acts_as_calculator_editor 0.1.0

data/app/assets/javascripts/acts_as_calculator_editor/list_filter_controller.js

@@ -0,0 +1,39 @@
+import { Controller } from "@hotwired/stimulus"
+
+// Client-side filtering for the formula/template/lookup-table index tables.
+//
+// Purely a view over rows already on the page — it never re-queries. The server-side `key`
+// and `scope` filters (ApplicationController#filter_by_key_and_scope) remain the real ones,
+// and this is the "I can see it, let me narrow it" affordance on top of them.
+export default class extends Controller {
+  static targets = [ "query", "row", "empty", "count" ]
+
+  connect() {
+    this.filter()
+  }
+
+  filter() {
+    const needle = this.hasQueryTarget ? this.queryTarget.value.trim().toLowerCase() : ""
+    let visible = 0
+
+    for (const row of this.rowTargets) {
+      const haystack = (row.dataset.filterText || row.textContent).toLowerCase()
+      const match = needle === "" || haystack.includes(needle)
+
+      row.hidden = !match
+      if (match) visible++
+    }
+
+    if (this.hasEmptyTarget) this.emptyTarget.hidden = visible > 0 || this.rowTargets.length === 0
+    if (this.hasCountTarget) {
+      this.countTarget.textContent = needle === ""
+        ? `${this.rowTargets.length}`
+        : `${visible} of ${this.rowTargets.length}`
+    }
+  }
+
+  clear() {
+    if (this.hasQueryTarget) this.queryTarget.value = ""
+    this.filter()
+  }
+}

data/app/assets/javascripts/acts_as_calculator_editor/template_editor_controller.js

@@ -0,0 +1,86 @@
+import { Controller } from "@hotwired/stimulus"
+
+// The template `body` field: a Lexxy editor for `format: "html"`, a plain textarea for
+// `format: "text"` (docs/lexxy-decision.md §4b — a text template's body is not HTML, and
+// putting it through an HTML editor would be the same mistake the formula field avoids).
+//
+// Both panes are rendered once and stay in the DOM. Switching format swaps which one is
+// visible and which one carries the `name` attribute; the hidden one has its `name` removed
+// so the browser does not submit two values for `template[body]`. Removing `name` works
+// identically for the textarea and for `<lexxy-editor>`, which is a form-associated custom
+// element reading `this.getAttribute("name")` — no value, no submission.
+//
+// Neither pane is ever inside the `template_preview` Turbo Frame. The preview button posts
+// the main form with `formaction`, so the frame that gets replaced is a sibling of the
+// editor, never an ancestor. Nesting them would make Turbo tear down and rebuild
+// <lexxy-editor> on every preview, losing cursor position and the whole undo stack.
+export default class extends Controller {
+  static targets = [ "htmlPane", "textPane", "htmlInput", "textInput", "format", "previewButton" ]
+
+  static values = {
+    previewDelay: { type: Number, default: 700 },
+    autoPreview: { type: Boolean, default: true }
+  }
+
+  connect() {
+    this.previewTimer = null
+    this.applyFormat()
+  }
+
+  disconnect() {
+    clearTimeout(this.previewTimer)
+  }
+
+  get format() {
+    return this.hasFormatTarget ? this.formatTarget.value : "html"
+  }
+
+  applyFormat() {
+    const html = this.format === "html"
+
+    this.togglePane(this.htmlPaneTarget, this.htmlInputTarget, html)
+    this.togglePane(this.textPaneTarget, this.textInputTarget, !html)
+  }
+
+  togglePane(pane, input, active) {
+    pane.hidden = !active
+
+    if (active) {
+      input.setAttribute("name", "template[body]")
+    } else {
+      // Not `disabled`: `<lexxy-editor>` manages its own ElementInternals validity state and
+      // a disabled form-associated element is skipped by the browser, but removing the name
+      // is the behaviour both elements agree on without relying on that.
+      input.removeAttribute("name")
+    }
+  }
+
+  formatChanged() {
+    this.applyFormat()
+    this.schedulePreview()
+  }
+
+  // Fires from `input` on the textarea and from Lexxy's own `lexxy:change` event. Debounced,
+  // because the preview goes through the real Liquid sandbox server-side.
+  bodyChanged() {
+    this.schedulePreview()
+  }
+
+  schedulePreview() {
+    if (!this.autoPreviewValue || !this.hasPreviewButtonTarget) return
+
+    clearTimeout(this.previewTimer)
+    this.previewTimer = setTimeout(() => this.preview(), this.previewDelayValue)
+  }
+
+  preview() {
+    const form = this.element.closest("form")
+    if (!form) return
+
+    // `requestSubmit(submitter)` rather than `submit()`: it honours the button's `formaction`
+    // (POST /templates/preview), its `formmethod`, and its `data-turbo-frame`, so Turbo
+    // replaces only the preview frame. `form.submit()` would ignore all three and publish
+    // the template.
+    form.requestSubmit(this.previewButtonTarget)
+  }
+}

data/app/assets/stylesheets/acts_as_calculator_editor/application.css

