feat(lists): task and shopping-list note types with running total
dev / Build debug APK (push) Canceled after 15m52s
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:
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
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user