Add count, min and max, and rule off each block in the margin

Author: kipcole9

assets/css/app.css

@@ -152,6 +152,22 @@
   height: var(--sheet-line-height);
 }
 
+/* The line an accountant draws under a column of figures before writing the
+   total beneath it. It marks where the entries stop and what they add up to
+   starts, which the margin otherwise leaves to the reader to work out.
+
+   Drawn as an inset shadow rather than a border on purpose. Every answer row
+   is exactly one line high and every column derives from that one value, so
+   a row that grew by the width of a border — or whose text shifted down by
+   it — would put this answer out of step with the line that produced it. A
+   shadow occupies no space at all.
+
+   The colour is mixed rather than set with `opacity`, which would fade the
+   answer along with its rule. */
+.sheet-answers > .sheet-rule {
+  box-shadow: inset 0 1px 0 0 color-mix(in oklab, currentColor 45%, transparent);
+}
+
 /* The editor is a transparent textarea laid over a coloured copy of its own
    text. Both boxes must agree byte for byte on metrics — font, size, line
    height, padding, wrapping — or the colours drift out from under the cursor.

lib/localize_pad/lexicon.ex

@@ -56,7 +56,7 @@ defmodule LocalizePad.Lexicon do
           | :of_reversed
           | :per_reversed
 
-  @type aggregate :: :sum | :average | :median
+  @type aggregate :: :sum | :average | :median | :count | :minimum | :maximum
 
   @type deictic ::
           :now | :today | :tomorrow | :yesterday | :day_after_tomorrow | :day_before_yesterday
@@ -246,31 +246,51 @@ defmodule LocalizePad.Lexicon do
   # Spanish is the reminder that these are near neighbours in every language:
   # `media` is the average and `mediana` is the median, one letter apart and
   # two different answers.
+  #
+  # `min` is also the abbreviation for a minute, so a line reading nothing but
+  # `min` answers the smallest entry above it rather than one minute. Only a
+  # line that is *entirely* the word is read this way — `5 min` is still five
+  # minutes — and nobody writes a bare `min` meaning a duration.
   @aggregates %{
     en: %{
       sum: ["sum", "subtotal", "total"],
       average: ["average", "avg", "mean"],
-      median: ["median"]
+      median: ["median"],
+      count: ["count"],
+      minimum: ["min", "minimum", "lowest", "smallest"],
+      maximum: ["max", "maximum", "highest", "largest"]
     },
     de: %{
       sum: ["summe", "zwischensumme", "gesamt", "gesamtsumme", "total"],
       average: ["durchschnitt", "mittelwert", "mittel"],
-      median: ["median", "zentralwert"]
+      median: ["median", "zentralwert"],
+      count: ["anzahl"],
+      minimum: ["min", "minimum", "kleinster wert"],
+      maximum: ["max", "maximum", "größter wert", "grösster wert"]
     },
     fr: %{
       sum: ["somme", "sous-total", "total"],
       average: ["moyenne"],
-      median: ["médiane", "mediane"]
+      median: ["médiane", "mediane"],
+      count: ["compte", "nombre"],
+      minimum: ["min", "minimum"],
+      maximum: ["max", "maximum"]
     },
     es: %{
       sum: ["suma", "subtotal", "total"],
       average: ["promedio", "media"],
-      median: ["mediana"]
+      median: ["mediana"],
+      count: ["cuenta", "recuento"],
+      minimum: ["min", "mínimo", "minimo"],
+      maximum: ["max", "máximo", "maximo"]
     },
     ja: %{
       sum: ["合計", "小計", "計"],
       average: ["平均", "平均値"],
-      median: ["中央値", "メジアン"]
+      median: ["中央値", "メジアン"],
+      count: ["件数", "個数", "カウント"],
+      minimum: ["最小", "最小値"],
+      maximum: ["最大", "最大値"]
     }
   }
 
@@ -285,7 +305,8 @@ defmodule LocalizePad.Lexicon do
 
   ### Returns
 
-  * `{:ok, function}` where function is `:sum`, `:average` or `:median`.
+  * `{:ok, function}` where function is `:sum`, `:average`, `:median`,
+    `:count`, `:minimum` or `:maximum`.
 
   * `:error` when the word names no function in this locale, which is what
     makes `somme` a calculation on a French sheet and prose on an English one.

lib/localize_pad/line.ex

@@ -12,8 +12,9 @@ defmodule LocalizePad.Line do
 
   * `:comment` — begins with `//`.
 
-  * `:aggregate` — `sum`, `average` or `median`, alone on a line. Summarises
-    every entry above it, back to the previous aggregate or heading.
+  * `:aggregate` — `sum`, `average`, `median`, `count`, `min` or `max`, alone
+    on a line. Summarises every entry above it, back to the previous aggregate
+    or heading.
 
   * `:declaration` — `name = expression`. Binds a name for the lines below.
 
@@ -25,7 +26,7 @@ defmodule LocalizePad.Line do
   file records it out of band. A sheet here is plain text first — it has to
   survive being copied into a chat window and pasted back — so the aggregate
   is a word you can type. `sum` on its own line is the marker, and `average`,
-  `mean` and `median` are the others.
+  `mean`, `median`, `count`, `min` and `max` are the others.
 
   Which words those are is the reader's business, not English's:
   `Durchschnitt` on a German sheet is the same line as `average` on an English

lib/localize_pad/sheet.ex

@@ -26,16 +26,22 @@ defmodule LocalizePad.Sheet do
   declaration names a value for later use, and counting `cost = 550` as an
   entry as well as every line that uses `cost` would double it.
 
-  A line reading `sum`, `average` or `median` does the same over the entries
-  above it, back to the previous such line or heading. Several of them may sit
-  one under the other, and each reports on the block the run as a whole
-  follows rather than on the line above it — `sum` then `average` answers for
-  the same entries twice, which is the point of writing both.
-
-  The three answer together or not at all. An average is a sum shared out and
-  a median is an ordering, so each needs what the sum needs: values of one
-  kind, converted into one unit or one currency. What the sum will not add,
-  the others will not average or order either.
+  A line reading `sum`, `average`, `median`, `count`, `min` or `max` does the
+  same over the entries above it, back to the previous such line or heading.
+  Several of them may sit one under the other, and each reports on the block
+  the run as a whole follows rather than on the line above it — `sum` then
+  `average` answers for the same entries twice, which is the point of writing
+  both.
+
+  Five of the six answer together or not at all. An average is a sum shared
+  out, and a median, a minimum and a maximum are orderings, so each needs what
+  the sum needs: values of one kind, converted into one unit or one currency.
+  What the sum will not add, the others will not average or order either.
+
+  `count` is the exception, because counting asks nothing of the values but
+  that they be there. A page of metres and kilograms has no total and no
+  middle, and still plainly has two entries on it. It counts what the others
+  use, so the sum shared out by the count is always the average.
 
   Three sheets have a total, and they are the three where one exists to be had:
 
@@ -614,6 +620,29 @@ defmodule LocalizePad.Sheet do
     end
   end
 
+  # The smallest and largest come out of the same ordering, and out of it
+  # already converted — the smallest of a metre and 50 cm is half a metre,
+  # written in the unit the sheet chose, exactly as the sum and the median
+  # are.
+  defp combine(values, :minimum, locale, rates), do: end_of(values, locale, rates, &List.first/1)
+  defp combine(values, :maximum, locale, rates), do: end_of(values, locale, rates, &List.last/1)
+
+  # Counting asks nothing of the values but that they be entries, so it
+  # answers where the others refuse: a page of metres and kilograms has no
+  # total and no middle, and still plainly has two things on it.
+  #
+  # What it counts is what the others use, which is what keeps the sum shared
+  # out by the count equal to the average. A date is not an entry here for the
+  # same reason it is not part of the total.
+  defp combine(values, :count, _locale, _rates), do: length(values)
+
+  defp end_of(values, locale, rates, pick) do
+    case ordered(values, locale, rates) do
+      {:ok, sorted} -> pick.(sorted)
+      :error -> nil
+    end
+  end
+
   defp middle(values, locale, rates) do
     count = length(values)
     above = div(count, 2)

lib/localize_pad_web/live/sheet_live.ex

@@ -145,7 +145,7 @@ defmodule LocalizePadWeb.SheetLive do
 
   use LocalizePadWeb, :live_view
 
-  alias LocalizePad.{Examples, Highlight, Locales, Refusal, Share, Sheet, Timeline, Value}
+  alias LocalizePad.{Examples, Highlight, Line, Locales, Refusal, Share, Sheet, Timeline, Value}
 
   @sample """
   # A first sheet
@@ -401,10 +401,35 @@ defmodule LocalizePadWeb.SheetLive do
       )
     )
     |> assign(:share_payload, Share.encode(socket.assigns.source, socket.assigns.locale))
+    |> assign(:ruled, ruled(sheet))
     |> assign(:total, format_total(sheet, socket.assigns.locale))
     |> assign(:detail, detail_for(sheet, socket.assigns[:selected], socket.assigns.locale))
   end
 
+  # Which answers get the rule drawn over them: the accountant's line under a
+  # column of figures, before the total is written beneath it.
+  #
+  # One per run, not one per aggregate, so `sum` / `average` / `median` read as
+  # one bracketed group rather than three stripes. Blank lines sit inside a run
+  # here exactly as they do in the block the run reports on — the two rules
+  # have to agree or the drawing would contradict the arithmetic.
+  #
+  # An aggregate with no answer is passed over rather than ruled off. A rule
+  # over an empty row delineates nothing, and where the sum refuses but the
+  # count does not, the line belongs over the answer that is actually there.
+  defp ruled(%Sheet{lines: lines}) do
+    {ruled, _drawn} =
+      Enum.reduce(lines, {MapSet.new(), false}, fn
+        %Line{kind: :aggregate, formatted: nil}, accumulated -> accumulated
+        %Line{kind: :aggregate} = line, {ruled, false} -> {MapSet.put(ruled, line.index), true}
+        %Line{kind: :aggregate}, accumulated -> accumulated
+        %Line{kind: :blank}, accumulated -> accumulated
+        _line, {ruled, _drawn} -> {ruled, false}
+      end)
+
+    ruled
+  end
+
   defp detail_for(_sheet, nil, _locale), do: nil
 
   defp detail_for(sheet, index, locale) do
@@ -665,7 +690,8 @@ defmodule LocalizePadWeb.SheetLive do
                 line.formatted && "cursor-pointer hover:opacity-70",
                 line.index == @selected && "font-semibold",
                 line.error && "opacity-40",
-                line.kind in [:heading, :comment] && "opacity-30"
+                line.kind in [:heading, :comment] && "opacity-30",
+                MapSet.member?(@ruled, line.index) && "sheet-rule"
               ]}
               title={
                 line.error &&

test/localize_pad/languages_test.exs

@@ -78,6 +78,17 @@ defmodule LocalizePad.LanguagesTest do
       assert answer("10\n20\n30\n中央値", "ja") == "20"
     end
 
+    test "and it can count and find its ends in its own language too" do
+      assert answer("10\n20\n30\nanzahl", "de") == "3"
+      assert answer("10\n20\n30\nnombre", "fr") == "3"
+      assert answer("10\n20\n30\ncuenta", "es") == "3"
+      assert answer("10\n20\n30\n件数", "ja") == "3"
+
+      assert answer("10\n20\n30\nkleinster wert", "de") == "10"
+      assert answer("10\n20\n30\nmáximo", "es") == "30"
+      assert answer("10\n20\n30\n最小", "ja") == "10"
+    end
+
     test "and the average and the median are one letter apart in Spanish" do
       # `media` is the average and `mediana` is the median. Two words, two
       # answers, and nothing but the last three letters to tell them apart.

test/localize_pad/sheet_test.exs

@@ -153,6 +153,28 @@ defmodule LocalizePad.SheetTest do
       assert answers("1\n2\n3\n4\nmedian") == ["1", "2", "3", "4", "2.5"]
     end
 
+    test "a minimum and a maximum are the ends of that same order" do
+      assert answers("30\n10\n20\nmin\nmax") == ["30", "10", "20", "10", "30"]
+    end
+
+    test "a count counts the entries" do
+      assert answers("19\n22\n1\ncount") == ["19", "22", "1", "3"]
+    end
+
+    test "and counts what the average divides by, so the two agree" do
+      # The date is no more part of the count than it is part of the sum.
+      # Counted, `sum / count` would answer 13.67 where the average says 20.5.
+      assert answers("19\nApril 12, 2026\n22\nsum\ncount\naverage") ==
+               ["19", "April 12, 2026", "22", "41", "2", "20.5"]
+    end
+
+    test "a count answers where the others refuse, because counting asks nothing" do
+      # There is no total of a distance and a weight and no middle one either,
+      # and the page still plainly has two entries on it.
+      assert answers("3 meters\n100 kg\nsum\nmedian\ncount") ==
+               ["3 meters", "100 kilograms", nil, nil, "2"]
+    end
+
     test "a quantity that will not add refuses the total rather than being skipped" do
       # Skipping it would answer `41` for a sheet whose middle line is a
       # distance, under a label reading `Total`. There is no total of a number
@@ -226,6 +248,13 @@ defmodule LocalizePad.SheetTest do
                ["1 meter", "50 centimeters", "2 meters", "1 meter"]
     end
 
+    test "the ends of the order are converted too, not reported as written" do
+      # 50 cm is the smallest however it is spelled, and it is answered in the
+      # unit the sheet chose rather than the one that line happened to use.
+      assert answers("1 meter\n50 cm\n2 m\nmin\nmax") ==
+               ["1 meter", "50 centimeters", "2 meters", "0.5 meters", "2 meters"]
+    end
+
     test "quantities of different kinds have no average" do
       assert answers("3 meters\n100 kg\naverage") == ["3 meters", "100 kilograms", nil]
     end

test/localize_pad_web/live/sheet_live_test.exs

@@ -192,6 +192,51 @@ defmodule LocalizePadWeb.SheetLiveTest do
     end
   end
 
+  describe "the rule over an aggregate" do
+    # The answer rows are the only thing carrying a line number, so the rows
+    # ruled off can be read straight out of the markup.
+    defp ruled_lines(html) do
+      ~r/phx-value-line="(\d+)"[^>]*sheet-rule/
+      |> Regex.scan(html)
+      |> Enum.map(fn [_whole, index] -> String.to_integer(index) end)
+    end
+
+    test "one rule opens a run, however many functions are in it", %{conn: conn} do
+      {:ok, live, _html} = live(conn, ~p"/")
+
+      # Three stripes would say the three answers were three separate things.
+      html = render_change(live, :edit, %{"source" => "10\n20\nsum\naverage\nmedian"})
+
+      assert ruled_lines(html) == [2]
+    end
+
+    test "and a blank inside the run does not start a second one", %{conn: conn} do
+      {:ok, live, _html} = live(conn, ~p"/")
+
+      html = render_change(live, :edit, %{"source" => "10\n20\nsum\n\naverage"})
+
+      assert ruled_lines(html) == [2]
+    end
+
+    test "every block gets its own", %{conn: conn} do
+      {:ok, live, _html} = live(conn, ~p"/")
+
+      html = render_change(live, :edit, %{"source" => "10\nsum\n# Travel\n20\nsum"})
+
+      assert ruled_lines(html) == [1, 4]
+    end
+
+    test "an aggregate with no answer is passed over, not ruled off", %{conn: conn} do
+      {:ok, live, _html} = live(conn, ~p"/")
+
+      # There is no total of a distance and a weight, so the rule belongs over
+      # the count, which is the first answer the run actually produces.
+      html = render_change(live, :edit, %{"source" => "3 meters\n100 kg\nsum\ncount"})
+
+      assert ruled_lines(html) == [3]
+    end
+  end
+
   describe "windows of one session" do
     # Two windows of a session mirror each other. The property that matters
     # more than the feature is that *only* they do: the topic is derived from a