@@ -0,0 +1,2 @@
+/*! tailwindcss v4.3.3 | MIT License | https://tailwindcss.com */
+@layer properties{@supports (((-webkit-hyphens:none)) and (not (margin-trim:inline))) or ((-moz-orient:inline) and (not (color:rgb(from red r g b)))){*,:before,:after,::backdrop{--tw-rotate-x:initial;--tw-rotate-y:initial;--tw-rotate-z:initial;--tw-skew-x:initial;--tw-skew-y:initial;--tw-space-y-reverse:0;--tw-divide-y-reverse:0;--tw-border-style:solid;--tw-font-weight:initial;--tw-tracking:initial;--tw-shadow:0 0 #0000;--tw-shadow-color:initial;--tw-shadow-alpha:100%;--tw-inset-shadow:0 0 #0000;--tw-inset-shadow-color:initial;--tw-inset-shadow-alpha:100%;--tw-ring-color:initial;--tw-ring-shadow:0 0 #0000;--tw-inset-ring-color:initial;--tw-inset-ring-shadow:0 0 #0000;--tw-ring-inset:initial;--tw-ring-offset-width:0px;--tw-ring-offset-color:#fff;--tw-ring-offset-shadow:0 0 #0000;--tw-blur:initial;--tw-brightness:initial;--tw-contrast:initial;--tw-grayscale:initial;--tw-hue-rotate:initial;--tw-invert:initial;--tw-opacity:initial;--tw-saturate:initial;--tw-sepia:initial;--tw-drop-shadow:initial;--tw-drop-shadow-color:initial;--tw-drop-shadow-alpha:100%;--tw-drop-shadow-size:initial}}}@layer theme{:root,:host{--font-mono:ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace;--color-red-50:oklch(97.1% .013 17.38);--color-red-200:oklch(88.5% .062 18.334);--color-red-300:oklch(80.8% .114 19.571);--color-red-500:oklch(63.7% .237 25.331);--color-red-700:oklch(50.5% .213 27.518);--color-red-800:oklch(44.4% .177 26.899);--color-red-900:oklch(39.6% .141 25.723);--color-amber-50:oklch(98.7% .022 95.277);--color-amber-100:oklch(96.2% .059 95.617);--color-amber-200:oklch(92.4% .12 95.746);--color-amber-500:oklch(76.9% .188 70.08);--color-amber-700:oklch(55.5% .163 48.998);--color-amber-800:oklch(47.3% .137 46.201);--color-amber-900:oklch(41.4% .112 45.904);--color-emerald-50:oklch(97.9% .021 166.113);--color-emerald-100:oklch(95% .052 163.051);--color-emerald-200:oklch(90.5% .093 164.15);--color-emerald-700:oklch(50.8% .118 165.612);--color-emerald-800:oklch(43.2% .095 166.913);--color-sky-200:oklch(90.1% .058 230.902);--color-sky-800:oklch(44.3% .11 240.79);--color-violet-700:oklch(49.1% .27 292.581);--color-pink-700:oklch(52.5% .223 3.958);--color-slate-50:oklch(98.4% .003 247.858);--color-slate-100:oklch(96.8% .007 247.896);--color-slate-200:oklch(92.9% .013 255.508);--color-slate-300:oklch(86.9% .022 252.894);--color-slate-400:oklch(70.4% .04 256.788);--color-slate-500:oklch(55.4% .046 257.417);--color-slate-600:oklch(44.6% .043 257.281);--color-slate-700:oklch(37.2% .044 257.287);--color-slate-800:oklch(27.9% .041 260.031);--color-slate-900:oklch(20.8% .042 265.755);--color-slate-950:oklch(12.9% .042 264.695);--color-white:#fff;--spacing:.25rem;--container-6xl:72rem;--text-xs:.75rem;--text-xs--line-height:calc(1 / .75);--text-sm:.875rem;--text-sm--line-height:calc(1.25 / .875);--text-2xl:1.5rem;--text-2xl--line-height:calc(2 / 1.5);--font-weight-medium:500;--font-weight-semibold:600;--tracking-tight:-.025em;--tracking-wide:.025em;--radius-md:.375rem;--radius-lg:.5rem;--default-transition-duration:.15s;--default-transition-timing-function:cubic-bezier(.4, 0, .2, 1)}}@layer base{.acts-as-calculator-editor{-webkit-text-size-adjust:100%;margin:0;font-family:ui-sans-serif,system-ui,-apple-system,Segoe UI,Roboto,Helvetica Neue,Arial,sans-serif;line-height:1.5}.acts-as-calculator-editor *,.acts-as-calculator-editor :before,.acts-as-calculator-editor :after{box-sizing:border-box}.acts-as-calculator-editor h1,.acts-as-calculator-editor h2,.acts-as-calculator-editor h3{font-size:inherit;font-weight:inherit;margin:0}.acts-as-calculator-editor p,.acts-as-calculator-editor ul,.acts-as-calculator-editor ol,.acts-as-calculator-editor pre,.acts-as-calculator-editor figure{margin:0}.acts-as-calculator-editor ul,.acts-as-calculator-editor ol{padding:0;list-style:none}.acts-as-calculator-editor fieldset{min-width:0;margin:0}.acts-as-calculator-editor a{color:inherit;-webkit-text-decoration:inherit;-webkit-text-decoration:inherit;text-decoration:inherit}.acts-as-calculator-editor table{border-collapse:collapse;text-indent:0}.acts-as-calculator-editor code,.acts-as-calculator-editor pre{font-family:var(--aac-mono);font-size:1em}.acts-as-calculator-editor button,.acts-as-calculator-editor input,.acts-as-calculator-editor select,.acts-as-calculator-editor textarea{font:inherit;color:inherit;margin:0}.acts-as-calculator-editor button{cursor:pointer;background:0 0}.acts-as-calculator-editor [hidden]{display:none!important}}@layer components{.acts-as-calculator-editor{--aac-mono:ui-monospace, SFMono-Regular, "SF Mono", Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace}.aac-expression__shell{border:1px solid var(--color-slate-300);background-color:#fff;border-radius:.375rem;position:relative;box-shadow:0 1px 2px #0000000d}.aac-expression__shell:focus-within{border-color:var(--color-slate-500);box-shadow:0 0 0 2px var(--color-slate-200)}.aac-expression__overlay,.aac-expression__ink{font-family:var(--aac-mono);letter-spacing:0;tab-size:2;white-space:pre-wrap;overflow-wrap:break-word;word-break:normal;border:0;margin:0;padding:.625rem .75rem;font-size:.875rem;line-height:1.5rem}.aac-expression__overlay{pointer-events:none;color:var(--color-slate-900);background:0 0;position:absolute;inset:0;overflow:hidden}.aac-expression__ink{resize:vertical;color:#0000;width:100%;caret-color:var(--color-slate-900);scrollbar-width:none;background:0 0;outline:none;display:block;position:relative}.aac-expression__ink::-webkit-scrollbar{display:none}.aac-expression__ink::selection{background:var(--color-sky-200);color:#0000}.aac-tok--function{color:var(--color-violet-700);font-weight:600}.aac-tok--identifier{color:var(--color-sky-800)}.aac-tok--number{color:var(--color-amber-700)}.aac-tok--string{color:var(--color-emerald-700)}.aac-tok--literal{color:var(--color-amber-700);font-weight:600}.aac-tok--operator{color:var(--color-pink-700)}.aac-tok--paren,.aac-tok--comma{color:var(--color-slate-500)}.aac-tok--undeclared,.aac-tok--unknown-function{-webkit-text-decoration:underline wavy var(--color-amber-500);-webkit-text-decoration:underline wavy var(--color-amber-500);text-decoration:underline wavy var(--color-amber-500);text-underline-offset:3px}.aac-tok--unterminated-string{color:var(--color-red-700);-webkit-text-decoration:underline wavy var(--color-red-500);-webkit-text-decoration:underline wavy var(--color-red-500);text-decoration:underline wavy var(--color-red-500);text-underline-offset:3px}.aac-suggestions{z-index:30;border:1px solid var(--color-slate-200);background-color:#fff;border-radius:.375rem;min-width:16rem;max-height:15rem;margin-top:.25rem;padding:.25rem;position:absolute;top:100%;left:0;overflow-y:auto;box-shadow:0 10px 15px -3px #0000001a}.aac-suggestion{cursor:pointer;border-radius:.25rem;justify-content:space-between;align-items:center;gap:1rem;padding:.25rem .5rem;font-size:.8125rem;display:flex}.aac-suggestion.is-active{background-color:var(--color-slate-100)}.aac-suggestion__name{font-family:var(--aac-mono);color:var(--color-slate-900)}.aac-suggestion__kind{text-transform:uppercase;letter-spacing:.05em;color:var(--color-slate-400);font-size:.6875rem}.aac-status{border-radius:.375rem;padding:.375rem .625rem;font-size:.8125rem}.aac-status--ok{background-color:var(--color-emerald-50);color:var(--color-emerald-800)}.aac-status--error{background-color:var(--color-red-50);color:var(--color-red-800)}.aac-status--warning{background-color:var(--color-amber-50);color:var(--color-amber-800)}.aac-status--unknown{background-color:var(--color-slate-100);color:var(--color-slate-600)}.acts-as-calculator-editor lexxy-editor.aac-lexxy{border:1px solid var(--color-slate-300);background-color:#fff;border-radius:.375rem;min-height:18rem;display:block}.acts-as-calculator-editor lexxy-editor.aac-lexxy:focus-within{border-color:var(--color-slate-500);box-shadow:0 0 0 2px var(--color-slate-200)}}@layer utilities{.visible{visibility:visible}.absolute{position:absolute}.fixed{position:fixed}.relative{position:relative}.static{position:static}.right-0{right:0}.z-20{z-index:20}.mx-auto{margin-inline:auto}.mt-0\.5{margin-top:calc(var(--spacing) * .5)}.mt-1{margin-top:var(--spacing)}.mt-2{margin-top:calc(var(--spacing) * 2)}.mt-3{margin-top:calc(var(--spacing) * 3)}.mt-6{margin-top:calc(var(--spacing) * 6)}.mb-1{margin-bottom:var(--spacing)}.mb-2{margin-bottom:calc(var(--spacing) * 2)}.mb-3{margin-bottom:calc(var(--spacing) * 3)}.mb-4{margin-bottom:calc(var(--spacing) * 4)}.mb-6{margin-bottom:calc(var(--spacing) * 6)}.mb-8{margin-bottom:calc(var(--spacing) * 8)}.ml-3{margin-left:calc(var(--spacing) * 3)}.ml-auto{margin-left:auto}.block{display:block}.flex{display:flex}.grid{display:grid}.hidden{display:none}.inline{display:inline}.inline-flex{display:inline-flex}.table{display:table}.h-64{height:calc(var(--spacing) * 64)}.min-h-screen{min-height:100vh}.w-40{width:calc(var(--spacing) * 40)}.w-56{width:calc(var(--spacing) * 56)}.w-80{width:calc(var(--spacing) * 80)}.w-full{width:100%}.max-w-6xl{max-width:var(--container-6xl)}.transform{transform:var(--tw-rotate-x,) var(--tw-rotate-y,) var(--tw-rotate-z,) var(--tw-skew-x,) var(--tw-skew-y,)}.cursor-pointer{cursor:pointer}.list-none{list-style-type:none}.flex-wrap{flex-wrap:wrap}.items-center{align-items:center}.items-end{align-items:flex-end}.items-start{align-items:flex-start}.justify-between{justify-content:space-between}.justify-center{justify-content:center}.justify-end{justify-content:flex-end}.gap-1{gap:var(--spacing)}.gap-2{gap:calc(var(--spacing) * 2)}.gap-3{gap:calc(var(--spacing) * 3)}.gap-4{gap:calc(var(--spacing) * 4)}:where(.space-y-1>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(var(--spacing) * var(--tw-space-y-reverse));margin-block-end:calc(var(--spacing) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-3>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 3) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 3) * calc(1 - var(--tw-space-y-reverse)))}:where(.space-y-6>:not(:last-child)){--tw-space-y-reverse:0;margin-block-start:calc(calc(var(--spacing) * 6) * var(--tw-space-y-reverse));margin-block-end:calc(calc(var(--spacing) * 6) * calc(1 - var(--tw-space-y-reverse)))}.gap-x-6{column-gap:calc(var(--spacing) * 6)}.gap-y-2{row-gap:calc(var(--spacing) * 2)}.gap-y-4{row-gap:calc(var(--spacing) * 4)}:where(.divide-y>:not(:last-child)){--tw-divide-y-reverse:0;border-bottom-style:var(--tw-border-style);border-top-style:var(--tw-border-style);border-top-width:calc(1px * var(--tw-divide-y-reverse));border-bottom-width:calc(1px * calc(1 - var(--tw-divide-y-reverse)))}:where(.divide-slate-100>:not(:last-child)){border-color:var(--color-slate-100)}.overflow-x-auto{overflow-x:auto}.rounded{border-radius:.25rem}.rounded-full{border-radius:3.40282e38px}.rounded-lg{border-radius:var(--radius-lg)}.rounded-md{border-radius:var(--radius-md)}.border{border-style:var(--tw-border-style);border-width:1px}.border-b{border-bottom-style:var(--tw-border-style);border-bottom-width:1px}.border-dashed{--tw-border-style:dashed;border-style:dashed}.border-amber-200{border-color:var(--color-amber-200)}.border-emerald-200{border-color:var(--color-emerald-200)}.border-red-200{border-color:var(--color-red-200)}.border-red-300{border-color:var(--color-red-300)}.border-slate-200{border-color:var(--color-slate-200)}.border-slate-300{border-color:var(--color-slate-300)}.bg-amber-50{background-color:var(--color-amber-50)}.bg-amber-100{background-color:var(--color-amber-100)}.bg-emerald-50{background-color:var(--color-emerald-50)}.bg-emerald-100{background-color:var(--color-emerald-100)}.bg-red-50{background-color:var(--color-red-50)}.bg-slate-50{background-color:var(--color-slate-50)}.bg-slate-100{background-color:var(--color-slate-100)}.bg-slate-200{background-color:var(--color-slate-200)}.bg-slate-900{background-color:var(--color-slate-900)}.bg-white{background-color:var(--color-white)}.p-3{padding:calc(var(--spacing) * 3)}.p-4{padding:calc(var(--spacing) * 4)}.p-5{padding:calc(var(--spacing) * 5)}.px-1{padding-inline:var(--spacing)}.px-1\.5{padding-inline:calc(var(--spacing) * 1.5)}.px-2{padding-inline:calc(var(--spacing) * 2)}.px-3{padding-inline:calc(var(--spacing) * 3)}.px-4{padding-inline:calc(var(--spacing) * 4)}.px-6{padding-inline:calc(var(--spacing) * 6)}.py-0\.5{padding-block:calc(var(--spacing) * .5)}.py-1\.5{padding-block:calc(var(--spacing) * 1.5)}.py-2{padding-block:calc(var(--spacing) * 2)}.py-3{padding-block:calc(var(--spacing) * 3)}.py-8{padding-block:calc(var(--spacing) * 8)}.pt-4{padding-top:calc(var(--spacing) * 4)}.pb-2{padding-bottom:calc(var(--spacing) * 2)}.text-left{text-align:left}.text-right{text-align:right}.font-mono{font-family:var(--font-mono)}.text-2xl{font-size:var(--text-2xl);line-height:var(--tw-leading,var(--text-2xl--line-height))}.text-sm{font-size:var(--text-sm);line-height:var(--tw-leading,var(--text-sm--line-height))}.text-xs{font-size:var(--text-xs);line-height:var(--tw-leading,var(--text-xs--line-height))}.font-medium{--tw-font-weight:var(--font-weight-medium);font-weight:var(--font-weight-medium)}.font-semibold{--tw-font-weight:var(--font-weight-semibold);font-weight:var(--font-weight-semibold)}.tracking-tight{--tw-tracking:var(--tracking-tight);letter-spacing:var(--tracking-tight)}.tracking-wide{--tw-tracking:var(--tracking-wide);letter-spacing:var(--tracking-wide)}.whitespace-nowrap{white-space:nowrap}.whitespace-pre-line{white-space:pre-line}.whitespace-pre-wrap{white-space:pre-wrap}.text-amber-800{color:var(--color-amber-800)}.text-amber-900{color:var(--color-amber-900)}.text-emerald-800{color:var(--color-emerald-800)}.text-red-700{color:var(--color-red-700)}.text-red-800{color:var(--color-red-800)}.text-red-900{color:var(--color-red-900)}.text-slate-100{color:var(--color-slate-100)}.text-slate-400{color:var(--color-slate-400)}.text-slate-500{color:var(--color-slate-500)}.text-slate-600{color:var(--color-slate-600)}.text-slate-700{color:var(--color-slate-700)}.text-slate-800{color:var(--color-slate-800)}.text-slate-900{color:var(--color-slate-900)}.text-white{color:var(--color-white)}.uppercase{text-transform:uppercase}.italic{font-style:italic}.underline{text-decoration-line:underline}.shadow{--tw-shadow:0 1px 3px 0 var(--tw-shadow-color,#0000001a), 0 1px 2px -1px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.shadow-lg{--tw-shadow:0 10px 15px -3px var(--tw-shadow-color,#0000001a), 0 4px 6px -4px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.shadow-sm{--tw-shadow:0 1px 3px 0 var(--tw-shadow-color,#0000001a), 0 1px 2px -1px var(--tw-shadow-color,#0000001a);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.blur{--tw-blur:blur(8px);filter:var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,)}.filter{filter:var(--tw-blur,) var(--tw-brightness,) var(--tw-contrast,) var(--tw-grayscale,) var(--tw-hue-rotate,) var(--tw-invert,) var(--tw-saturate,) var(--tw-sepia,) var(--tw-drop-shadow,)}.transition-colors{transition-property:color,background-color,border-color,outline-color,text-decoration-color,fill,stroke,--tw-gradient-from,--tw-gradient-via,--tw-gradient-to;transition-timing-function:var(--tw-ease,var(--default-transition-timing-function));transition-duration:var(--tw-duration,var(--default-transition-duration))}.placeholder\:text-slate-400::placeholder{color:var(--color-slate-400)}.read-only\:bg-slate-100:read-only{background-color:var(--color-slate-100)}@media (hover:hover){.hover\:bg-red-50:hover{background-color:var(--color-red-50)}.hover\:bg-slate-50:hover{background-color:var(--color-slate-50)}.hover\:bg-slate-100:hover{background-color:var(--color-slate-100)}.hover\:bg-slate-700:hover{background-color:var(--color-slate-700)}.hover\:text-slate-900:hover{color:var(--color-slate-900)}.hover\:text-slate-950:hover{color:var(--color-slate-950)}}.focus\:border-slate-500:focus{border-color:var(--color-slate-500)}.focus\:ring-2:focus{--tw-ring-shadow:var(--tw-ring-inset,) 0 0 0 calc(2px + var(--tw-ring-offset-width)) var(--tw-ring-color,currentcolor);box-shadow:var(--tw-inset-shadow), var(--tw-inset-ring-shadow), var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow)}.focus\:ring-red-300:focus{--tw-ring-color:var(--color-red-300)}.focus\:ring-slate-200:focus{--tw-ring-color:var(--color-slate-200)}.focus\:ring-slate-300:focus{--tw-ring-color:var(--color-slate-300)}.focus\:ring-slate-400:focus{--tw-ring-color:var(--color-slate-400)}.focus\:ring-offset-1:focus{--tw-ring-offset-width:1px;--tw-ring-offset-shadow:var(--tw-ring-inset,) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color)}.focus\:outline-none:focus{--tw-outline-style:none;outline-style:none}.disabled\:bg-slate-100:disabled{background-color:var(--color-slate-100)}@media (min-width:40rem){.sm\:col-span-2{grid-column:span 2/span 2}.sm\:col-span-3{grid-column:span 3/span 3}.sm\:col-span-4{grid-column:span 4/span 4}.sm\:grid-cols-2{grid-template-columns:repeat(2,minmax(0,1fr))}.sm\:grid-cols-3{grid-template-columns:repeat(3,minmax(0,1fr))}.sm\:grid-cols-12{grid-template-columns:repeat(12,minmax(0,1fr))}}}@property --tw-rotate-x{syntax:"*";inherits:false}@property --tw-rotate-y{syntax:"*";inherits:false}@property --tw-rotate-z{syntax:"*";inherits:false}@property --tw-skew-x{syntax:"*";inherits:false}@property --tw-skew-y{syntax:"*";inherits:false}@property --tw-space-y-reverse{syntax:"*";inherits:false;initial-value:0}@property --tw-divide-y-reverse{syntax:"*";inherits:false;initial-value:0}@property --tw-border-style{syntax:"*";inherits:false;initial-value:solid}@property --tw-font-weight{syntax:"*";inherits:false}@property --tw-tracking{syntax:"*";inherits:false}@property --tw-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-shadow-color{syntax:"*";inherits:false}@property --tw-shadow-alpha{syntax:"<percentage>";inherits:false;initial-value:100%}@property --tw-inset-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-inset-shadow-color{syntax:"*";inherits:false}@property --tw-inset-shadow-alpha{syntax:"<percentage>";inherits:false;initial-value:100%}@property --tw-ring-color{syntax:"*";inherits:false}@property --tw-ring-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-inset-ring-color{syntax:"*";inherits:false}@property --tw-inset-ring-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-ring-inset{syntax:"*";inherits:false}@property --tw-ring-offset-width{syntax:"<length>";inherits:false;initial-value:0}@property --tw-ring-offset-color{syntax:"*";inherits:false;initial-value:#fff}@property --tw-ring-offset-shadow{syntax:"*";inherits:false;initial-value:0 0 #0000}@property --tw-blur{syntax:"*";inherits:false}@property --tw-brightness{syntax:"*";inherits:false}@property --tw-contrast{syntax:"*";inherits:false}@property --tw-grayscale{syntax:"*";inherits:false}@property --tw-hue-rotate{syntax:"*";inherits:false}@property --tw-invert{syntax:"*";inherits:false}@property --tw-opacity{syntax:"*";inherits:false}@property --tw-saturate{syntax:"*";inherits:false}@property --tw-sepia{syntax:"*";inherits:false}@property --tw-drop-shadow{syntax:"*";inherits:false}@property --tw-drop-shadow-color{syntax:"*";inherits:false}@property --tw-drop-shadow-alpha{syntax:"<percentage>";inherits:false;initial-value:100%}@property --tw-drop-shadow-size{syntax:"*";inherits:false}

data/app/controllers/acts_as_calculator_editor/application_controller.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module ActsAsCalculatorEditor
+  # This engine calls the core gem's Decrees in-process rather than over HTTP
+  # (docs/core-gem-contract.md §1), which means it also inherits the job the core gem's own
+  # `ApplicationController` was doing: turning `ActsAsCalculator::Error` into a status code.
+  # The mapping below is the same table, deliberately — a divergence here would mean the
+  # same failure reads as a different kind of problem depending on which door you came in.
+  #
+  # There is no authentication or authorization here, matching the core gem: a host wraps
+  # the mounted engine in its own.
+  class ApplicationController < ActionController::Base
+    # Registration order is inverted at lookup time — the most recently registered matching
+    # handler wins — so the catch-all for the gem's own errors goes first and the narrower
+    # cases override it below.
+    rescue_from ActsAsCalculator::Error, with: :render_unprocessable
+    rescue_from ActsAsCalculator::FormulaNotFoundError,
+                ActsAsCalculator::TemplateNotFoundError,
+                ActsAsCalculator::NoEffectiveVersionError, with: :render_not_found
+    rescue_from ActsAsCalculator::PartialSupersedeError, with: :render_conflict
+    rescue_from ActsAsCalculator::LookupTableInUseError, with: :render_conflict
+    rescue_from ::ActiveRecord::RecordNotFound, with: :render_not_found
+    rescue_from ::ActiveRecord::RecordInvalid, with: :render_unprocessable
+    rescue_from ::ActiveRecord::RecordNotDestroyed, with: :render_conflict
+    rescue_from ::ActionController::ParameterMissing, with: :render_bad_request
+
+    private
+
+    # 409, not 422: the request is well-formed and the state is valid — the two are just
+    # irreconcilable until the operator says which one they meant to keep.
+    CONFLICTS = [ActsAsCalculator::PartialSupersedeError,
+                 ActsAsCalculator::LookupTableInUseError,
+                 ::ActiveRecord::RecordNotDestroyed].freeze
+
+    NOT_FOUND = [ActsAsCalculator::FormulaNotFoundError,
+                 ActsAsCalculator::TemplateNotFoundError,
+                 ActsAsCalculator::NoEffectiveVersionError,
+                 ::ActiveRecord::RecordNotFound].freeze
+
+    # Anything a form can provoke. `RecordNotFound` is not in here on purpose: a missing row
+    # is not something re-rendering a form can help with, so it falls through to the
+    # `rescue_from` above and gets a 404 page.
+    RENDERABLE = [ActsAsCalculator::Error,
+                  ::ActiveRecord::RecordInvalid,
+                  ::ActiveRecord::RecordNotDestroyed].freeze
+
+    # Wraps the one Decree call an action exists to make, so a failure re-renders the form
+    # the operator was looking at — with the real status code, not a 302 that loses it.
+    def rescuing_core_errors(view, message: nil)
+      yield
+    rescue *RENDERABLE => e
+      @error_message = message || editor_message(e)
+      render view, status: editor_status(e)
+    end
+
+    def editor_status(error)
+      return :conflict if CONFLICTS.any? { |type| error.is_a?(type) }
+      return :not_found if NOT_FOUND.any? { |type| error.is_a?(type) }
+
+      :unprocessable_entity
+    end
+
+    # `PartialSupersedeError` and `LookupTableInUseError` carry messages written for an
+    # operator — they name the exact date range that would be orphaned, or the formula
+    # versions blocking a bracket edit, and both suggest a fix. They are shown verbatim.
+    # `RecordNotDestroyed`, by contrast, says "Failed to destroy the record", so the record's
+    # own validation errors are tried first and the caller may pass something better.
+    def editor_message(error)
+      record = error.respond_to?(:record) ? error.record : nil
+      record&.errors&.full_messages&.to_sentence.presence || error.message
+    end
+
+    def render_conflict(error)
+      render_error(error, :conflict)
+    end
+
+    def render_not_found(error)
+      render_error(error, :not_found)
+    end
+
+    def render_unprocessable(error)
+      render_error(error, :unprocessable_entity)
+    end
+
+    def render_bad_request(error)
+      render_error(error, :bad_request)
+    end
+
+    def render_error(error, status)
+      @error_message = editor_message(error)
+      @error_type = error.class.name
+
+      respond_to do |format|
+        format.html { render "acts_as_calculator_editor/shared/error", status: }
+        format.json { render json: { error: { type: @error_type, message: @error_message } }, status: }
+      end
+    end
+
+    # `key` alone never identifies a row in this gem — every uniqueness constraint scopes
+    # past it to `[key, scope, owner]` (contract §2.2) — so a list filters on the pair and
+    # every index view shows `scope` as a first-class column.
+    def filter_by_key_and_scope(relation)
+      relation = relation.where(key: params[:key]) if params[:key].present?
+      relation = relation.where(scope: params[:scope]) if params[:scope].present?
+      relation
+    end
+
+    # v1 authors global (nil-owner) rows only. See `ActsAsCalculatorEditor.owner_classes`
+    # for why there is no free-text owner field, and what a host does instead.
+    def current_owner
+      nil
+    end
+    helper_method :current_owner
+  end
+end

data/app/controllers/acts_as_calculator_editor/exports_controller.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ActsAsCalculatorEditor
+  # Export is a gap the core gem leaves open: it reads the import document schema and has no
+  # reverse (docs/core-gem-contract.md §4.2). What comes out here is that *import* shape —
+  # not the shape `SerializeFormula` and friends emit, which differ in four ways that would
+  # each quietly produce a file that does not round-trip.
+  #
+  # `?full_history=true` widens the formulas section from active versions to every version.
+  # It does not widen templates, which stay current-only for the reason `ExportTemplates`
+  # explains.
+  class ExportsController < ApplicationController
+    def show
+      document = BuildExportDocument.(key: params[:key], scope: params[:scope],
+                                      full_history: full_history?)
+
+      send_data JSON.pretty_generate(document),
+                filename:, type: "application/json", disposition: disposition
+    end
+
+    private
+
+    def full_history?
+      %w[true 1].include?(params[:full_history].to_s)
+    end
+
+    def filename
+      parts = ["acts_as_calculator", params[:scope].presence, params[:key].presence,
+               Date.current.strftime("%Y%m%d")].compact
+
+      "#{parts.join("-").parameterize}.json"
+    end
+
+    # `inline` so a link with `?disposition=inline` can be read in a browser tab; a plain
+    # export link downloads. Turbo does not intercept either — a file response is not a
+    # navigation, which is why the export link in the views sets `data-turbo="false"`.
+    def disposition
+      params[:disposition].to_s == "inline" ? "inline" : "attachment"
+    end
+  end
+end

data/app/controllers/acts_as_calculator_editor/formula_versions_controller.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module ActsAsCalculatorEditor
+  # No edit, no update, no destroy — a published version is immutable, and the corrective
+  # action is publishing another one (docs/core-gem-contract.md §2.4). `new` accepts
+  # `?from_version_id=` so "duplicate this into a new draft" is available, which is usually
+  # what an operator reaching for "edit" actually means.
+  #
+  # `@form` and `@variable_rows` are plain hashes rather than an unsaved `FormulaVersion`:
+  # a failed submission has to come back showing exactly what the operator typed, including
+  # the unparseable date that caused the failure, and an ActiveRecord object cannot hold one.
+  class FormulaVersionsController < ApplicationController
+    FIELDS = %w[expression effective_from effective_to status change_note].freeze
+
+    def index
+      @formula = formula
+      @versions = formula.versions.includes(:variables).order(:version_number)
+    end
+
+    def show
+      @formula = formula
+      @version = version
+      @variables = version.variables.order(:name)
+    end
+
+    def new
+      @formula = formula
+      @form = prefilled_form
+      @variable_rows = prefilled_variable_rows
+      @active_versions = active_versions
+    end
+
+    # Straight through `PublishFormulaVersion`, which is the same object the core gem's own
+    # API controller calls: the incumbent is superseded rather than rewritten, version
+    # numbers are handed out in one place, and a supersede that would leave part of the
+    # incumbent's range with no active version raises `PartialSupersedeError` — surfaced
+    # here as a 409 with its message intact, because that message names the exact date range
+    # at issue and the two ways out of it.
+    def create
+      @formula = formula
+      @form = submitted_form
+      @variable_rows = variables
+      @active_versions = active_versions
+
+      rescuing_core_errors(:new) do
+        published = ActsAsCalculator::PublishFormulaVersion.(formula: @formula, **version_attributes)
+        redirect_to formula_version_path(@formula, published),
+                    notice: "Published version #{published.version_number} of #{@formula.key}."
+      end
+    end
+
+    private
+
+    def formula
+      @formula ||= ActsAsCalculator::Formula.find(params[:formula_id])
+    end
+
+    def version
+      @version ||= formula.versions.find(params[:id])
+    end
+
+    # The overlap rule is discoverable from data already in hand, so the form shows the
+    # ranges already in force rather than letting the operator find out by 409 (contract
+    # §2.3).
+    def active_versions
+      formula.versions.active.order(:effective_from, :version_number)
+    end
+
+    def duplicated
+      return @duplicated if defined?(@duplicated)
+
+      @duplicated = params[:from_version_id].presence && formula.versions.find(params[:from_version_id])
+    end
+
+    # A duplicate comes back as a `draft` and without the dates: the whole reason to
+    # duplicate is that the new version applies to a different period, and copying the old
+    # `effective_from` into an active version is the fastest route to a supersede nobody
+    # meant.
+    def prefilled_form
+      return blank_form if duplicated.nil?
+
+      blank_form.merge("expression" => duplicated.expression,
+                       "change_note" => duplicated.change_note,
+                       "status" => ActsAsCalculator::FormulaVersion::DRAFT)
+    end
+
+    def blank_form
+      FIELDS.index_with { "" }.merge("status" => ActsAsCalculator::FormulaVersion::ACTIVE)
+    end
+
+    def prefilled_variable_rows
+      return [] if duplicated.nil?
+
+      duplicated.variables.order(:name).map do |variable|
+        { "name" => variable.name, "source_type" => variable.source_type,
+          "required" => variable.required?, "source_config" => variable.source_config || {} }
+      end
+    end
+
+    def submitted_form
+      permitted = version_params
+
+      FIELDS.index_with { |field| permitted[field].to_s }
+    end
+
+    def version_params
+      params.require(:version).permit(*FIELDS)
+    end
+
+    # `variables` is read outside strong parameters because `source_config` is arbitrary
+    # JSON, which `permit` cannot describe without either enumerating every source type's
+    # keys or opening the whole subtree. `CastVariableRows` is the whitelist instead: it
+    # emits exactly `name`, `source_type`, `source_config` and `required`, and nothing a
+    # form posts alongside them survives.
+    def variables
+      CastVariableRows.(params.dig(:version, :variables))
+    end
+
+    def version_attributes
+      { expression: @form["expression"],
+        effective_from: @form["effective_from"],
+        effective_to: @form["effective_to"].presence,
+        status: @form["status"].presence || ActsAsCalculator::FormulaVersion::ACTIVE,
+        change_note: @form["change_note"].presence,
+        variables: @variable_rows }
+    end
+  end
+end

data/app/controllers/acts_as_calculator_editor/formulas_controller.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module ActsAsCalculatorEditor
+  # Identity only — `key` and `scope`. There is no `expression` field anywhere in this
+  # controller, because "edit a formula" is not a thing this data model supports: everything
+  # mutable about a formula lives on its versions (docs/core-gem-contract.md §2.1), which is
+  # what `FormulaVersionsController` is for.
+  class FormulasController < ApplicationController
+    # The audit trail outranks a delete. `FormulaVersion has_many :runs,
+    # dependent: :restrict_with_error`, so this delete was always going to fail — the view
+    # says so before the operator clicks it, and `RecordNotDestroyed`'s own message
+    # ("Failed to destroy the record") is not worth showing anyone.
+    AUDITED = "This formula has versions with recorded calculation runs. The audit trail is " \
+              "never deleted to make room for a delete, so the formula stays. Retire its " \
+              "active version instead if it should stop being used."
+
+    def index
+      @formulas = filter_by_key_and_scope(ActsAsCalculator::Formula.order(:scope, :key, :id))
+    end
+
+    def show
+      @formula = formula
+      @versions = versions
+    end
+
+    def new
+      @formula = ActsAsCalculator::Formula.new(scope: ActsAsCalculator::DEFAULT_SCOPE)
+    end
+
+    def edit
+      @formula = formula
+    end
+
+    # `Formula.create!` rather than a Decree: identity rows have no effective-dating, no
+    # supersede and no version numbering to get wrong, and the core gem's own controller
+    # creates them the same way. The Decree rule exists for `calculator_formula_versions`,
+    # `calculator_templates` and `calculator_lookup_table_entries` — the tables where a
+    # hand-rolled write would bypass real logic.
+    def create
+      @formula = ActsAsCalculator::Formula.new(**formula_attributes)
+
+      rescuing_core_errors(:new) do
+        @formula.save!
+        redirect_to formula_path(@formula), notice: "Created formula #{@formula.key}."
+      end
+    end
+
+    # Re-owning or re-scoping a formula silently re-targets every future calculation of that
+    # key (contract §2.7). v1 exposes `key` and `scope` only, and no owner field at all.
+    def update
+      @formula = formula
+
+      rescuing_core_errors(:edit) do
+        @formula.update!(**formula_attributes)
+        redirect_to formula_path(@formula), notice: "Updated formula #{@formula.key}."
+      end
+    end
+
+    def destroy
+      formula.destroy!
+      redirect_to formulas_path, notice: "Deleted formula #{formula.key}."
+    rescue ::ActiveRecord::RecordNotDestroyed
+      @formula = formula
+      @versions = versions
+      @error_message = AUDITED
+      render :show, status: :conflict
+    end
+
+    private
+
+    # `find` by id, not by key: `key` alone never identifies a row here (contract §2.2).
+    def formula
+      @formula ||= ActsAsCalculator::Formula.find(params[:id])
+    end
+
+    def versions
+      formula.versions.includes(:variables).order(:version_number)
+    end
+
+    def formula_params
+      params.require(:formula).permit(:key, :scope)
+    end
+
+    # Only the keys that were sent, so a rename cannot blank the scope — the same rule the
+    # core gem's `PATCH /formulas/:id` follows.
+    def formula_attributes
+      permitted = formula_params
+      attributes = {}
+      attributes[:key] = permitted[:key].to_s.strip if permitted.key?(:key)
+      attributes[:scope] = permitted[:scope].presence || ActsAsCalculator::DEFAULT_SCOPE if permitted.key?(:scope)
+      attributes
+    end
+  end
+end

data/app/controllers/acts_as_calculator_editor/lookup_tables_controller.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module ActsAsCalculatorEditor
+  # The core gem has no controller, no routes and no serializer for lookup tables
+  # (docs/core-gem-contract.md §4.4) — deliberately, because `POST /import` is the only path
+  # that enforces the guard against editing brackets an audited formula version resolved to.
+  # This controller is therefore the only lookup-table authoring surface there is, and it
+  # keeps that property by writing exclusively through `ImportLookupTable`
+  # (via `PublishLookupTable`) rather than touching `entries` directly.
+  #
+  # This matters because a lookup table is not decoration: a variable with
+  # `source_type: "lookup"` cannot evaluate without one.
+  class LookupTablesController < ApplicationController
+    def index
+      @lookup_tables = filter_by_key_and_scope(
+        ActsAsCalculator::LookupTable.includes(:entries).order(:scope, :key, :id)
+      )
+    end
+
+    def show
+      @lookup_table = lookup_table
+      @entries = entries
+      @used_by = references
+    end
+
+    def new
+      @form = { "key" => "", "scope" => ActsAsCalculator::DEFAULT_SCOPE }
+      @entry_rows = []
+    end
+
+    # `key` and `scope` are not editable. `ImportLookupTable` keys on `[key, scope, owner]`,
+    # so a "rename" would silently create a second table and leave every formula variable
+    # still pointing at the old one — which would keep calculating, against brackets the
+    # operator believes they just changed. Entries are what an edit changes; a new key is a
+    # new table.
+    def edit
+      @lookup_table = lookup_table
+      @form = { "key" => lookup_table.key, "scope" => lookup_table.scope }
+      @entry_rows = entries.map { |entry| entry_row(entry) }
+    end
+
+    def create
+      @form = submitted_form
+      @entry_rows = submitted_entry_rows
+
+      rescuing_core_errors(:new) do
+        created = PublishLookupTable.(key: @form["key"], scope: @form["scope"],
+                                      owner: current_owner, entries: @entry_rows)
+        redirect_to lookup_table_path(created), notice: "Created lookup table #{created.key}."
+      end
+    end
+
+    def update
+      @lookup_table = lookup_table
+      @form = { "key" => lookup_table.key, "scope" => lookup_table.scope }
+      @entry_rows = submitted_entry_rows
+
+      rescuing_core_errors(:edit) do
+        updated = PublishLookupTable.(key: @form["key"], scope: @form["scope"],
+                                      owner: lookup_table.owner, entries: @entry_rows)
+        redirect_to lookup_table_path(updated), notice: "Updated lookup table #{updated.key}."
+      end
+    end
+
+    def destroy
+      @lookup_table = lookup_table
+      @entries = entries
+      @used_by = references
+
+      rescuing_core_errors(:show) do
+        DeleteLookupTable.(lookup_table: @lookup_table)
+        redirect_to lookup_tables_path, notice: "Deleted lookup table #{@lookup_table.key}."
+      end
+    end
+
+    private
+
+    def lookup_table
+      @lookup_table ||= ActsAsCalculator::LookupTable.find(params[:id])
+    end
+
+    def entries
+      lookup_table.entries.ordered
+    end
+
+    # Which formula versions would resolve to *this* table if they ran now — owner shadowing
+    # included, which is why this is a Decree call and not a key comparison. Shown on the
+    # page so the operator learns an edit is blocked before attempting it.
+    def references
+      ActsAsCalculator::FindLookupTableReferences.(lookup_table:)
+    end
+
+    def entry_row(entry)
+      { "from" => CastExportDecimal.(entry.from), "to" => CastExportDecimal.(entry.to),
+        "value" => CastExportDecimal.(entry.value) }
+    end
+
+    def submitted_form
+      permitted = params.require(:lookup_table).permit(:key, :scope)
+
+      { "key" => permitted[:key].to_s, "scope" => permitted[:scope].to_s }
+    end
+
+    # `require` rather than `dig`: an empty entries list is a legitimate edit (an operator
+    # clearing every bracket), so a request that forgot the whole `lookup_table` key has to
+    # be told apart from one that meant it — otherwise a malformed PATCH silently wipes a
+    # table's brackets.
+    def submitted_entry_rows
+      CastEntryRows.(params.require(:lookup_table)[:entries])
+    end
+  end
+end