feat(lists): task and shopping-list note types with running total
dev / Build debug APK (push) Canceled after 15m52s

NoteType (TEXT / TASK_LIST / SHOPPING_LIST) persists in an additive
NoteEntity.typeKey column (ObjectBox auto-migrates; old rows = TEXT).
List bodies stay GitHub-flavoured '- [ ]' lines so search, field
encryption, backups (defaulted noteType) and Trash keep working.

Editor: checklist + basket buttons convert any note; rows are uniform
underlined line fields (13sp) - product, 'Quan.' quantity (defaults to
1 on blur), and POS-style price showing raw cents while focused and
$1.23 on focus loss. Sticky total bar sums qty x price of checked
rows in integer cents via an explicit {q.. p..} end-of-line marker so
product text is never scanned for numbers.

Fixes found in device testing: cards rendered raw markdown for list
notes stranded as TEXT by partial builds - read-time Note.inferListType
now heals them; quantity field was clipped invisible (64dp vs the 48dp
icon target) - replaced by the free-text line; the serializer emitted
a bare 'q' slot (broken '{q p1.23}' markers, stray ' x' folds) - now
null-when-default. Add-tag suggestions rebuilt on flatMapLatest so the
autocomplete re-queries per keystroke.

versionCode 32->33, versionName 0.3.8.0, APP_VERSION in lockstep.
This commit is contained in:
Incido Developer committed 2026-09-17 15:43:43 +12:00
1 parent 7b6187f99a
commit 32166a3100
14 files changed
+1044 -109

No files matched your search

