diff --git a/backend/web.go b/backend/web.go
index 62c7dee..b3368db 100644
--- a/backend/web.go
+++ b/backend/web.go
@@ -9,6 +9,7 @@ import (
"math"
"mime"
"net/http"
+ "net/url"
"strconv"
"strings"
"time"
@@ -44,6 +45,9 @@ type listView struct {
// reading set, not the active tab, so the badge does not change meaning as
// the user moves between tabs.
NewCount int
+ // OOB marks a render of the chrome partials as an out-of-band swap rather
+ // than the inline copy app.html lays out.
+ OOB bool
}
// Initial is the monogram the templates show in place of a cover when the
@@ -184,12 +188,6 @@ func (h *webHandler) buildListView(tab string) (listView, error) {
}
reading := filterBookmarks(all, func(b Bookmark) bool { return b.Status == statusReading })
- // The strip reflects overall reading recency, not the active tab.
- recent := reading
- if len(recent) > recentCount {
- recent = recent[:recentCount]
- }
-
withNew := filterBookmarks(reading, func(b Bookmark) bool { return b.HasNewChapter() })
var items []Bookmark
@@ -206,6 +204,22 @@ func (h *webHandler) buildListView(tab string) (listView, error) {
tab = "all"
items = reading
}
+ // The strip is scoped to series with a chapter waiting, which is the one
+ // question the list below it does not already answer: the list is ordered by
+ // reading recency, so the head of it *is* the strip whenever the strip is
+ // just "the most recent rows". Only on All — on Updated it would render the
+ // same set twice, and on the other tabs it would contradict the bucket.
+ //
+ // It therefore disappears entirely on a library with nothing new. That is
+ // the intended reading: an empty strip has nothing to say, and the ~240px it
+ // costs on a phone belongs to the list.
+ var recent []Bookmark
+ if tab == "all" {
+ recent = withNew
+ if len(recent) > recentCount {
+ recent = recent[:recentCount]
+ }
+ }
return listView{Tab: tab, Recent: recent, Items: items, NewCount: len(withNew)}, nil
}
@@ -217,6 +231,46 @@ func (h *webHandler) uiList(w http.ResponseWriter, r *http.Request) {
return
}
h.render(w, http.StatusOK, "list", view)
+ // The chrome is outside this response's swap target, so without this a tab
+ // switch would leave the strip and badge from whichever tab the page was
+ // loaded on — the same URL would render differently depending on how the
+ // reader got there.
+ h.writeChromeOOB(w, view)
+}
+
+// currentTab is the tab the reader is looking at, read from htmx's own header,
+// so out-of-band chrome is rebuilt for that view rather than for a default.
+func currentTab(r *http.Request) string {
+ u, err := url.Parse(r.Header.Get("HX-Current-URL"))
+ if err != nil {
+ return ""
+ }
+ return u.Query().Get("tab")
+}
+
+// writeChromeOOB appends the two regions that live outside #list — the recent
+// strip and the Updated badge — as out-of-band swaps, so a mutation cannot
+// leave them describing the library as it was before the tap.
+func (h *webHandler) writeChromeOOB(w http.ResponseWriter, view listView) {
+ view.OOB = true
+ for _, name := range []string{"recent", "newcount"} {
+ if err := h.tmpl.ExecuteTemplate(w, name, view); err != nil {
+ // The card is already written; stale chrome beats a torn response.
+ log.Printf("render %s oob: %v", name, err)
+ return
+ }
+ }
+}
+
+// refreshChrome rebuilds the chrome for the reader's current tab after a
+// mutation and appends it to the response.
+func (h *webHandler) refreshChrome(w http.ResponseWriter, r *http.Request) {
+ view, err := h.buildListView(currentTab(r))
+ if err != nil {
+ log.Printf("ui chrome: %v", err)
+ return
+ }
+ h.writeChromeOOB(w, view)
}
func (h *webHandler) login(w http.ResponseWriter, r *http.Request) {
@@ -273,17 +327,16 @@ func (h *webHandler) loadForMutation(w http.ResponseWriter, r *http.Request) (Bo
return b, true
}
-// saveAndRenderCard upserts and renders the row as stored. Upsert decides
-// whether updated_at moves, so the argument's timestamp is only a candidate and
-// the response must come from the return value.
+// saveAndRenderCard upserts and renders the row as stored, then refreshes the
+// chrome. Upsert decides whether updated_at moves, so the argument's timestamp
+// is only a candidate and the response must come from the return value.
//
// ponytail: the swapped card stays put even when its new status no longer
-// matches the active tab, add an hx-swap-oob list refresh if that reads as a
-// bug rather than as feedback. Archiving from the All tab leaves the card on
-// screen until the next list load. The alternative costs a full list round
-// trip on every toggle, and the card visibly showing its new state is the
-// feedback the user needs.
-func (h *webHandler) saveAndRenderCard(w http.ResponseWriter, b Bookmark) {
+// matches the active tab. That much is deliberate — the card showing its new
+// state is the feedback for the tap. The strip and the badge are not: they
+// describe the whole library, so they are rebuilt out of band on every
+// mutation, at the cost of one extra list read per toggle.
+func (h *webHandler) saveAndRenderCard(w http.ResponseWriter, r *http.Request, b Bookmark) {
stored, err := h.store.Upsert(b)
if err != nil {
log.Printf("ui upsert %q: %v", b.Key, err)
@@ -291,6 +344,7 @@ func (h *webHandler) saveAndRenderCard(w http.ResponseWriter, b Bookmark) {
return
}
h.render(w, http.StatusOK, "card", stored)
+ h.refreshChrome(w, r)
}
// uiFavorite flips the favourite flag. last_chapter_num is untouched, so
@@ -302,7 +356,7 @@ func (h *webHandler) uiFavorite(w http.ResponseWriter, r *http.Request) {
}
b.Favorite = !b.Favorite
b.UpdatedAt = time.Now().UnixMilli()
- h.saveAndRenderCard(w, b)
+ h.saveAndRenderCard(w, r, b)
}
// uiStatus moves a bookmark between lifecycle buckets. This is the only place
@@ -328,7 +382,7 @@ func (h *webHandler) uiStatus(w http.ResponseWriter, r *http.Request) {
return
}
b.UpdatedAt = time.Now().UnixMilli()
- h.saveAndRenderCard(w, b)
+ h.saveAndRenderCard(w, r, b)
}
// uiChapter forces the read chapter to a value the user typed.
@@ -364,7 +418,7 @@ func (h *webHandler) uiChapter(w http.ResponseWriter, r *http.Request) {
b.LastChapterNum = num
}
b.UpdatedAt = time.Now().UnixMilli()
- h.saveAndRenderCard(w, b)
+ h.saveAndRenderCard(w, r, b)
}
// uiDelete removes the row and answers with an empty body, which htmx swaps in
@@ -382,4 +436,7 @@ func (h *webHandler) uiDelete(w http.ResponseWriter, r *http.Request) {
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
w.WriteHeader(http.StatusOK)
+ // The empty body is what removes the card; the chrome still has to be told
+ // the library got smaller.
+ h.refreshChrome(w, r)
}
diff --git a/backend/web_test.go b/backend/web_test.go
index edbf541..a37bd0f 100644
--- a/backend/web_test.go
+++ b/backend/web_test.go
@@ -1,6 +1,7 @@
package main
import (
+ "fmt"
"net/http"
"net/http/httptest"
"net/url"
@@ -450,8 +451,14 @@ func TestUIDeleteRemovesRow(t *testing.T) {
if rr.Code != http.StatusOK {
t.Fatalf("delete status = %d, want 200", rr.Code)
}
- if rr.Body.Len() != 0 {
- t.Fatalf("delete body = %q, want empty so htmx swaps the card away", rr.Body.String())
+ // The body carries only out-of-band chrome, so htmx has nothing to swap into
+ // the card's place and the row disappears.
+ body := rr.Body.String()
+ if strings.Contains(body, `class="card`) {
+ t.Fatalf("delete body = %q, want no card so htmx swaps it away", body)
+ }
+ if !strings.Contains(body, `id="new-count" hx-swap-oob="true"`) {
+ t.Fatalf("delete body = %q, want the out-of-band badge", body)
}
if _, ok, _ := store.Get("asura:solo"); ok {
t.Fatal("row still present after delete")
@@ -578,25 +585,90 @@ func TestTabsShowOnlyTheirBucket(t *testing.T) {
}
}
-func TestRecentStripExcludesArchivedAndFinished(t *testing.T) {
- cfg := webConfig()
- srv, store := newWebTestServer(t, cfg)
- seedStatusRows(t, store)
-
- req := httptest.NewRequest(http.MethodGet, "/?tab=archived", nil)
+// stripOf returns everything above the list, which is where the recent section
+// renders.
+func stripOf(t *testing.T, srv http.Handler, cfg Config, tab string) string {
+ t.Helper()
+ req := httptest.NewRequest(http.MethodGet, "/?tab="+tab, nil)
req.AddCookie(sessionCookie(t, cfg))
rr := httptest.NewRecorder()
srv.ServeHTTP(rr, req)
+ body := rr.Body.String()
+ if i := strings.Index(body, `id="list"`); i >= 0 {
+ body = body[:i]
+ }
+ return body
+}
- strip := rr.Body.String()
- if i := strings.Index(strip, `id="list"`); i >= 0 {
- strip = strip[:i] // everything above the list is the recent section
+// The strip carries the series with a chapter waiting — the one thing the
+// updated_at-ordered list below it does not already say — and only on All.
+func TestRecentStripCarriesUnreadOnlyAndOnlyOnAll(t *testing.T) {
+ cfg := webConfig()
+ srv, store := newWebTestServer(t, cfg)
+ seedStatusRows(t, store) // ReadingOne is at 10 with 11 out; the rest are not reading
+
+ // A reading series that is caught up has nothing waiting, so it stays out.
+ caught := Bookmark{
+ Key: "asura:caught", Site: "asura", SeriesID: "caught", Title: "CaughtUpOne",
+ Status: statusReading, LastChapterNum: 40, LatestChapter: "40",
+ LatestChapterNum: floatPtr(40), UpdatedAt: time.Now().UnixMilli(),
}
- if strings.Contains(strip, "ArchivedOne") || strings.Contains(strip, "FinishedOne") {
- t.Fatal("recent strip included an archived or finished series")
+ if _, err := store.Upsert(caught); err != nil {
+ t.Fatalf("seed %s: %v", caught.Key, err)
}
+
+ strip := stripOf(t, srv, cfg, "all")
if !strings.Contains(strip, "ReadingOne") {
- t.Fatal("recent strip dropped the reading series")
+ t.Fatal("strip dropped the series with an unread chapter")
+ }
+ for _, unwanted := range []string{"CaughtUpOne", "ArchivedOne", "FinishedOne"} {
+ if strings.Contains(strip, unwanted) {
+ t.Fatalf("strip included %s", unwanted)
+ }
+ }
+ for _, tab := range []string{"new", "fav", "archived", "finished"} {
+ if strings.Contains(stripOf(t, srv, cfg, tab), "ReadingOne") {
+ t.Fatalf("tab %s rendered the strip", tab)
+ }
+ }
+
+ // Nothing new anywhere: the strip has nothing to say and does not render.
+ reading, _, err := store.Get("asura:reading")
+ if err != nil {
+ t.Fatalf("Get: %v", err)
+ }
+ reading.LatestChapterNum = floatPtr(reading.LastChapterNum)
+ if _, err := store.Upsert(reading); err != nil {
+ t.Fatalf("Upsert: %v", err)
+ }
+ // The section still ships (an out-of-band swap needs the id to exist) but
+ // carries no cards and is hidden.
+ empty := stripOf(t, srv, cfg, "all")
+ if strings.Contains(empty, "recent-card") {
+ t.Fatal("strip rendered cards with no unread chapters anywhere")
+ }
+ if !strings.Contains(empty, `id="recent" hidden`) {
+ t.Fatalf("strip not hidden with nothing new: %q", empty)
+ }
+}
+
+// The strip never grows past recentCount, however many series are waiting.
+func TestRecentStripCapped(t *testing.T) {
+ cfg := webConfig()
+ srv, store := newWebTestServer(t, cfg)
+ for i := 0; i <= recentCount; i++ {
+ b := Bookmark{
+ Key: fmt.Sprintf("asura:new%d", i), Site: "asura",
+ SeriesID: fmt.Sprintf("new%d", i), Title: fmt.Sprintf("Waiting%d", i),
+ Status: statusReading, LastChapterNum: 1, LatestChapter: "2",
+ LatestChapterNum: floatPtr(2), UpdatedAt: time.Now().UnixMilli() + int64(i),
+ }
+ if _, err := store.Upsert(b); err != nil {
+ t.Fatalf("seed %s: %v", b.Key, err)
+ }
+ }
+ if got := strings.Count(stripOf(t, srv, cfg, "all"), "recent-card"); got != recentCount {
+ t.Fatalf("strip rendered %d cards, want %d", got, recentCount)
}
}
@@ -730,3 +802,37 @@ func TestAppRendersNewTabs(t *testing.T) {
}
}
}
+
+// A mutation has to bring the chrome with it: the strip and the badge live
+// outside the swapped card, so nothing else would correct them.
+func TestMutationRefreshesChromeOutOfBand(t *testing.T) {
+ cfg := webConfig()
+ srv, store := newWebTestServer(t, cfg)
+ seed(t, store, Bookmark{
+ Key: "asura:solo", Site: "asura", SeriesID: "solo", Title: "Solo Leveling",
+ Status: statusReading, LastChapterNum: 10, LatestChapter: "Chapter 11",
+ LatestChapterNum: floatPtr(11), UpdatedAt: time.Now().UnixMilli(),
+ })
+
+ before := stripOf(t, srv, cfg, "all")
+ if !strings.Contains(before, "Solo Leveling") || !strings.Contains(before, `id="new-count"`) {
+ t.Fatalf("expected the series in the strip to start with: %q", before)
+ }
+
+ req := uiRequest(t, cfg, http.MethodPost, "/ui/bookmarks/asura:solo/status",
+ url.Values{"status": {statusArchived}})
+ req.Header.Set("HX-Current-URL", "http://localhost/?tab=all")
+ rr := httptest.NewRecorder()
+ srv.ServeHTTP(rr, req)
+ if rr.Code != http.StatusOK {
+ t.Fatalf("status post = %d, want 200", rr.Code)
+ }
+
+ body := rr.Body.String()
+ if !strings.Contains(body, `id="recent" hx-swap-oob="true" hidden`) {
+ t.Fatalf("archiving did not empty the strip out of band: %q", body)
+ }
+ if !strings.Contains(body, `id="new-count" hx-swap-oob="true" hidden`) {
+ t.Fatalf("archiving did not clear the Updated badge out of band: %q", body)
+ }
+}