diff --git a/PRD.md b/PRD.md index 0f42fb0..6c4ee84 100644 --- a/PRD.md +++ b/PRD.md @@ -113,6 +113,23 @@ in English. Side dishes live in their own table and have no category. The pool is expected to stay small. +### Tähteet — leftovers (stage 1) + +A single built-in entry, flagged `special` on the main dish table. It is +**not food**: it exists so a day can be recorded as "we ate what was already +there" without inventing a meal that was never cooked. + +- No category, which is why it cannot be an ordinary main: those must have + at least one. +- Created by a migration. The household does not add, edit or delete it, and + it never appears in the Ruuat catalog. +- Loggable exactly like any other entry, and shown on the log board apart + from the categories. +- **The stage 2 suggester must never propose it.** It is excluded from the + eligible pool outright, so cooldown, category coverage (§8.1) and + frequency weighting (§8.2) all skip it — despite it being among the + most-logged entries. + ### Meal log entry ("what was actually eaten") (stage 1) - `id` - `date` — SQL `DATE`, day granularity only. There is no time-of-day field diff --git a/cmd/foodster/catalog_test.go b/cmd/foodster/catalog_test.go index d4ae0b1..622d441 100644 --- a/cmd/foodster/catalog_test.go +++ b/cmd/foodster/catalog_test.go @@ -131,6 +131,55 @@ func TestSoftDeleteHidesDishButKeepsHistory(t *testing.T) { } } +func TestTahteetIsLoggableButNotFood(t *testing.T) { + h := seeded(t) + + // The migration creates it; nobody adds it. + special, err := listSpecial(h.db, "") + if err != nil { + t.Fatalf("listSpecial: %v", err) + } + if len(special) != 1 || special[0].Name != "Tähteet" { + t.Fatalf("special = %+v, want exactly Tähteet", special) + } + + // It must not turn up among the dishes: not on the board's categories, + // not in the catalog, and not in whatever the suggester later draws from. + dishes, err := listDishes(h.db, "") + if err != nil { + t.Fatalf("listDishes: %v", err) + } + for _, d := range dishes { + if d.Name == "Tähteet" { + t.Fatal("Tähteet appears among the dishes") + } + } + + // It carries no category at all, which is why it cannot be an ordinary + // dish: those are required to have one. + if len(special[0].Categories) != 0 { + t.Errorf("categories = %v, want none", special[0].Categories) + } + // And it gets its own mark: no categories is not the same as several, so + // it must not fall through to the mixed Sekalaiset one. + if got := special[0].CategoryKey(); got != "tahteet" { + t.Errorf("CategoryKey = %q, want tahteet", got) + } + + // Logging it has to work exactly like logging a real meal. + date := day(t, "2026-09-05") + if err := saveEntry(h.db, date, special[0].ID, nil); err != nil { + t.Fatalf("saveEntry: %v", err) + } + entry, err := entryFor(h.db, date) + if err != nil || entry == nil { + t.Fatalf("entryFor: %v, %v", entry, err) + } + if entry.Main.Name != "Tähteet" { + t.Errorf("logged %q, want Tähteet", entry.Main.Name) + } +} + func TestSoftDeleteSideHidesItFromPickers(t *testing.T) { h := seeded(t) id := h.sideNamed(t, "Riisi") diff --git a/cmd/foodster/handlers.go b/cmd/foodster/handlers.go index 080a8ed..2f72e7e 100644 --- a/cmd/foodster/handlers.go +++ b/cmd/foodster/handlers.go @@ -86,6 +86,7 @@ type logView struct { ShowBoard bool Dishes []Dish // flat, only to know whether anything matched Groups []DishGroup // what the board actually renders + Special []Dish // Tähteet and the like: loggable, but not food Sides []Side New mainForm // inline "add the dish you were looking for" History HistoryPage @@ -142,6 +143,9 @@ func (a *app) index(w http.ResponseWriter, r *http.Request) { // listDishes already orders by frequency then name, so grouping keeps // the favourites at the top of each category. v.Groups = groupDishes(v.Dishes) + if v.Special, err = listSpecial(a.db, v.Search); err != nil { + log.Printf("list special: %v", err) + } // Seed the inline add form with whatever was searched for, so a miss // turns straight into "add it" without retyping. v.New = mainForm{Name: v.Search, Categories: map[string]bool{}, HasSides: true} @@ -210,6 +214,9 @@ func (a *app) searchBoard(w http.ResponseWriter, r *http.Request) { } v.Dishes = dishes v.Groups = groupDishes(dishes) + if v.Special, err = listSpecial(a.db, v.Search); err != nil { + log.Printf("search special: %v", err) + } v.New = mainForm{Name: v.Search, Categories: map[string]bool{}, HasSides: true} fragment(w, r, boardList(v)) @@ -293,6 +300,9 @@ func (a *app) quickAdd(w http.ResponseWriter, r *http.Request) { log.Printf("list dishes: %v", err) } v.Groups = groupDishes(v.Dishes) + if v.Special, err = listSpecial(a.db, v.Search); err != nil { + log.Printf("list special: %v", err) + } v.HistoryDays = historyWindow(r) v.HistoryMore = v.HistoryDays + historyDays if v.History, err = history(a.db, a.loc, today(a.loc), v.HistoryDays); err != nil { diff --git a/cmd/foodster/main_test.go b/cmd/foodster/main_test.go index edebd4c..75bd898 100644 --- a/cmd/foodster/main_test.go +++ b/cmd/foodster/main_test.go @@ -246,14 +246,16 @@ func TestMealLogOneEntryPerDate(t *testing.T) { } defer db.Close() - if _, err := db.Exec(`INSERT INTO main_dishes (id, name) VALUES (1, 'Lohikeitto'), (2, 'Lihapullat')`); err != nil { + // Ids well clear of anything the migrations create. + if _, err := db.Exec( + `INSERT INTO main_dishes (id, name) VALUES (101, 'Lohikeitto'), (102, 'Lihapullat')`); err != nil { t.Fatalf("seed: %v", err) } - if _, err := db.Exec(`INSERT INTO meal_log (date, main_dish_id) VALUES ('2026-09-05', 1)`); err != nil { + if _, err := db.Exec(`INSERT INTO meal_log (date, main_dish_id) VALUES ('2026-09-05', 101)`); err != nil { t.Fatalf("first entry: %v", err) } // PRD §6: a second dinner for the same day must be refused. - if _, err := db.Exec(`INSERT INTO meal_log (date, main_dish_id) VALUES ('2026-09-05', 2)`); err == nil { + if _, err := db.Exec(`INSERT INTO meal_log (date, main_dish_id) VALUES ('2026-09-05', 102)`); err == nil { t.Error("second entry for the same date was accepted, want a unique violation") } } @@ -265,18 +267,18 @@ func TestDuplicateNamesAreCaseInsensitive(t *testing.T) { } defer db.Close() - if _, err := db.Exec(`INSERT INTO main_dishes (id, name) VALUES (1, 'Kanacurry')`); err != nil { + if _, err := db.Exec(`INSERT INTO main_dishes (id, name) VALUES (101, 'Kanacurry')`); err != nil { t.Fatalf("first insert: %v", err) } - if _, err := db.Exec(`INSERT INTO main_dishes (id, name) VALUES (2, 'kanacurry')`); err == nil { + if _, err := db.Exec(`INSERT INTO main_dishes (id, name) VALUES (102, 'kanacurry')`); err == nil { t.Error("case-variant duplicate was accepted, want a unique violation") } // Soft-deleting the original frees the name again (PRD §7.3). - if _, err := db.Exec(`UPDATE main_dishes SET deleted_at = datetime('now') WHERE id = 1`); err != nil { + if _, err := db.Exec(`UPDATE main_dishes SET deleted_at = datetime('now') WHERE id = 101`); err != nil { t.Fatalf("soft delete: %v", err) } - if _, err := db.Exec(`INSERT INTO main_dishes (id, name) VALUES (2, 'kanacurry')`); err != nil { + if _, err := db.Exec(`INSERT INTO main_dishes (id, name) VALUES (102, 'kanacurry')`); err != nil { t.Errorf("name still blocked after soft delete: %v", err) } } diff --git a/cmd/foodster/migrations/0002_tahteet.sql b/cmd/foodster/migrations/0002_tahteet.sql new file mode 100644 index 0000000..85df255 --- /dev/null +++ b/cmd/foodster/migrations/0002_tahteet.sql @@ -0,0 +1,19 @@ +-- Tähteet: leftovers. +-- +-- Not a dish. It exists so a day can be recorded as "we ate what was already +-- there" without inventing a meal that was never cooked. It has no category, +-- it is not something the household adds or edits, and the stage 2 suggester +-- must never propose it (PRD §8). +-- +-- Modelled as a flagged row in main_dishes rather than a nullable +-- main_dish_id on meal_log: the log keeps one shape, and every foreign key +-- and join carries on working untouched. + +ALTER TABLE main_dishes + ADD COLUMN special INTEGER NOT NULL DEFAULT 0 CHECK (special IN (0, 1)); + +-- OR IGNORE in case a household already typed a dish by this name: the unique +-- index on lower(name) would otherwise fail the migration. Their row stays as +-- an ordinary dish, which is wrong but harmless and fixable by hand. +INSERT OR IGNORE INTO main_dishes (name, has_sides, special) +VALUES ('Tähteet', 0, 1); diff --git a/cmd/foodster/static/app.css b/cmd/foodster/static/app.css index 4990e15..30de39d 100644 --- a/cmd/foodster/static/app.css +++ b/cmd/foodster/static/app.css @@ -134,6 +134,8 @@ html[data-theme="light"] .themetoggle .i-moon { display: none; } .c-kana { color: var(--kana); } .c-kala { color: var(--kala); } .c-kasvis { color: var(--kasvis); } +/* Not a category, so not a category colour. */ +.c-tahteet { color: var(--muted); } /* Day switcher */ .dayseg { display: flex; gap: 6px; margin-top: 11px; flex-wrap: wrap; } @@ -208,6 +210,20 @@ html[data-theme="light"] .themetoggle .i-moon { display: none; } font-size: 10px; color: var(--muted); } +/* Not food: set apart from the categories, and deliberately quiet. */ +.special { + margin-top: 22px; + padding-top: 16px; + border-top: 1px dashed var(--line); +} +.pill.plain { + font-size: 16px; + padding: 12px 16px; + background: var(--sunk); + color: var(--muted); + font-weight: 600; +} + .pill.xl { font-size: 22px; padding: 14px 18px; flex: 1 1 100%; } .pill.lg { font-size: 18px; padding: 12px 16px; } .pill.md { font-size: 15.5px; padding: 11px 14px; } diff --git a/cmd/foodster/store.go b/cmd/foodster/store.go index 8369440..161fae7 100644 --- a/cmd/foodster/store.go +++ b/cmd/foodster/store.go @@ -28,13 +28,24 @@ type Dish struct { TimesEaten int } -// CategoryKey is the class suffix for the colour dot. A dish covering several -// categories (tortillas, build-your-own pizza) gets the mixed marker. +// Rows flagged `special` in the database — Tähteet — are loggable but are not +// food. They carry no category, never appear in the catalog, and PRD §8 +// excludes them from the suggester: cooldown, coverage and weighting all skip +// them. dishByID deliberately does not filter on the flag, because logging one +// has to work like logging anything else. + +// CategoryKey picks the mark for a dish. One covering several categories +// (tortillas, build-your-own pizza) gets the mixed one; carrying none at all +// means it is not food, and Tähteet is not a mixture of anything. func (d Dish) CategoryKey() string { - if len(d.Categories) == 1 { + switch len(d.Categories) { + case 0: + return "tahteet" + case 1: return categoryFI[d.Categories[0]] + default: + return "sek" } - return "sek" } // Size buckets the dish by how often it has been eaten. The board draws @@ -77,6 +88,17 @@ func (e Entry) SidesLabel() string { // listDishes returns live mains ordered by how often they have been eaten. // An empty search matches everything. func listDishes(db *sql.DB, search string) ([]Dish, error) { + return queryDishes(db, search, false) +} + +// listSpecial returns the entries that are not food — Tähteet and anything +// like it. They are loggable but never suggested, and never appear in the +// catalog, so they are fetched deliberately rather than by accident. +func listSpecial(db *sql.DB, search string) ([]Dish, error) { + return queryDishes(db, search, true) +} + +func queryDishes(db *sql.DB, search string, special bool) ([]Dish, error) { rows, err := db.Query(` SELECT m.id, m.name, m.has_sides, coalesce((SELECT group_concat(c.category) @@ -85,8 +107,9 @@ func listDishes(db *sql.DB, search string) ([]Dish, error) { (SELECT count(*) FROM meal_log l WHERE l.main_dish_id = m.id) FROM main_dishes m WHERE m.deleted_at IS NULL + AND m.special = ? AND (? = '' OR lower(m.name) LIKE '%' || lower(?) || '%') - ORDER BY 5 DESC, m.name`, search, search) + ORDER BY 5 DESC, m.name`, special, search, search) if err != nil { return nil, err } diff --git a/cmd/foodster/views.templ b/cmd/foodster/views.templ index 5be62d6..3cd4d00 100644 --- a/cmd/foodster/views.templ +++ b/cmd/foodster/views.templ @@ -183,6 +183,10 @@ templ categoryIcon(key string) { @glyphKasvis() + case "tahteet": + + @glyphTahteet() + default: @glyphSekalaiset() @@ -190,6 +194,15 @@ templ categoryIcon(key string) { } } +// A lidded tub. Tähteet is not food and not a mixture of categories, so it +// gets neither a category colour nor the quartered mark. +templ glyphTahteet() { + +} + // A steak, its bone knocked out with fill-rule so the hole is transparent on // whatever background the icon lands on. templ glyphLiha() { @@ -385,6 +398,28 @@ templ boardList(v logView) { } } + // Tähteet is not food, so it sits apart from the categories rather + // than inside one. Fixed size: it will be among the most-logged + // entries, and it should not tower over the actual cooking. + if len(v.Special) > 0 { +
+ for _, d := range v.Special { + { strconv.Itoa(d.TimesEaten) } + } + + } +
+ } + // Tähteet always matches an empty search, so the add card keys off the + // real dishes only: otherwise a fresh install would show leftovers and + // no way to add anything. if len(v.Dishes) == 0 { @quickAddCard(v) } diff --git a/scripts/smoke.sh b/scripts/smoke.sh index 985b711..e991721 100755 --- a/scripts/smoke.sh +++ b/scripts/smoke.sh @@ -114,6 +114,11 @@ check "malformed JSON is explained" \ board=$(curl -s -u ":$pass" "http://$addr/") check "board lists imported dishes" "$board" "Lihapullat" +# Tähteet is loggable but is not food: on the board, never in the catalog. +check "leftovers are on the board" "$board" "Tähteet" +refute "leftovers are not in the catalog" \ + "$(curl -s -u ":$pass" "http://$addr/ruuat")" "Tähteet" + # Pull a real dish id out of the board rather than assuming one. ruoka=$(printf '%s' "$board" | grep -o 'ruoka=[0-9]*' | head -n1 | cut -d= -f2) if [ -z "$ruoka" ]; then diff --git a/seeds/kotiruoat.json b/seeds/kotiruoat.json index 6296a9b..d050f67 100644 --- a/seeds/kotiruoat.json +++ b/seeds/kotiruoat.json @@ -1,19 +1,56 @@ { "mains": [ - {"name": "Uunilohi", "categories": ["fish"], "has_sides": true}, - {"name": "Lasagnette", "categories": ["meat"], "has_sides": false}, - {"name": "Jauhelihakastike", "categories": ["meat"], "has_sides": true}, - {"name": "Risotto", "categories": ["vegetarian"], "has_sides": false}, - {"name": "Pakastepizza", "categories": ["meat"], "has_sides": false}, - {"name": "Kanakeitto", "categories": ["chicken"], "has_sides": false}, - {"name": "Kasvissosekeitto", "categories": ["vegetarian"], "has_sides": false} + {"name": "Jauheliha-perunasiivu pelti", "categories": ["meat"], "has_sides": false}, + {"name": "Jauhelihakastike", "categories": ["meat"], "has_sides": true}, + {"name": "Jauhelihakeitto", "categories": ["meat"], "has_sides": false}, + {"name": "Jauhelihapihvit", "categories": ["meat"], "has_sides": true}, + {"name": "Kebab", "categories": ["meat"], "has_sides": true}, + {"name": "Kinkkukiusaus", "categories": ["meat"], "has_sides": false}, + {"name": "Lasagnette", "categories": ["meat"], "has_sides": false}, + {"name": "Lihapullat/pihvit", "categories": ["meat"], "has_sides": true}, + {"name": "Makaronilaatikko", "categories": ["meat"], "has_sides": false}, + {"name": "Makaronimössö", "categories": ["meat"], "has_sides": false}, + {"name": "Maksalaatikko", "categories": ["meat"], "has_sides": false}, + {"name": "Nachopelti", "categories": ["meat"], "has_sides": false}, + {"name": "Nakkikeitto", "categories": ["meat"], "has_sides": false}, + {"name": "Pakastepizza", "categories": ["meat"], "has_sides": false}, + {"name": "Possunsuikalekastike", "categories": ["meat"], "has_sides": true}, + {"name": "Possurisotto", "categories": ["meat"], "has_sides": false}, + {"name": "Pyttipannu", "categories": ["meat"], "has_sides": false}, + {"name": "Uuniliha", "categories": ["meat"], "has_sides": true}, + {"name": "Uunimakkara", "categories": ["meat"], "has_sides": true}, + + {"name": "Broilerin koipireidet", "categories": ["chicken"], "has_sides": true}, + {"name": "Kanakastike", "categories": ["chicken"], "has_sides": true}, + {"name": "Kanakeitto", "categories": ["chicken"], "has_sides": false}, + {"name": "Kanamakaronilaatikko", "categories": ["chicken"], "has_sides": false}, + {"name": "Kanapasta", "categories": ["chicken"], "has_sides": false}, + {"name": "Kanarisotto", "categories": ["chicken"], "has_sides": false}, + + {"name": "Kalakeitto", "categories": ["fish"], "has_sides": false}, + {"name": "Lohicuscus-salaatti", "categories": ["fish"], "has_sides": false}, + {"name": "Lohipyörykät", "categories": ["fish"], "has_sides": true}, + {"name": "Uunilohi", "categories": ["fish"], "has_sides": true}, + {"name": "Uuniperunat (lohitäytteellä)", "categories": ["fish"], "has_sides": false}, + + {"name": "Hernekeitto", "categories": ["vegetarian"], "has_sides": false}, + {"name": "Italianpata (lihaton)", "categories": ["vegetarian"], "has_sides": true}, + {"name": "Kasvispihvit", "categories": ["vegetarian"], "has_sides": true}, + {"name": "Kasvissosekeitto", "categories": ["vegetarian"], "has_sides": false}, + {"name": "Pinaattiletut", "categories": ["vegetarian"], "has_sides": false}, + {"name": "Risotto", "categories": ["vegetarian"], "has_sides": false}, + + {"name": "Tortillat", "categories": ["meat", "chicken", "fish", "vegetarian"], "has_sides": false} ], "sides": [ {"name": "Keitetyt perunat"}, - {"name": "Ranskalaiset"}, {"name": "Lohkoperunat"}, - {"name": "Muussi"}, + {"name": "Muusi"}, + {"name": "Pasta"}, + {"name": "Ranskalaiset"}, {"name": "Riisi"}, - {"name": "Pasta"} + {"name": "Spagetti"}, + {"name": "Tillikastike"}, + {"name": "Wokkivihannekset"} ] }