markdownr 0.7.2 → 0.8.1

data/lib/markdown_server/assets/editor-loader.js

@@ -0,0 +1,362 @@
+// markdownr editor loader — CodeMirror 6.
+//
+// All esm.sh URLs are pinned in the page's <script type="importmap"> (see
+// editor_import_map_json in lib/markdown_server/app.rb). Each package has
+// `?external=<shared-deps>` so esm.sh emits bare imports for shared modules
+// (state, view, language, commands), which the importmap then resolves to a
+// single URL each — guaranteeing one instance of each shared module.
+
+import { EditorState, Compartment, RangeSetBuilder } from '@codemirror/state';
+import {
+  EditorView, keymap, highlightActiveLine, lineNumbers,
+  highlightActiveLineGutter, drawSelection, ViewPlugin, Decoration, WidgetType
+} from '@codemirror/view';
+import {
+  defaultKeymap, history, historyKeymap, indentWithTab
+} from '@codemirror/commands';
+import {
+  defaultHighlightStyle, syntaxHighlighting, indentOnInput, bracketMatching,
+  foldGutter, foldKeymap, StreamLanguage, syntaxTree
+} from '@codemirror/language';
+import { searchKeymap, highlightSelectionMatches } from '@codemirror/search';
+import {
+  autocompletion, completionKeymap, closeBrackets, closeBracketsKeymap
+} from '@codemirror/autocomplete';
+import { oneDark } from '@codemirror/theme-one-dark';
+import { markdown } from '@codemirror/lang-markdown';
+import { javascript } from '@codemirror/lang-javascript';
+import { json } from '@codemirror/lang-json';
+import { yaml } from '@codemirror/lang-yaml';
+import { html } from '@codemirror/lang-html';
+import { css } from '@codemirror/lang-css';
+import { python } from '@codemirror/lang-python';
+import { ruby } from '@codemirror/legacy-modes/mode/ruby';
+import { shell } from '@codemirror/legacy-modes/mode/shell';
+import { vim, Vim } from '@replit/codemirror-vim';
+
+// ── Live-preview plugin (subset: headings, strong, emphasis, inline code, links)
+//
+// Lines whose content the cursor (or selection) is currently on are left as
+// raw markdown so the user can edit the syntax. All other supported tokens
+// are decorated: structural marks (#, **, _, `, [, ]) get hidden via
+// Decoration.replace; content gets a class for CSS styling. Anything we
+// don't recognize (tables, fences, lists, images, embeds, etc.) is left
+// untouched and shows as raw markdown text — that's why the side preview
+// pane is still available for the cases this subset can't render.
+
+const HEADING_LEVEL = {
+  ATXHeading1: 1, ATXHeading2: 2, ATXHeading3: 3,
+  ATXHeading4: 4, ATXHeading5: 5, ATXHeading6: 6,
+};
+
+class BulletWidget extends WidgetType {
+  toDOM() {
+    const span = document.createElement('span');
+    span.className = 'cm-md-bullet';
+    span.textContent = '• ';
+    return span;
+  }
+  eq() { return true; }
+  ignoreEvent() { return false; }
+}
+
+function buildLivePreviewDecorations(view) {
+  const tree = syntaxTree(view.state);
+
+  const sel = view.state.selection.main;
+  const cursorLines = new Set();
+  const lineFromIdx = view.state.doc.lineAt(sel.from).number;
+  const lineToIdx = view.state.doc.lineAt(sel.to).number;
+  for (let l = lineFromIdx; l <= lineToIdx; l++) cursorLines.add(l);
+
+  const lineHasCursor = (pos) => cursorLines.has(view.state.doc.lineAt(pos).number);
+
+  // We collect ranges into an array and let Decoration.set(..., true) sort
+  // them. RangeSetBuilder requires strict monotonic (from, startSide)
+  // ordering, but the markdown tree visits a parent (e.g. StrongEmphasis)
+  // and then its child marker (EmphasisMark) at the same start position —
+  // that's a tie the builder rejects unless the child range starts exactly
+  // where the parent's last range ended, which it doesn't.
+  const ranges = [];
+  const seen = Object.create(null);
+  const add = (from, to, deco) => { ranges.push(deco.range(from, to)); };
+
+  // Walk the entire doc (not just visibleRanges) — for typical markdown
+  // files in the popup this is fine, and avoids pitfalls when the visible
+  // range hasn't settled yet on first construction.
+  {
+    tree.iterate({
+      enter(node) {
+        const name = node.type.name;
+        seen[name] = (seen[name] || 0) + 1;
+        const lvl = HEADING_LEVEL[name];
+
+        if (lvl) {
+          const line = view.state.doc.lineAt(node.from);
+          add(line.from, line.from, Decoration.line({
+            class: `cm-md-line-h${lvl}`
+          }));
+          return;
+        }
+
+        if (name === 'HeaderMark') {
+          const parent = node.node.parent;
+          if (!parent || !HEADING_LEVEL[parent.type.name]) return;
+          if (lineHasCursor(node.from)) return;
+          // Hide "# " (the mark plus the space after it).
+          const after = view.state.doc.sliceString(node.to, node.to + 1);
+          const hideTo = after === ' ' ? node.to + 1 : node.to;
+          add(node.from, hideTo, Decoration.replace({}));
+          return;
+        }
+
+        if (name === 'ListItem') {
+          const line = view.state.doc.lineAt(node.from);
+          add(line.from, line.from, Decoration.line({ class: 'cm-md-list-item' }));
+          return;
+        }
+
+        if (name === 'ListMark') {
+          if (lineHasCursor(node.from)) return;
+          const parent = node.node.parent;
+          if (!parent || parent.type.name !== 'ListItem') return;
+          const list = parent.parent;
+          if (!list) return;
+          if (list.type.name === 'BulletList') {
+            // Replace `- ` (or `*`/`+` plus its trailing space) with a `• ` widget.
+            const after = view.state.doc.sliceString(node.to, node.to + 1);
+            const hideTo = after === ' ' ? node.to + 1 : node.to;
+            add(node.from, hideTo, Decoration.replace({ widget: new BulletWidget() }));
+          }
+          // OrderedList: leave the "1." marker visible — easier than tracking
+          // the actual sequence number, and reads fine as-is.
+          return;
+        }
+
+        // Styling classes always apply (Obsidian-style: bold/italic/code stay
+        // visually styled even when the cursor is on the line). Only the
+        // syntax markers (**, _, `, [, ], (url)) are revealed/hidden based on
+        // cursor position.
+
+        if (name === 'StrongEmphasis') {
+          add(node.from, node.to, Decoration.mark({ class: 'cm-md-strong' }));
+          return;
+        }
+
+        if (name === 'Emphasis') {
+          add(node.from, node.to, Decoration.mark({ class: 'cm-md-em' }));
+          return;
+        }
+
+        if (name === 'EmphasisMark') {
+          if (lineHasCursor(node.from)) return;
+          const parent = node.node.parent;
+          if (!parent) return;
+          if (parent.type.name === 'Emphasis' || parent.type.name === 'StrongEmphasis') {
+            add(node.from, node.to, Decoration.replace({}));
+          }
+          return;
+        }
+
+        if (name === 'InlineCode') {
+          add(node.from, node.to, Decoration.mark({ class: 'cm-md-code' }));
+          return;
+        }
+
+        if (name === 'CodeMark') {
+          if (lineHasCursor(node.from)) return;
+          const parent = node.node.parent;
+          if (parent && parent.type.name === 'InlineCode') {
+            add(node.from, node.to, Decoration.replace({}));
+          }
+          return;
+        }
+
+        if (name === 'Link') {
+          add(node.from, node.to, Decoration.mark({ class: 'cm-md-link' }));
+          return;
+        }
+
+        if (name === 'LinkMark' || name === 'URL') {
+          if (lineHasCursor(node.from)) return;
+          const parent = node.node.parent;
+          if (parent && parent.type.name === 'Link') {
+            add(node.from, node.to, Decoration.replace({}));
+          }
+          return;
+        }
+      }
+    });
+  }
+  if (typeof window !== 'undefined') {
+    window.__lpDebug = {
+      treeRoot: tree.type.name,
+      docLength: view.state.doc.length,
+      seenNodeTypes: seen,
+      decorationsAdded: ranges.length,
+      ranAt: new Date().toISOString(),
+    };
+  }
+  return Decoration.set(ranges, true);
+}
+
+const livePreviewPlugin = ViewPlugin.fromClass(class {
+  constructor(view) { this.decorations = buildLivePreviewDecorations(view); }
+  update(u) {
+    if (u.docChanged || u.viewportChanged || u.selectionSet) {
+      this.decorations = buildLivePreviewDecorations(u.view);
+    }
+  }
+}, { decorations: v => v.decorations });
+
+function languageExtension(name) {
+  switch (name) {
+    case 'markdown': return markdown({ codeLanguages: [] });
+    case 'javascript': return javascript();
+    case 'json': return json();
+    case 'yaml': return yaml();
+    case 'html': return html();
+    case 'css': return css();
+    case 'python': return python();
+    case 'ruby': return StreamLanguage.define(ruby);
+    case 'bash': case 'shell': return StreamLanguage.define(shell);
+    default: return [];
+  }
+}
+
+const baseExtensions = (onChange) => [
+  lineNumbers(),
+  highlightActiveLineGutter(),
+  history(),
+  drawSelection(),
+  foldGutter(),
+  indentOnInput(),
+  syntaxHighlighting(defaultHighlightStyle, { fallback: true }),
+  bracketMatching(),
+  closeBrackets(),
+  autocompletion(),
+  highlightActiveLine(),
+  highlightSelectionMatches(),
+  oneDark,
+  // Live-preview decorations — only emit non-empty results when the active
+  // language is lang-markdown (other parsers' syntax trees never contain the
+  // node names we look for). Adding it at the base level instead of inside
+  // the language compartment avoids confusion when the language is switched.
+  livePreviewPlugin,
+  EditorView.lineWrapping,
+  keymap.of([
+    ...closeBracketsKeymap,
+    ...defaultKeymap,
+    ...searchKeymap,
+    ...historyKeymap,
+    ...foldKeymap,
+    ...completionKeymap,
+    indentWithTab,
+  ]),
+  EditorView.updateListener.of((u) => {
+    if (u.docChanged && onChange) onChange(u.state.doc.toString());
+  }),
+];
+
+// Active editor's vim ex-command handlers. Only one editor can own these at a
+// time (last-set wins). When the focused editor is destroyed, its handlers are
+// cleared so a stale closure doesn't fire against a torn-down view.
+let vimSaveHandler = null;
+let vimQuitHandler = null;
+let vimIsDirtyHandler = null;
+
+function showVimNotice(cm, msg) {
+  if (!cm || typeof cm.openNotification !== 'function') return;
+  const div = document.createElement('div');
+  div.className = 'cm-vim-message';
+  div.style.color = 'red';
+  div.style.whiteSpace = 'pre';
+  div.textContent = msg;
+  cm.openNotification(div, { bottom: true, duration: 4000 });
+}
+
+function vimSaveThenQuit() {
+  if (!vimSaveHandler) {
+    if (vimQuitHandler) vimQuitHandler({ saved: true });
+    return;
+  }
+  Promise.resolve(vimSaveHandler()).then((ok) => {
+    if (ok === false) return;
+    if (vimQuitHandler) vimQuitHandler({ saved: true });
+  });
+}
+
+Vim.defineEx('write', 'w', () => { if (vimSaveHandler) vimSaveHandler(); });
+Vim.defineEx('wq', 'wq', vimSaveThenQuit);
+Vim.defineEx('x', 'x', vimSaveThenQuit);
+Vim.defineEx('quit', 'q', (cm, params) => {
+  // Bang (`:q!`) is parsed into params.argString by codemirror-vim:
+  // commandName='q', argString='!'.
+  const argStr = String((params && params.argString) || '');
+  const force = argStr.indexOf('!') !== -1;
+  if (!force && vimIsDirtyHandler && vimIsDirtyHandler()) {
+    showVimNotice(cm, 'No write since last change (use :q! to discard, :wq to save and quit)');
+    return;
+  }
+  if (vimQuitHandler) vimQuitHandler({ saved: false });
+});
+
+export function createEditor({ parent, doc, language, vim: useVim, onSave, onChange }) {
+  const langCompartment = new Compartment();
+  const vimCompartment = new Compartment();
+
+  const saveKeymap = keymap.of([
+    {
+      key: 'Mod-s',
+      preventDefault: true,
+      run: () => { if (onSave) onSave(); return true; },
+    },
+  ]);
+
+  const state = EditorState.create({
+    doc: doc || '',
+    extensions: [
+      vimCompartment.of(useVim ? vim() : []),
+      saveKeymap,
+      ...baseExtensions(onChange),
+      langCompartment.of(languageExtension(language)),
+    ],
+  });
+
+  const view = new EditorView({ state, parent });
+
+  let mySave = null, myQuit = null, myIsDirty = null;
+
+  return {
+    view,
+    setVim(on) {
+      view.dispatch({ effects: vimCompartment.reconfigure(on ? vim() : []) });
+    },
+    setLanguage(name) {
+      view.dispatch({ effects: langCompartment.reconfigure(languageExtension(name)) });
+    },
+    setSaveHandler(fn) {
+      mySave = fn;
+      vimSaveHandler = fn;
+    },
+    setQuitHandler(quitFn, isDirtyFn) {
+      myQuit = quitFn;
+      myIsDirty = isDirtyFn;
+      vimQuitHandler = quitFn;
+      vimIsDirtyHandler = isDirtyFn;
+    },
+    getValue() {
+      return view.state.doc.toString();
+    },
+    setValue(text) {
+      view.dispatch({ changes: { from: 0, to: view.state.doc.length, insert: text } });
+    },
+    focus() { view.focus(); },
+    destroy() {
+      if (vimSaveHandler === mySave) vimSaveHandler = null;
+      if (vimQuitHandler === myQuit) vimQuitHandler = null;
+      if (vimIsDirtyHandler === myIsDirty) vimIsDirtyHandler = null;
+      view.destroy();
+    },
+  };
+}

