feat: v0.3.0.0 — hashtags (visible on editor) + bolder colour accent + centred title + nav drawer + new version scheme
v0.3.0.0 bundles four user-facing features, the plan-compliance polish
that was deferred from v0.2, and a permanent change to how we name
releases going forward.
VERSION SCHEME (app/build.gradle.kts)
- versionName = '0.3.0.0' (MAJOR.MINOR.MAINTENANCE.EMERGENCY)
- versionCode = 5
- New gradle taskGraph validator fails the build if versionName
doesn't match ^\d+\.\d+\.\d+\.\d+$ — we can't accidentally
regress the scheme.
- History re-keyed across README, Plan §10, CONTRIBUTING.md.
HASHTAGS
- value class Hashtag (domain/model) with normalise/parseOrNull
helpers; pattern: ^[a-z0-9][a-z0-9._-]{0,30}$
- data class HashtagUsage (name, noteCount, lastUsedAt)
- sealed class NoteFilter { Home, Favorites, Untagged, ByTag(name) }
- Note gains hashtags: List<String> (sorted ascending)
- Repository:
- new entities HashtagEntity (@Index on name) and
NoteHashtagCrossRef (many-to-many junction)
- new methods: observeFavorites / observeUntagged /
observeNotesForHashtag / observeHashtagsByRecentUse /
observeAllHashtags / searchHashtags / addHashtag / removeHashtag
- search() now matches content OR hashtag-name (case-insensitive)
- ObjectBox queries use explicit StringOrder + type annotations
(kapt's stubs are finicky around Property<String> overloads)
UI
- CenterAlignedTopAppBar on both list and editor screens
- List:
- Hamburger top-left opens a ModalNavigationDrawer (Home /
Favorites / Untagged / divider / scrollable Recent tags)
- Drawer selection drives a NoteFilter state held at root
- Search bar visible only when filter == Home
- NoteCard redesign — 14 dp vertical gradient stripe +
tinted surface (12 % colour blend) + 10 dp corner chip
- Empty-state copy is filter-aware
- Editor:
- Persistent hashtag chip row above the text field
- Tag # icon in the top bar + '+ add' chip opens a ModalBottomSheet
- Autocomplete suggestions live from repository.searchHashtags
- '+ Create name' button when the typed value is valid + new
- Snackbar 'Maximum 5 tags reached.' when the cap is hit
- Reconciled on save via addHashtag / removeHashtag diff
DOCS
- README v0.3.0.0 section + re-keyed changelog
- Development Plan §10 history re-keyed (0.1.0.0 / 0.1.1.0 /
0.2.0.0 / 0.2.0.1 / 0.3.0.0)
- CONTRIBUTING.md release-process note updated for the new scheme
VERIFIED
- ./gradlew assembleDebug assembleRelease both green
- Debug 25.7 MB, release 19.8 MB (v2-signed)
- versionCode=5, versionName='0.3.0.0'
- No INTERNET permission
- Validator regression: setting versionName='0.3' causes
assembleDebug to fail with the new scheme error message
This commit is contained in:
1 parent
84900838f7
commit
d616ce3021
20 files changed
+1285
-251
No files matched your search
@@ -0,0 +1,19 @@
|
||||
package org.incido.data.entity
|
||||
|
||||
import io.objectbox.annotation.Entity
|
||||
import io.objectbox.annotation.Id
|
||||
import io.objectbox.annotation.Index
|
||||
|
||||
/**
|
||||
* A single normalised hashtag. Case-insensitive uniqueness is
|
||||
* enforced at the repository layer (`NoteRepositoryImpl.addHashtag`
|
||||
* uses `findFirst` and reuses the existing row); the index here just
|
||||
* speeds up the lookup.
|
||||
*
|
||||
* The "many-to-many" link to notes lives in [NoteHashtagCrossRef].
|
||||
*/
|
||||
@Entity
|
||||
data class HashtagEntity(
|
||||
@Id var id: Long = 0,
|
||||
@Index var name: String = "",
|
||||
)
|
||||
@@ -0,0 +1,19 @@
|
||||
package org.incido.data.entity
|
||||
|
||||
import io.objectbox.annotation.Entity
|
||||
import io.objectbox.annotation.Id
|
||||
import io.objectbox.annotation.Index
|
||||
|
||||
/**
|
||||
* Many-to-many junction between [NoteEntity] and [HashtagEntity].
|
||||
* Each row is one (`noteId`, `hashtagId`) pair.
|
||||
*
|
||||
* Both columns are indexed for fast lookups in either direction
|
||||
* (notes for a hashtag, hashtags for a note).
|
||||
*/
|
||||
@Entity
|
||||
data class NoteHashtagCrossRef(
|
||||
@Id var id: Long = 0,
|
||||
@Index var noteId: Long = 0,
|
||||
@Index var hashtagId: Long = 0,
|
||||
)
|
||||
@@ -2,72 +2,113 @@ package org.incido.data.repository
|
||||
|
||||
import io.objectbox.BoxStore
|
||||
import io.objectbox.kotlin.boxFor
|
||||
import io.objectbox.query.QueryBuilder
|
||||
import io.objectbox.reactive.DataSubscription
|
||||
import kotlinx.coroutines.channels.awaitClose
|
||||
import kotlinx.coroutines.flow.Flow
|
||||
import kotlinx.coroutines.flow.callbackFlow
|
||||
import kotlinx.coroutines.flow.flowOn
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import org.incido.data.entity.HashtagEntity
|
||||
import org.incido.data.entity.HashtagEntity_
|
||||
import org.incido.data.entity.NoteEntity
|
||||
import org.incido.data.entity.NoteEntity_
|
||||
import org.incido.data.entity.NoteHashtagCrossRef
|
||||
import org.incido.data.entity.NoteHashtagCrossRef_
|
||||
import org.incido.data.entity.toDomain
|
||||
import org.incido.data.entity.toEntity
|
||||
import org.incido.domain.model.Hashtag
|
||||
import org.incido.domain.model.HashtagUsage
|
||||
import org.incido.domain.model.Note
|
||||
import org.incido.domain.repository.NoteRepository
|
||||
|
||||
/**
|
||||
* ObjectBox-backed implementation of [NoteRepository]. All writes are
|
||||
* dispatched to `Default`; reads use ObjectBox's reactive subscription so
|
||||
* the UI auto-refreshes whenever a row changes (F7).
|
||||
* ObjectBox-backed implementation of [NoteRepository]. Hashtags live
|
||||
* in two extra tables (`HashtagEntity`, `NoteHashtagCrossRef`); every
|
||||
* "list of notes" snapshot here loads the cross-ref + tags in one
|
||||
* pass so callers get fully-populated [Note.hashtags] lists.
|
||||
*
|
||||
* Sort order is `isFavorite DESC, updatedAt DESC` for both [observeAll] and
|
||||
* [search] so favourites always float to the top.
|
||||
* Sort order for [observeAll] / [search] / filter streams:
|
||||
* `isFavorite DESC, updatedAt DESC`.
|
||||
*
|
||||
* Note: ObjectBox 4.0.3's Kotlin stubs are finicky around
|
||||
* `QueryBuilder.equal(Property, String, ...)` — passing the
|
||||
* `StringOrder` argument explicitly is the most reliable way to call it.
|
||||
*/
|
||||
class NoteRepositoryImpl(
|
||||
private val boxStore: BoxStore,
|
||||
) : NoteRepository {
|
||||
|
||||
private val box = boxStore.boxFor<NoteEntity>()
|
||||
private val noteBox = boxStore.boxFor<NoteEntity>()
|
||||
private val tagBox = boxStore.boxFor<HashtagEntity>()
|
||||
private val xrefBox = boxStore.boxFor<NoteHashtagCrossRef>()
|
||||
|
||||
// ---------------------------------------------------------------------
|
||||
// List / observation streams
|
||||
// ---------------------------------------------------------------------
|
||||
|
||||
override fun observeAll(): Flow<List<Note>> = callbackFlow {
|
||||
trySend(sortedSnapshot(""))
|
||||
|
||||
val subscription = box
|
||||
.query()
|
||||
.build()
|
||||
.subscribe()
|
||||
.observer { trySend(sortedSnapshot("")) }
|
||||
|
||||
awaitClose { subscription.cancel() }
|
||||
trySend(snapshotAll())
|
||||
val sub = noteBox.query().build().subscribe().observer { trySend(snapshotAll()) }
|
||||
awaitClose { sub.cancel() }
|
||||
}.flowOn(Dispatchers.Default)
|
||||
|
||||
override fun search(query: String): Flow<List<Note>> = callbackFlow {
|
||||
trySend(sortedSnapshot(query))
|
||||
trySend(snapshotSearch(query))
|
||||
val sub = noteBox.query().build().subscribe().observer { trySend(snapshotSearch(query)) }
|
||||
awaitClose { sub.cancel() }
|
||||
}.flowOn(Dispatchers.Default)
|
||||
|
||||
val subscription = if (query.isBlank()) {
|
||||
box.query().build().subscribe()
|
||||
} else {
|
||||
box.query()
|
||||
.contains(NoteEntity_.content, query, io.objectbox.query.QueryBuilder.StringOrder.CASE_INSENSITIVE)
|
||||
.build()
|
||||
.subscribe()
|
||||
}.observer { trySend(sortedSnapshot(query)) }
|
||||
override fun observeFavorites(): Flow<List<Note>> = callbackFlow {
|
||||
trySend(snapshotFavorites())
|
||||
val sub = noteBox.query().build().subscribe().observer { trySend(snapshotFavorites()) }
|
||||
awaitClose { sub.cancel() }
|
||||
}.flowOn(Dispatchers.Default)
|
||||
|
||||
awaitClose { subscription.cancel() }
|
||||
override fun observeUntagged(): Flow<List<Note>> = callbackFlow {
|
||||
trySend(snapshotUntagged())
|
||||
val sub = noteBox.query().build().subscribe().observer { trySend(snapshotUntagged()) }
|
||||
awaitClose { sub.cancel() }
|
||||
}.flowOn(Dispatchers.Default)
|
||||
|
||||
override fun observeNotesForHashtag(name: String): Flow<List<Note>> = callbackFlow {
|
||||
trySend(snapshotForHashtag(name))
|
||||
val sub = noteBox.query().build().subscribe().observer { trySend(snapshotForHashtag(name)) }
|
||||
awaitClose { sub.cancel() }
|
||||
}.flowOn(Dispatchers.Default)
|
||||
|
||||
override fun observeHashtagsByRecentUse(): Flow<List<HashtagUsage>> = callbackFlow {
|
||||
trySend(hashtagUsageSnapshot())
|
||||
val sub = noteBox.query().build().subscribe().observer { trySend(hashtagUsageSnapshot()) }
|
||||
awaitClose { sub.cancel() }
|
||||
}.flowOn(Dispatchers.Default)
|
||||
|
||||
override fun observeAllHashtags(): Flow<List<String>> = callbackFlow {
|
||||
trySend(allHashtagsSnapshot().sorted())
|
||||
val sub = noteBox.query().build().subscribe().observer {
|
||||
trySend(allHashtagsSnapshot().sorted())
|
||||
}
|
||||
awaitClose { sub.cancel() }
|
||||
}.flowOn(Dispatchers.Default)
|
||||
|
||||
override fun searchHashtags(prefix: String): Flow<List<String>> = callbackFlow {
|
||||
trySend(searchHashtagsSnapshot(prefix))
|
||||
val sub = noteBox.query().build().subscribe().observer {
|
||||
trySend(searchHashtagsSnapshot(prefix))
|
||||
}
|
||||
awaitClose { sub.cancel() }
|
||||
}.flowOn(Dispatchers.Default)
|
||||
|
||||
override fun observeById(id: Long): Flow<Note?> = callbackFlow {
|
||||
trySend(box.get(id)?.toDomain())
|
||||
|
||||
val subscription = box
|
||||
.query()
|
||||
.build()
|
||||
.subscribe()
|
||||
.observer { trySend(box.get(id)?.toDomain()) }
|
||||
|
||||
awaitClose { subscription.cancel() }
|
||||
trySend(noteByIdSnapshot(id))
|
||||
val sub = noteBox.query().build().subscribe().observer { trySend(noteByIdSnapshot(id)) }
|
||||
awaitClose { sub.cancel() }
|
||||
}.flowOn(Dispatchers.Default)
|
||||
|
||||
// ---------------------------------------------------------------------
|
||||
// Writes
|
||||
// ---------------------------------------------------------------------
|
||||
|
||||
override suspend fun upsert(note: Note): Note {
|
||||
val now = System.currentTimeMillis()
|
||||
val toPersist = if (note.id == 0L) {
|
||||
@@ -75,39 +116,213 @@ class NoteRepositoryImpl(
|
||||
} else {
|
||||
note.copy(updatedAt = now).toEntity()
|
||||
}
|
||||
val assignedId = box.put(toPersist)
|
||||
val existing = box.get(assignedId)
|
||||
return existing?.toDomain() ?: note.copy(id = assignedId)
|
||||
val assignedId = noteBox.put(toPersist)
|
||||
return noteBox.get(assignedId)?.toDomain() ?: note.copy(id = assignedId)
|
||||
}
|
||||
|
||||
override suspend fun delete(id: Long) {
|
||||
box.remove(id)
|
||||
noteBox.remove(id)
|
||||
val orphanXrefs: List<NoteHashtagCrossRef> = xrefBox.query()
|
||||
.equal(NoteHashtagCrossRef_.noteId, id)
|
||||
.build()
|
||||
.find()
|
||||
if (orphanXrefs.isNotEmpty()) {
|
||||
xrefBox.remove(*orphanXrefs.map { it.id }.toLongArray())
|
||||
}
|
||||
}
|
||||
|
||||
override suspend fun setFavorite(id: Long, isFavorite: Boolean) {
|
||||
val entity = box.get(id) ?: return
|
||||
val entity = noteBox.get(id) ?: return
|
||||
if (entity.isFavorite == isFavorite) return
|
||||
entity.isFavorite = isFavorite
|
||||
box.put(entity)
|
||||
noteBox.put(entity)
|
||||
}
|
||||
|
||||
/**
|
||||
* Snapshot helper. If [query] is non-blank, only notes whose content
|
||||
* contains it (case-insensitive) are included; otherwise all notes.
|
||||
* The result is sorted favourites-first, then newest-first.
|
||||
*/
|
||||
private fun sortedSnapshot(query: String): List<Note> {
|
||||
val raw = if (query.isBlank()) {
|
||||
box.all
|
||||
} else {
|
||||
box.query()
|
||||
.contains(NoteEntity_.content, query, io.objectbox.query.QueryBuilder.StringOrder.CASE_INSENSITIVE)
|
||||
.build()
|
||||
.find()
|
||||
}
|
||||
return raw.sortedWith(
|
||||
override suspend fun addHashtag(noteId: Long, name: String) {
|
||||
val normalised = Hashtag.normalise(name)
|
||||
if (!normalised.matches(Regex("^[a-z0-9][a-z0-9._-]{0,30}$"))) return
|
||||
|
||||
val tag: HashtagEntity = tagBox.query()
|
||||
.equal(HashtagEntity_.name, normalised, QueryBuilder.StringOrder.CASE_INSENSITIVE)
|
||||
.build()
|
||||
.findFirst() ?: run {
|
||||
tagBox.put(HashtagEntity(name = normalised))
|
||||
// Re-query to get the freshly-inserted row (with its new id).
|
||||
tagBox.query()
|
||||
.equal(HashtagEntity_.name, normalised, QueryBuilder.StringOrder.CASE_INSENSITIVE)
|
||||
.build()
|
||||
.findFirst()
|
||||
} ?: return
|
||||
|
||||
val existing: NoteHashtagCrossRef? = xrefBox.query()
|
||||
.equal(NoteHashtagCrossRef_.noteId, noteId)
|
||||
.equal(NoteHashtagCrossRef_.hashtagId, tag.id)
|
||||
.build()
|
||||
.findFirst()
|
||||
if (existing != null) return
|
||||
|
||||
xrefBox.put(NoteHashtagCrossRef(noteId = noteId, hashtagId = tag.id))
|
||||
}
|
||||
|
||||
override suspend fun removeHashtag(noteId: Long, name: String) {
|
||||
val normalised = Hashtag.normalise(name)
|
||||
val tag: HashtagEntity = tagBox.query()
|
||||
.equal(HashtagEntity_.name, normalised, QueryBuilder.StringOrder.CASE_INSENSITIVE)
|
||||
.build()
|
||||
.findFirst() ?: return
|
||||
val xref: NoteHashtagCrossRef = xrefBox.query()
|
||||
.equal(NoteHashtagCrossRef_.noteId, noteId)
|
||||
.equal(NoteHashtagCrossRef_.hashtagId, tag.id)
|
||||
.build()
|
||||
.findFirst() ?: return
|
||||
xrefBox.remove(xref.id)
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------
|
||||
// Snapshots
|
||||
// ---------------------------------------------------------------------
|
||||
|
||||
/** Map of noteId -> ordered list of hashtag names. */
|
||||
private fun hashtagsByNoteId(): Map<Long, List<String>> {
|
||||
val xrefs: List<NoteHashtagCrossRef> = xrefBox.all
|
||||
if (xrefs.isEmpty()) return emptyMap()
|
||||
val tagIds: Set<Long> = xrefs.map { it.hashtagId }.toSet()
|
||||
val tagById: Map<Long, String> = tagIds.associateWith { id ->
|
||||
tagBox.get(id)?.name ?: ""
|
||||
}.filterValues { it.isNotEmpty() }
|
||||
|
||||
return xrefs.groupBy { it.noteId }
|
||||
.mapValues { (_, refs) ->
|
||||
refs.mapNotNull { tagById[it.hashtagId] }.sorted()
|
||||
}
|
||||
}
|
||||
|
||||
private fun decorate(entities: List<NoteEntity>): List<Note> {
|
||||
val tags = hashtagsByNoteId()
|
||||
return entities.sortedWith(
|
||||
compareByDescending<NoteEntity> { it.isFavorite }
|
||||
.thenByDescending { it.updatedAt }
|
||||
).map { it.toDomain() }
|
||||
).map { e ->
|
||||
val base = e.toDomain()
|
||||
base.copy(hashtags = tags[e.id].orEmpty())
|
||||
}
|
||||
}
|
||||
|
||||
private fun snapshotAll(): List<Note> = decorate(noteBox.all)
|
||||
|
||||
private fun snapshotSearch(query: String): List<Note> {
|
||||
val q = query.trim()
|
||||
if (q.isEmpty()) return snapshotAll()
|
||||
|
||||
// Match against content (contains, case-insensitive).
|
||||
val contentMatches: List<Long> = noteBox.query()
|
||||
.contains(NoteEntity_.content, q, QueryBuilder.StringOrder.CASE_INSENSITIVE)
|
||||
.build()
|
||||
.find()
|
||||
.map { it.id }
|
||||
|
||||
// Match against hashtag names (case-insensitive exact equality).
|
||||
val matchingTag: HashtagEntity? = tagBox.query()
|
||||
.equal(HashtagEntity_.name, q, QueryBuilder.StringOrder.CASE_INSENSITIVE)
|
||||
.build()
|
||||
.findFirst()
|
||||
val tagMatches: List<Long> = if (matchingTag == null) emptyList() else {
|
||||
xrefBox.query()
|
||||
.equal(NoteHashtagCrossRef_.hashtagId, matchingTag.id)
|
||||
.build()
|
||||
.find()
|
||||
.map { it.noteId }
|
||||
}
|
||||
|
||||
val allIds: Set<Long> = (contentMatches + tagMatches).toSet()
|
||||
if (allIds.isEmpty()) return emptyList()
|
||||
val entities: List<NoteEntity> = allIds.mapNotNull { noteBox.get(it) }
|
||||
return decorate(entities)
|
||||
}
|
||||
|
||||
private fun snapshotFavorites(): List<Note> {
|
||||
val favEntities: List<NoteEntity> = noteBox.query()
|
||||
.equal(NoteEntity_.isFavorite, true)
|
||||
.build()
|
||||
.find()
|
||||
return decorate(favEntities)
|
||||
}
|
||||
|
||||
private fun snapshotUntagged(): List<Note> {
|
||||
val noteIdsWithTags: Set<Long> = xrefBox.all.map { it.noteId }.toSet()
|
||||
val untaggedEntities: List<NoteEntity> = noteBox.all.filter { it.id !in noteIdsWithTags }
|
||||
return decorate(untaggedEntities)
|
||||
}
|
||||
|
||||
private fun snapshotForHashtag(name: String): List<Note> {
|
||||
val normalised = Hashtag.normalise(name)
|
||||
val tag: HashtagEntity = tagBox.query()
|
||||
.equal(HashtagEntity_.name, normalised, QueryBuilder.StringOrder.CASE_INSENSITIVE)
|
||||
.build()
|
||||
.findFirst() ?: return emptyList()
|
||||
val xrefs: List<NoteHashtagCrossRef> = xrefBox.query()
|
||||
.equal(NoteHashtagCrossRef_.hashtagId, tag.id)
|
||||
.build()
|
||||
.find()
|
||||
val noteIds: Set<Long> = xrefs.map { it.id }.let { _ -> xrefs.map { it.noteId }.toSet() }
|
||||
if (noteIds.isEmpty()) return emptyList()
|
||||
val entities: List<NoteEntity> = noteIds.mapNotNull { noteBox.get(it) }
|
||||
return decorate(entities)
|
||||
}
|
||||
|
||||
private fun noteByIdSnapshot(id: Long): Note? {
|
||||
val entity = noteBox.get(id) ?: return null
|
||||
val tags = hashtagsByNoteId()[id].orEmpty()
|
||||
return entity.toDomain().copy(hashtags = tags)
|
||||
}
|
||||
|
||||
/** Build [HashtagUsage] for every distinct tag, sorted by lastUsedAt DESC. */
|
||||
private fun hashtagUsageSnapshot(): List<HashtagUsage> {
|
||||
val xrefs: List<NoteHashtagCrossRef> = xrefBox.all
|
||||
if (xrefs.isEmpty()) return emptyList()
|
||||
|
||||
// For each hashtagId, accumulate (lastUsedAt, count).
|
||||
data class Agg(var lastUsedAt: Long, var count: Int)
|
||||
val aggregate = HashMap<Long, Agg>(xrefs.size)
|
||||
for (x in xrefs) {
|
||||
val note: NoteEntity = noteBox.get(x.noteId) ?: continue
|
||||
val cur = aggregate[x.hashtagId]
|
||||
if (cur == null) {
|
||||
aggregate[x.hashtagId] = Agg(note.updatedAt, 1)
|
||||
} else {
|
||||
if (note.updatedAt > cur.lastUsedAt) cur.lastUsedAt = note.updatedAt
|
||||
cur.count += 1
|
||||
}
|
||||
}
|
||||
return aggregate.mapNotNull { (tagId, agg) ->
|
||||
val tag: HashtagEntity = tagBox.get(tagId) ?: return@mapNotNull null
|
||||
HashtagUsage(name = tag.name, noteCount = agg.count, lastUsedAt = agg.lastUsedAt)
|
||||
}.sortedWith(
|
||||
compareByDescending<HashtagUsage> { it.lastUsedAt }
|
||||
.thenByDescending { it.noteCount }
|
||||
.thenBy { it.name }
|
||||
)
|
||||
}
|
||||
|
||||
private fun allHashtagsSnapshot(): List<String> =
|
||||
tagBox.all.map { it.name }
|
||||
|
||||
private fun searchHashtagsSnapshot(prefix: String): List<String> {
|
||||
val p = prefix.trim()
|
||||
if (p.isEmpty()) return allHashtagsSnapshot().sorted()
|
||||
|
||||
val byPrefix: List<HashtagEntity> = tagBox.query()
|
||||
.startsWith(HashtagEntity_.name, p.lowercase(), QueryBuilder.StringOrder.CASE_INSENSITIVE)
|
||||
.build()
|
||||
.find()
|
||||
|
||||
// Sort by usage count (most-used first), then name.
|
||||
val usageById: Map<Long, Int> = xrefBox.all.groupingBy { it.hashtagId }.eachCount()
|
||||
return byPrefix
|
||||
.sortedWith(
|
||||
compareByDescending<HashtagEntity> { usageById[it.id] ?: 0 }
|
||||
.thenBy { it.name }
|
||||
)
|
||||
.map { it.name }
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
package org.incido.domain.model
|
||||
|
||||
/**
|
||||
* A single hashtag, normalised: lowercase, no leading `#`, no
|
||||
* surrounding whitespace. The [name] is the on-disk identifier so
|
||||
* two notes tagging "Work" and "work" share a row.
|
||||
*
|
||||
* Allowed characters: `a-z`, `0-9`, `.`, `_`, `-`. Must start with an
|
||||
* alphanumeric. Length 1..31.
|
||||
*/
|
||||
@JvmInline
|
||||
value class Hashtag(val name: String) {
|
||||
init {
|
||||
require(name.matches(Regex("^[a-z0-9][a-z0-9._-]{0,30}$"))) {
|
||||
"Invalid hashtag name: \"$name\". Must match ^[a-z0-9][a-z0-9._-]{0,30}$"
|
||||
}
|
||||
}
|
||||
|
||||
/** Render with leading `#` for display. */
|
||||
fun displayName(): String = "#$name"
|
||||
|
||||
companion object {
|
||||
/** Normalise raw user input — trim, lowercase, strip leading `#`s. */
|
||||
fun normalise(raw: String): String =
|
||||
raw.trim().lowercase().trimStart('#').trim()
|
||||
|
||||
/** Try to parse; returns null when the input doesn't match the rules. */
|
||||
fun parseOrNull(raw: String): Hashtag? {
|
||||
val n = normalise(raw)
|
||||
return if (n.matches(Regex("^[a-z0-9][a-z0-9._-]{0,30}$"))) Hashtag(n) else null
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
package org.incido.domain.model
|
||||
|
||||
/**
|
||||
* Aggregate info about a single hashtag, for the nav drawer's "Recent
|
||||
* tags" list.
|
||||
*/
|
||||
data class HashtagUsage(
|
||||
val name: String,
|
||||
val noteCount: Int,
|
||||
val lastUsedAt: Long,
|
||||
)
|
||||
@@ -12,6 +12,8 @@ data class Note(
|
||||
val updatedAt: Long,
|
||||
val isFavorite: Boolean = false,
|
||||
val color: NoteColor = NoteColor.NONE,
|
||||
/** Tags attached to this note (normalised lowercase, sorted ascending). */
|
||||
val hashtags: List<String> = emptyList(),
|
||||
) {
|
||||
companion object {
|
||||
private const val UNTITLED = "Untitled"
|
||||
|
||||
@@ -0,0 +1,26 @@
|
||||
package org.incido.domain.model
|
||||
|
||||
/**
|
||||
* What the note list is currently showing. Drives both the
|
||||
* `NoteListScreen` body and the selected entry in the navigation
|
||||
* drawer.
|
||||
*
|
||||
* - [Home] — every note (the default). The search bar is enabled.
|
||||
* - [Favorites] — only notes with `isFavorite = true`. No search.
|
||||
* - [Untagged] — only notes that have zero hashtags. No search.
|
||||
* - [ByTag] — only notes tagged with [hashtag]. No search.
|
||||
*/
|
||||
sealed class NoteFilter {
|
||||
object Home : NoteFilter()
|
||||
object Favorites : NoteFilter()
|
||||
object Untagged : NoteFilter()
|
||||
data class ByTag(val hashtag: String) : NoteFilter()
|
||||
|
||||
/** Stable identifier used by the drawer for `selected` matching. */
|
||||
fun key(): String = when (this) {
|
||||
Home -> "home"
|
||||
Favorites -> "favorites"
|
||||
Untagged -> "untagged"
|
||||
is ByTag -> "tag:$hashtag"
|
||||
}
|
||||
}
|
||||
@@ -1,28 +1,26 @@
|
||||
package org.incido.domain.repository
|
||||
|
||||
import kotlinx.coroutines.flow.Flow
|
||||
import org.incido.domain.model.HashtagUsage
|
||||
import org.incido.domain.model.Note
|
||||
|
||||
/**
|
||||
* Persistence boundary for [Note]s. The UI layer depends on this interface
|
||||
* only — never on the ObjectBox-backed implementation in `:core:data`.
|
||||
*
|
||||
* Implementations are expected to:
|
||||
* - Return a [Flow] that emits whenever the underlying data changes,
|
||||
* so the list screen satisfies F7 (auto-refresh).
|
||||
* - Assign a fresh id (0 or 0L on construction) for new notes and use the
|
||||
* ObjectBox-managed id once persisted.
|
||||
* - Sort [observeAll] / [search] with favourites first, then by [Note.updatedAt]
|
||||
* descending.
|
||||
* Sort order for [observeAll] / [search]: `isFavorite DESC, updatedAt DESC`.
|
||||
* [search] additionally matches against any of the note's hashtags
|
||||
* (case-insensitive equality).
|
||||
*/
|
||||
interface NoteRepository {
|
||||
/** Stream of all notes, newest-first, favourites pinned to the top. */
|
||||
fun observeAll(): Flow<List<Note>>
|
||||
|
||||
/**
|
||||
* Stream of notes whose [Note.content] contains [query] (case-insensitive),
|
||||
* favourites first then newest-first. An empty / blank [query] returns
|
||||
* the same list as [observeAll].
|
||||
* Stream of notes whose [Note.content] contains [query] (case-insensitive)
|
||||
* OR whose hashtags contain [query] as one of the names. Favourites
|
||||
* first then newest-first. Blank [query] returns the same as
|
||||
* [observeAll].
|
||||
*/
|
||||
fun search(query: String): Flow<List<Note>>
|
||||
|
||||
@@ -37,4 +35,50 @@ interface NoteRepository {
|
||||
|
||||
/** Toggle the favourite flag on a single note. */
|
||||
suspend fun setFavorite(id: Long, isFavorite: Boolean)
|
||||
|
||||
// --- Filter streams (v0.3.0.0) ---
|
||||
/** Only notes with `isFavorite = true`, sorted by updatedAt DESC. */
|
||||
fun observeFavorites(): Flow<List<Note>>
|
||||
|
||||
/** Only notes that have zero hashtags, sorted by updatedAt DESC. */
|
||||
fun observeUntagged(): Flow<List<Note>>
|
||||
|
||||
/** Only notes tagged with [name] (normalised form), sorted by updatedAt DESC. */
|
||||
fun observeNotesForHashtag(name: String): Flow<List<Note>>
|
||||
|
||||
/**
|
||||
* Every distinct hashtag, sorted by `lastUsedAt DESC` then
|
||||
* `noteCount DESC` then `name ASC`. Each entry also carries the
|
||||
* number of notes that use it.
|
||||
*/
|
||||
fun observeHashtagsByRecentUse(): Flow<List<HashtagUsage>>
|
||||
|
||||
// --- Hashtag autocomplete (v0.3.0.0) ---
|
||||
/**
|
||||
* Every distinct hashtag in the store, sorted by usage count DESC
|
||||
* then name ASC. Used to populate the autocomplete "suggestions"
|
||||
* list when the input is empty.
|
||||
*/
|
||||
fun observeAllHashtags(): Flow<List<String>>
|
||||
|
||||
/**
|
||||
* Hashtags whose name starts with [prefix] (case-insensitive),
|
||||
* sorted by usage count DESC then name ASC. Blank [prefix] is
|
||||
* equivalent to [observeAllHashtags].
|
||||
*/
|
||||
fun searchHashtags(prefix: String): Flow<List<String>>
|
||||
|
||||
/**
|
||||
* Add [name] to the note's hashtag set. Creates the hashtag row
|
||||
* if it doesn't exist yet. Idempotent. No-op if the note already
|
||||
* has the tag.
|
||||
*/
|
||||
suspend fun addHashtag(noteId: Long, name: String)
|
||||
|
||||
/**
|
||||
* Remove [name] from the note's hashtag set. Idempotent. No-op if
|
||||
* the note doesn't have the tag. The hashtag row itself is NOT
|
||||
* auto-deleted (cleanup is the future "tag browser" feature).
|
||||
*/
|
||||
suspend fun removeHashtag(noteId: Long, name: String)
|
||||
}
|
||||
Reference in new issue
Block a user