@@ -0,0 +1,27 @@
package org.incido.domain.model
/**
* v0.3.8.0 — one row of a [NoteType.TASK_LIST] / [NoteType.SHOPPING_LIST]
* note while it is being edited. Rows live in the editor's UI state and
* are serialised back into `- [ ]` / `- [x]` content lines on every edit
* (see [Note.serializeListContent] / [Note.splitListContent]).
*/
data class ChecklistItem(
/** Item label; blank rows are skipped when serialising. */
val text: String,
/** Checkbox state — for shopping lists: "in the basket". */
val checked: Boolean = false,
/**
* Quantity as typed/picked (`""` = 1). Only meaningful for
* [NoteType.SHOPPING_LIST]; shopping rows offer a 1–9 picker so
* this stays tiny, but the parser accepts any small positive int.
*/
val quantity: String = "",
/**
* Price as entered, in CENTS DIGITS (`""` = none, `"199"` = $1.99 —
* supermarket-terminal style where the last two digits are cents).
* Only meaningful for [NoteType.SHOPPING_LIST]. Money maths runs
* on these integers so there is never binary-float drift.
*/
val cost: String = "",
)
@@ -24,6 +24,8 @@ data class Note(
val attachments: List<NoteAttachment> = emptyList(),
/** True only for notes moved to the Trash view; active-note queries exclude these rows. */
val isTrashed: Boolean = false,
/** v0.3.8.0 — which editor surface opens this note (see [NoteType]). */
val type: NoteType = NoteType.TEXT,
) {
/** Convenience: the first image attachment, or `null` if none. */
val firstImageAttachment: NoteAttachment?
@@ -107,5 +109,326 @@ data class Note(
else -> "$open open · $done done"
}
}
// -----------------------------------------------------------------
// v0.3.8.0 — task / shopping list parsing + serialisation.
//
// A list note's content is an optional header block (the title /
// preamble kept as plain lines) followed by GitHub-style checkbox
// lines. Shopping-list rows carry quantity + per-item price in an
// explicit end-of-line marker so the PRODUCT TEXT IS NEVER
// SCANNED FOR NUMBERS (a product called "Battery AA 3" or
// "Poster 50 x 60" is safe):
//
// - [ ] Milk no qty / price yet
// - [ ] Ham {p12.99} price only (qty 1)
// - [ ] Eggs {q12 p2.40} 12 × $2.40
//
// Hand-typed / legacy lines stay importable (Development Plan
// §6.1's trailing-numeric-token idea): `Milk 3.50` reads as a
// price, `Eggs 12 x 2.40` as qty × price. Those forms survive in
// task lists, where each row is just `- [ ] <text>`.
// -----------------------------------------------------------------
private val CHECKLIST_LINE: Regex = Regex("""^\s*-\s+\[([ xX])]\s*(.*)$""")
/** `Product {q12 p2.40}` / `{p2.40}` / `{q12}` (anchored, greedy-safe). */
private val BRACED_QP: Regex =
Regex("""^(.*?)\s*\{\s*(?:q(\d{1,3}))?\s*(?:p([\d.,]{1,12}))?\s*\}$""")
/** Legacy: `Product 12 x 2.40` (also `12x2.40`, `×`). A decimal on
* the price keeps lookalikes like "Poster 50 x 60" as plain text. */
private val LEGACY_QTY_PRICE: Regex =
Regex("""^(.+?)\s+(\d{1,3})\s*[xX×]\s*(\d{1,9}[.,]\d{1,2})$""")
/** Legacy (§6.1): `Product 3.50`. Decimal point REQUIRED, so a
* product named "Battery AA 3" is never mistaken for a price. */
private val TRAILING_COST: Regex = Regex("""^(.*\S)\s+(\d{1,9}[.,]\d{1,2})$""")
private val COST_PATTERN: Regex = Regex("""\d{1,9}(?:\.\d{1,2})?""")
/**
* Canonicalise a raw monetary amount token: trims, accepts `,` as
* decimal separator, tolerates a trailing `.` mid-typing, and
* returns `""` for anything that isn't a plain positive number
* with at most two decimals.
*/
fun normaliseCost(raw: String): String {
val trimmed = raw.trim().replace(',', '.')
if (trimmed.isEmpty()) return ""
val candidate = if (trimmed.endsWith(".")) trimmed.dropLast(1) else trimmed
return if (candidate.matches(COST_PATTERN)) candidate else ""
}
/**
* Convert a canonical amount ("2.40", "5", "0.05") into CENTS
* DIGITS ("240", "500", "5"). Returns `""` for invalid input.
*/
fun priceDigitsFromAmount(amount: String): String {
val canonical = normaliseCost(amount)
if (canonical.isEmpty()) return ""
val parts = canonical.split('.')
val units = parts[0].toLongOrNull() ?: return ""
val cents = if (parts.size > 1) parts[1].padEnd(2, '0').toLongOrNull() ?: return "" else 0L
val total = units * 100 + cents
if (total <= 0L) return ""
return total.toString()
}
/** Inverse: cents digits ("199") → canonical amount ("1.99"); "" → "". */
fun amountFromPriceDigits(digits: String): String {
val clean = digits.filter { it.isDigit() }.trimStart('0')
if (clean.isEmpty()) return ""
return clean.padStart(3, '0').let { "${it.dropLast(2)}.${it.takeLast(2)}" }
}
/** Digit-only normalisation of the quantity picker/keypad input. */
fun normaliseQuantity(raw: String): String =
raw.filter { it.isDigit() }.take(3).trimStart('0')
/** Digit-only normalisation of the price input ("2.4" → "24"). */
fun normalisePriceInput(raw: String): String =
raw.filter { it.isDigit() }.take(9).trimStart('0')
/** Numeric quantity of a row (blank ⇒ 1). */
fun quantityOf(item: ChecklistItem): Int =
item.quantity.toIntOrNull()?.coerceIn(1, 999) ?: 1
/** Per-line total in cents: quantity × unit price. */
fun lineTotalCents(item: ChecklistItem): Long =
quantityOf(item) * (item.cost.toLongOrNull() ?: 0L)
/**
* Split [content] into (header, items) for the structured list
* editors.
*
* When marker lines (`- [ ] …`) exist, the header is everything
* before the first one and every marker line becomes an item;
* other non-blank lines below the first marker become unchecked
* items so nothing is silently dropped. Without any marker line
* (a plain note being converted), the first non-blank line is
* kept as the title/header and the remaining non-blank lines
* become unchecked items.
*
* [interpretCosts] (shopping lists only) strips a trailing
* numeric token off each item text into [ChecklistItem.cost].
*/
fun splitListContent(
content: String,
interpretCosts: Boolean,
): Pair<String, List<ChecklistItem>> {
val lines = content.split('\n')
val firstMarker = lines.indexOfFirst { CHECKLIST_LINE.matches(it) }
val headerLines: List<String>
val itemLines: List<String>
if (firstMarker >= 0) {
headerLines = lines.take(firstMarker)
itemLines = lines.drop(firstMarker)
} else {
val titleIdx = lines.indexOfFirst { it.isNotBlank() }
headerLines = if (titleIdx >= 0) listOf(lines[titleIdx]) else emptyList()
itemLines = if (titleIdx >= 0) lines.drop(titleIdx + 1) else lines
}
val items = itemLines
.filter { it.isNotBlank() }
.map { line ->
val match = CHECKLIST_LINE.matchEntire(line)
var text: String
val checked: Boolean
if (match != null) {
checked = match.groupValues[1].equals("x", ignoreCase = true)
text = match.groupValues[2].trim()
} else {
checked = false
text = line.trim()
}
var quantity = ""
var cost = "" // cents digits
if (interpretCosts) {
val braced = BRACED_QP.matchEntire(text)
val legacyQtyPrice = if (braced == null) LEGACY_QTY_PRICE.matchEntire(text) else null
val legacyPrice = if (braced == null && legacyQtyPrice == null)
TRAILING_COST.matchEntire(text) else null
when {
braced != null -> {
// Structured form: everything before the
// marker is PRODUCT TEXT, unexamined.
val q = parsedQuantity(braced.groupValues[2])
val p = parsedPrice(braced.groupValues[3])
if (q.isEmpty() && p.isEmpty()) {
// "{}" or invalid slots — not a marker after all.
} else {
text = braced.groupValues[1].trim()
quantity = q
cost = p
}
}
legacyQtyPrice != null -> {
text = legacyQtyPrice.groupValues[1].trim()
quantity = parsedQuantity(legacyQtyPrice.groupValues[2])
cost = parsedPrice(legacyQtyPrice.groupValues[3])
}
legacyPrice != null -> {
text = legacyPrice.groupValues[1].trim()
cost = parsedPrice(legacyPrice.groupValues[2])
}
}
}
ChecklistItem(text = text, checked = checked, quantity = quantity, cost = cost)
}
return headerLines.joinToString("\n").trim() to items
}
/** Normalise a parsed quantity token (blank / 1 ⇒ default ""). */
private fun parsedQuantity(raw: String): String {
val n = normaliseQuantity(raw)
return if (n == "1" || n.isEmpty()) "" else n
}
/** Normalise a parsed amount token into cents digits. */
private fun parsedPrice(raw: String): String = priceDigitsFromAmount(raw)
/**
* Inverse of [splitListContent]: rebuild the note content from a
* header + item rows. Blank rows are skipped. Shopping rows
* serialise quantity + price into the `{q… p…}` marker (qty 1 is
* omitted); converting BACK to a task list folds the values into
* legacy text tokens (`Milk 2 x 3.90`) so they survive a
* round-trip through plain-text mode.
*/
fun serializeListContent(
header: String,
items: List<ChecklistItem>,
type: NoteType,
): String {
val isShopping = type == NoteType.SHOPPING_LIST
val bodyLines = items.mapNotNull { item ->
val amount = amountFromPriceDigits(item.cost)
// v0.3.8.0 FIX: parsedQuantity folds the default (1) to
// "" — a plain String, never null. Without takeIf, the
// shopping branch emitted a bare "q" slot (broken
// "{q p1.23}" markers) and the task branch folded a
// stray " x" onto every row. Null means "no quantity".
val qtyDigits = parsedQuantity(item.quantity).takeIf { it.isNotEmpty() }
val rawText = item.text.trim()
val rowText: String
if (isShopping) {
val slots = listOfNotNull(
qtyDigits?.let { "q$it" },
amount.ifEmpty { null }?.let { "p$it" },
)
rowText = if (slots.isEmpty()) rawText
else "$rawText {${slots.joinToString(" ")}}"
} else {
// Task list: fold structured values back into text so
// switching modes never silently drops them.
rowText = when {
rawText.isEmpty() && qtyDigits != null && amount.isNotEmpty() ->
"$qtyDigits x $amount"
rawText.isEmpty() && amount.isNotEmpty() -> amount
qtyDigits != null && amount.isNotEmpty() -> "$rawText $qtyDigits x $amount"
qtyDigits != null -> "$rawText $qtyDigits x"
amount.isNotEmpty() -> "$rawText $amount"
else -> rawText
}
}
when {
rowText.isBlank() -> null
else -> "- [" + (if (item.checked) "x" else " ") + "] " + rowText
}
}
val headerTrimmed = header.trimEnd()
return when {
bodyLines.isEmpty() -> headerTrimmed
headerTrimmed.isEmpty() -> bodyLines.joinToString("\n")
else -> headerTrimmed + "\n" + bodyLines.joinToString("\n")
}
}
/** Running shopping total in cents: quantity × price, CHECKED rows only. */
fun shoppingTotalCents(items: List<ChecklistItem>): Long =
items.filter { it.checked }.sumOf { lineTotalCents(it) }
/** Running shopping total as dollars (display helper). */
fun shoppingTotal(items: List<ChecklistItem>): Double =
shoppingTotalCents(items) / 100.0
/** "$0.00"-style display string for entered cents digits. */
fun formatMoney(centsDigits: String): String {
val clean = centsDigits.filter { it.isDigit() }.trimStart('0')
return "$" + if (clean.isEmpty()) "0.00" else amountFromPriceDigits(clean)
}
/**
* Card-friendly rendering for structured note types: (title, body)
* WITHOUT any markdown syntax. Title is the list header's first
* non-blank line (or "Untitled"); body is the item names joined
* with " · ", shopping rows carrying " ×qty" (when ≠ 1) and
* " @$price" suffixes. Plain-text notes keep using
* [titleAndBody] untouched.
*/
fun cardPresentation(content: String, type: NoteType): Pair<String, String> {
val isShopping = type == NoteType.SHOPPING_LIST
val (header, items) = splitListContent(
content,
interpretCosts = isShopping,
)
val title = header.lineSequence()
.firstOrNull { it.isNotBlank() }?.trim() ?: UNTITLED
val parts = items.mapNotNull { item ->
val text = item.text.trim()
if (text.isEmpty()) return@mapNotNull null
val qty = quantityOf(item)
val amount = if (isShopping) amountFromPriceDigits(item.cost) else ""
buildString {
append(text)
if (isShopping && qty > 1) append(" \u00d7$qty")
if (isShopping && amount.isNotEmpty()) {
append(" @")
append(amount)
}
}
}
return title to parts.joinToString(" \u00b7 ")
}
/**
* v0.3.8.0 FIX — heal notes stranded as [NoteType.TEXT] by builds
* that saved list content before the `typeKey` column existed (or
* by a partial write of the new feature). Returns the list type
* implied by [content], or null when the body is NOT unambiguously
* a checklist:
*
* * The first non-blank line is a header ONLY if it is not itself
* a checkbox line (headerless lists start straight at `- [ ]`).
* * EVERY remaining non-blank line must match [CHECKLIST_LINE]
* and at least one must exist — prose + an occasional hand-typed
* `- [ ]` stays plain TEXT.
* * Any line carrying a `{q…/p…}` marker implies SHOPPING_LIST.
*/
fun inferListType(content: String): NoteType? {
val lines = content.lines()
val firstNonBlank = lines.indexOfFirst { it.isNotBlank() }
if (firstNonBlank < 0) return null
val startIdx = if (CHECKLIST_LINE.matches(lines[firstNonBlank])) {
firstNonBlank // headerless list
} else {
firstNonBlank + 1 // first line is the header
}
var sawMarker = false
var sawBrace = false
for (i in startIdx until lines.size) {
val line = lines[i]
if (line.isBlank()) continue
val match = CHECKLIST_LINE.matchEntire(line) ?: return null
sawMarker = true
if (BRACED_QP.containsMatchIn(match.groupValues[2])) sawBrace = true
}
return when {
!sawMarker -> null
sawBrace -> NoteType.SHOPPING_LIST
else -> NoteType.TASK_LIST
}
}
}
}
@@ -0,0 +1,31 @@
package org.incido.domain.model
/**
* v0.3.8.0 — which editor surface a note body uses.
*
* The note text itself stays the single source of truth: task and
* shopping lists are persisted as GitHub-flavoured checkbox lines
* (`- [ ] item` / `- [x] item`, with an optional trailing numeric
* cost token on shopping lists), so free-text search, at-rest
* encryption, backups, and the inline `- [ ]` markdown already
* supported in [Note.checklistCounts] keep working untouched.
*
* Stored as a `Short` in ObjectBox — additive-safe migration from
* the pre-v0.3.8.0 schema (rows without the column default to [TEXT]).
*/
enum class NoteType(val storageKey: Short) {
/** Free-form body edited in the plain multi-line field. */
TEXT(0),
/** Editable checklist: checkbox + item text rows. */
TASK_LIST(1),
/** Checklist plus a per-item cost (number pad) and a running total. */
SHOPPING_LIST(2);
companion object {
/** Convert from the stored [Short] back to the enum, defaulting to [TEXT]. */
fun fromStorageKey(key: Short): NoteType =
values().firstOrNull { it.storageKey == key } ?: TEXT
}
}