Add Rails backend: accounts via magic link, server documents, sharing

The app becomes a Rails 8 application; the Vue frontend moves to
app/frontend and is served through vite_rails.

- Without an account documents stay in the browser (IndexedDB). Sign-in
  is by magic link or the 6-digit code from the same mail; afterwards
  local documents can be uploaded into the account.
- Server documents (/d/<id>) with versioned saves and a single-editor
  lock per browser tab; others see them read-only and follow by polling.
- Sharing via link (works without an account) and via e-mail invitation,
  roles viewer/editor; the owner manages links and people.
- Store gains a read-only mode that blocks all content changes.
- Solid Queue, Cache and Cable share the one PostgreSQL database.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

app/frontend/engine/__tests__/refs.spec.ts

@@ -0,0 +1,123 @@
+import { describe, it, expect } from 'vitest';
+import { parseA1, toA1, cycleReferenceLocks, currentIdentifierAtCaret } from '../refs';
+
+describe('parseA1 / toA1: $-locked (absolute/mixed) references', () => {
+  it('parseA1 reports which axes are $-locked', () => {
+    expect(parseA1('A1')).toEqual({ col: 0, row: 0, colAbs: false, rowAbs: false });
+    expect(parseA1('$A$1')).toEqual({ col: 0, row: 0, colAbs: true, rowAbs: true });
+    expect(parseA1('A$1')).toEqual({ col: 0, row: 0, colAbs: false, rowAbs: true });
+    expect(parseA1('$A1')).toEqual({ col: 0, row: 0, colAbs: true, rowAbs: false });
+  });
+
+  it('toA1 round-trips the lock markers', () => {
+    expect(toA1(0, 0)).toBe('A1');
+    expect(toA1(0, 0, true, true)).toBe('$A$1');
+    expect(toA1(0, 0, false, true)).toBe('A$1');
+    expect(toA1(0, 0, true, false)).toBe('$A1');
+  });
+});
+
+describe('cycleReferenceLocks (F4) -- collapsed caret', () => {
+  it('cycles relative -> absolute -> row-locked -> col-locked -> relative', () => {
+    let f = '=A1';
+    let pos = 3;
+    for (const expected of ['=$A$1', '=A$1', '=$A1', '=A1']) {
+      const res = cycleReferenceLocks(f, pos, pos)!;
+      expect(res.text).toBe(expected);
+      expect(res.start).toBe(res.end); // a collapsed caret in -> a collapsed caret out
+      f = res.text;
+      pos = res.end;
+    }
+  });
+
+  it('toggles only the reference the caret sits in/against', () => {
+    const res = cycleReferenceLocks('=A1+B2', 2, 2)!; // caret inside "A1"
+    expect(res.text).toBe('=$A$1+B2');
+    const res2 = cycleReferenceLocks('=A1+B2', 6, 6)!; // caret inside "B2"
+    expect(res2.text).toBe('=A1+$B$2');
+  });
+
+  it('picks the right side of a range depending on the caret', () => {
+    const left = cycleReferenceLocks('=A1:B2', 2, 2)!;
+    expect(left.text).toBe('=$A$1:B2');
+    const right = cycleReferenceLocks('=A1:B2', 6, 6)!;
+    expect(right.text).toBe('=A1:$B$2');
+  });
+
+  it('returns null when the caret is not on a reference, or the text is not a formula', () => {
+    expect(cycleReferenceLocks('=SUM(1;2)', 5, 5)).toBeNull();
+    expect(cycleReferenceLocks('42', 1, 1)).toBeNull();
+  });
+
+  it('never toggles a table-name qualifier, even one shaped like a cell', () => {
+    // "AB12" reads as a cell reference on its own, but here it's a table name
+    const formula = '=AB12!A1';
+    expect(cycleReferenceLocks(formula, 2, 2)).toBeNull(); // caret inside "AB12"
+    expect(cycleReferenceLocks(formula, 7, 7)?.text).toBe('=AB12!$A$1'); // caret inside the actual cell
+  });
+});
+
+describe('cycleReferenceLocks (F4) -- a real text selection spanning several refs', () => {
+  it('toggles every reference the selection overlaps, each from its own state', () => {
+    // select "A1+$B2" inside "=A1+$B2+C3" -- C3 sits outside the selection.
+    // A1 (relative) -> $A$1; $B2 (already col-locked-only, the cycle's last
+    // stop before relative) -> B2, its next step back to fully relative.
+    const formula = '=A1+$B2+C3';
+    const start = formula.indexOf('A1');
+    const end = formula.indexOf('$B2') + '$B2'.length;
+    const res = cycleReferenceLocks(formula, start, end)!;
+    expect(res.text).toBe('=$A$1+B2+C3');
+  });
+
+  it('a selection covering the whole formula adjusts all of it in one press', () => {
+    const res = cycleReferenceLocks('=A1+B2', 1, 7)!;
+    expect(res.text).toBe('=$A$1+$B$2');
+  });
+
+  it('re-cycling the same (now resized) selection keeps advancing every reference', () => {
+    let f = '=A1+B2';
+    let sel = cycleReferenceLocks(f, 1, 7)!; // -> $A$1+$B$2
+    f = sel.text;
+    sel = cycleReferenceLocks(f, sel.start, sel.end)!; // -> A$1+B$2
+    expect(sel.text).toBe('=A$1+B$2');
+  });
+
+  it('a selection touching no reference returns null', () => {
+    expect(cycleReferenceLocks('=SUM(1;2)', 4, 8)).toBeNull();
+  });
+});
+
+describe('currentIdentifierAtCaret -- function-name autocomplete detection', () => {
+  it('right after "=", right after an operator, right after "(" or ";"', () => {
+    expect(currentIdentifierAtCaret('=S', 2)).toEqual({ text: 'S', start: 1 });
+    expect(currentIdentifierAtCaret('=A1+S', 5)).toEqual({ text: 'S', start: 4 });
+    expect(currentIdentifierAtCaret('=SUM(A', 6)).toEqual({ text: 'A', start: 5 });
+    expect(currentIdentifierAtCaret('=SUM(1;A', 8)).toEqual({ text: 'A', start: 7 });
+  });
+
+  it('null outside a formula (no leading "=")', () => {
+    expect(currentIdentifierAtCaret('SUM', 3)).toBeNull();
+  });
+
+  it('null once the word looks like a cell reference (has a digit)', () => {
+    expect(currentIdentifierAtCaret('=SUM(A1', 7)).toBeNull();
+    expect(currentIdentifierAtCaret('=A1', 3)).toBeNull();
+  });
+
+  it('null right after an already-open, complete function call', () => {
+    expect(currentIdentifierAtCaret('=SUM(', 5)).toBeNull();
+  });
+
+  it('null once the caret has moved past the word (trailing whitespace)', () => {
+    expect(currentIdentifierAtCaret('=SUM ', 5)).toBeNull();
+  });
+
+  it('only looks at text up to the caret, ignoring what follows it', () => {
+    // caret between "SUM" and "X" in "SUMX" -- same result as if "X" weren't there
+    expect(currentIdentifierAtCaret('=SUMX', 4)).toEqual({ text: 'SUM', start: 1 });
+  });
+
+  it('null on a malformed prefix (unterminated string) rather than throwing', () => {
+    expect(currentIdentifierAtCaret('=SUM("x', 7)).toBeNull();
+  });
+});