data/lib/markdown_server/csv_browser/addon_registry.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+module MarkdownServer
+  module CsvBrowser
+    # Holds one add-on's declarative definition: its `actions` block and a set of
+    # `on :action_id` handler blocks. Created via the DSL inside `register`.
+    class AddonDefinition
+      attr_reader :name
+
+      def initialize(name)
+        @name = name.to_sym
+        @actions_block = nil
+        @handlers = {}
+      end
+
+      def actions(&block)
+        @actions_block = block
+      end
+
+      def on(action_id, &block)
+        @handlers[action_id.to_sym] = block
+      end
+
+      # Returns [{ id:, label:, enabled:, ... }, ...] for the given row context.
+      def actions_for(ctx)
+        return [] unless @actions_block
+
+        result = @actions_block.call(ctx)
+        Array(result).map do |entry|
+          h = entry.dup
+          h[:id] = h[:id].to_sym
+          h[:enabled] = h.key?(:enabled) ? !!h[:enabled] : true
+          h
+        end
+      end
+
+      def handler_for(action_id)
+        @handlers[action_id.to_sym]
+      end
+    end
+
+    # Global registry of CSV add-ons.
+    #
+    # Lifecycle:
+    # 1. A Ruby file calls `MarkdownServer::CsvAddonRegistry.register(:name) { ... }`
+    #    at load time. That block is `instance_exec`'d against a fresh
+    #    `AddonDefinition`, populating its `actions` and `on` entries.
+    # 2. At startup, `load(addons_config, root_dir)` receives the `csv_addons`
+    #    mapping from .markdownr.yml and `require`s each absolute path; missing
+    #    files warn but don't halt startup.
+    # 3. `for_table(db, table)` returns the definitions a given table has
+    #    attached via its `addons:` list; unknown add-on names warn and are
+    #    dropped.
+    class CsvAddonRegistry
+      @definitions = {}
+      @loaded_config = {}
+
+      class << self
+        attr_reader :definitions, :loaded_config
+
+        def reset!
+          @definitions = {}
+          @loaded_config = {}
+        end
+
+        def register(name, &block)
+          defn = AddonDefinition.new(name)
+          defn.instance_exec(&block) if block
+          @definitions[name.to_sym] = defn
+          defn
+        end
+
+        def [](name)
+          @definitions[name.to_sym]
+        end
+
+        def load(addons_config, _root_dir = nil)
+          @loaded_config = (addons_config || {}).each_with_object({}) do |(k, v), h|
+            h[k.to_sym] = v
+          end
+
+          @loaded_config.each do |name, path|
+            unless File.exist?(path.to_s)
+              $stderr.puts "\n\e[1;33mWarning: csv_addon '#{name}' file not found: #{path}\e[0m\n\n"
+              next
+            end
+            # Use Kernel#load (not require) so repeated calls re-evaluate the
+            # add-on file — important after `reset!` in tests and to let users
+            # refresh their add-on without restarting (the gate is the
+            # absolute path in .markdownr.yml).
+            Kernel.load(path.to_s)
+          end
+        end
+
+        # Returns an array of AddonDefinition instances attached to the table.
+        # Unknown names (declared on the table but not registered) produce a
+        # one-time warning per (table, name) and are skipped.
+        def for_table(_database, table)
+          attached = Array(table.addons).map { |entry| normalize_attachment(entry) }
+          attached.filter_map do |att|
+            defn = @definitions[att[:name]]
+            unless defn
+              key = [table.key, att[:name]]
+              @warned_missing ||= {}
+              unless @warned_missing[key]
+                $stderr.puts "\n\e[1;33mWarning: table '#{table.key}' references unknown csv_addon '#{att[:name]}'\e[0m\n\n"
+                @warned_missing[key] = true
+              end
+              next
+            end
+            { definition: defn, options: att[:options] }
+          end
+        end
+
+        private
+
+        def normalize_attachment(entry)
+          case entry
+          when String, Symbol
+            { name: entry.to_sym, options: {} }
+          when Hash
+            sym = entry.transform_keys(&:to_sym)
+            opts = sym[:options] || {}
+            opts = opts.transform_keys(&:to_sym) if opts.is_a?(Hash)
+            { name: (sym[:id] || sym[:name]).to_sym, options: opts }
+          else
+            { name: :__invalid__, options: {} }
+          end
+        end
+      end
+    end
+  end
+
+  # Top-level alias so add-on files can write:
+  #   MarkdownServer::CsvAddonRegistry.register(:name) { ... }
+  CsvAddonRegistry = CsvBrowser::CsvAddonRegistry
+end