lilac-cli 0.2.0

data/lib/lilac/cli/build/runtime_resolver.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Lilac
+  module CLI
+    # Shared discovery logic for the two build-target runtimes
+    # (`:full` / `:compiled`). Both vendor a wasm bundle plus the SAME
+    # mruby-wasm-js JS bridge into `dist/vendor/lilac-<target>/`, and both
+    # discover sources in the same order: explicit CLI/config → env →
+    # `lilac-wasm-bin` gem (the canonical install path — decisions §25) →
+    # monorepo sibling layout for in-repo development.
+    #
+    # The bridge is identical across targets, so its resolution lives
+    # here. Subclasses supply only the wasm-specific bits via the
+    # protected hooks at the bottom (env key, gem accessor, monorepo
+    # candidate, not-found message).
+    class RuntimeResolver
+      # Common ancestor so a caller can `rescue RuntimeResolver::Error`
+      # for either target. Each subclass defines its own `Error <
+      # RuntimeResolver::Error` and the `resolve_*!` methods raise
+      # `self.class::Error`, so `FullRuntimeResolver::Error` and
+      # `CompiledRuntimeResolver::Error` stay distinct (a rescue of one
+      # doesn't swallow the other).
+      class Error < StandardError; end
+
+      def initialize(lilac_wasm_path: nil, mruby_wasm_js_path: nil,
+                     monorepo_root: nil, disable_gem_discovery: false)
+        @configured_wasm_path   = lilac_wasm_path
+        @configured_bridge_path = mruby_wasm_js_path
+        # Tests inject a dummy directory to keep the (real) monorepo wasm
+        # from being discovered; production callers leave it nil and the
+        # gem-relative ancestor is used.
+        @monorepo_root_override = monorepo_root
+        # Tests that exercise the fallback chain pass `true` so the gem's
+        # wasm doesn't satisfy a "nothing should resolve" expectation.
+        @disable_gem_discovery  = disable_gem_discovery
+      end
+
+      # Absolute path to the wasm, or nil if none of the discovery routes
+      # turn up a readable file. Non-raising: use this to *report*
+      # discoverability (Doctor); use `resolve_wasm!` on the build path
+      # where absence must be a hard error.
+      def wasm_path
+        return @configured_wasm_path if File.file?(@configured_wasm_path.to_s)
+        if (env = ENV[wasm_env_key]) && File.file?(env)
+          return env
+        end
+        if (gem_wasm = gem_provided_wasm) && File.file?(gem_wasm)
+          return gem_wasm
+        end
+        monorepo_wasm_candidate.then { |c| return c if File.file?(c) }
+
+        nil
+      end
+
+      # Directory containing the bridge's `index.js`, or nil if not found.
+      # Shared across targets — the bridge artifact is the same for both.
+      def bridge_path
+        if @configured_bridge_path
+          return @configured_bridge_path if bridge_dir?(@configured_bridge_path)
+        end
+        if (env = ENV["MRUBY_WASM_JS_PATH"]) && bridge_dir?(env)
+          return env
+        end
+        [
+          gem_provided_bridge,        # `lilac-wasm-bin` gem (canonical install path)
+          monorepo_bridge_candidate,
+        ].compact.find { |c| bridge_dir?(c) }
+      end
+
+      # Raising variants for the build path: a missing runtime must fail
+      # the build loudly with an actionable message.
+      def resolve_wasm!
+        wasm_path || raise(self.class::Error, wasm_not_found_message)
+      end
+
+      def resolve_bridge!
+        bridge_path || raise(self.class::Error, bridge_not_found_message)
+      end
+
+      private
+
+      # Soft-requires the `lilac-wasm-bin` gem for the bridge directory,
+      # or nil if the gem isn't on the load path.
+      def gem_provided_bridge
+        return nil if @disable_gem_discovery
+        require "lilac/wasm/bin"
+        ::Lilac::Wasm::Bin.mruby_wasm_js_dir
+      rescue LoadError
+        nil
+      end
+
+      def monorepo_bridge_candidate
+        candidate = File.join(monorepo_root, "mrbgem", "mruby-wasm-js", "js")
+        candidate if File.directory?(candidate)
+      end
+
+      def bridge_dir?(path)
+        File.directory?(path.to_s) && File.file?(File.join(path.to_s, "index.js"))
+      end
+
+      # The cli gem ships from `<repo>/cli`. This file lives at
+      # `<repo>/cli/lib/lilac/cli/build/runtime_resolver.rb`, so `<repo>`
+      # is five levels up. When installed via rubygems the cli gem is
+      # unpacked alone — the candidates simply won't exist, which is fine:
+      # discovery falls through to gem / explicit overrides.
+      def monorepo_root
+        @monorepo_root ||= @monorepo_root_override || File.expand_path("../../../../..", __dir__)
+      end
+
+      def bridge_not_found_message
+        <<~MSG.strip
+          @takahashim/mruby-wasm-js bridge not found. Tried:
+            • configured `c.mruby_wasm_js_path` (#{@configured_bridge_path.inspect})
+            • ENV["MRUBY_WASM_JS_PATH"] (#{ENV["MRUBY_WASM_JS_PATH"].inspect})
+            • lilac-wasm-bin gem (not on load path)
+            • monorepo: #{monorepo_bridge_candidate || '(no mrbgem/mruby-wasm-js/js dir)'}
+
+          To fix, either:
+            • Add `gem "lilac-wasm-bin"` to your Gemfile (recommended)
+            • Pass `--mruby-wasm-js-path /abs/path/to/mruby-wasm-js/` on the command line
+            • Add `c.mruby_wasm_js_path = "/abs/path"` to lilac.config.rb
+            • Set ENV["MRUBY_WASM_JS_PATH"]
+        MSG
+      end
+
+      # ---- wasm-specific hooks (subclasses must override) --------------
+
+      # ENV var consulted for an explicit wasm path.
+      def wasm_env_key
+        raise NotImplementedError, "#{self.class} must define #wasm_env_key"
+      end
+
+      # Path the `lilac-wasm-bin` gem publishes for this target's wasm,
+      # or nil if the gem isn't loadable / discovery is disabled.
+      def gem_provided_wasm
+        raise NotImplementedError, "#{self.class} must define #gem_provided_wasm"
+      end
+
+      # The monorepo `build/<wasm>` candidate for in-repo development.
+      def monorepo_wasm_candidate
+        raise NotImplementedError, "#{self.class} must define #monorepo_wasm_candidate"
+      end
+
+      # Actionable "wasm not found" message naming this target's overrides.
+      def wasm_not_found_message
+        raise NotImplementedError, "#{self.class} must define #wasm_not_found_message"
+      end
+    end
+  end
+end

data/lib/lilac/cli/build/sfc.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module Lilac
+  module CLI
+    # Parses a `.lil` single-file component into its constituent parts:
+    #
+    #   * one or more `<template>` blocks, optionally named via
+    #     `data-template="..."` (a standard HTML5 data attribute, same as
+    #     what the Lilac runtime expects for clone-targets)
+    #   * one or more `<script type="text/ruby">` blocks
+    #
+    # The format is HTML5-valid: any conformant HTML parser (browser,
+    # nokogiri, gammo) can build a DOM from a `.lil` file. We use regex
+    # rather than a full HTML parser internally because we want the
+    # `<template>` inner content **verbatim** — a DOM-based parser would
+    # require re-serializing children back to HTML and would normalize
+    # quote / whitespace / attribute order along the way.
+    #
+    # The parsed result is a `Component` value object. Order of templates
+    # is preserved from the source; named templates remember their name.
+    # Anonymous templates (no `data-template` attribute) are the
+    # component's "default" markup; multiple anonymous templates are
+    # allowed and concatenated in document order.
+    module SFC
+      # `name` is nil for anonymous templates.
+      Template = Struct.new(:name, :body, keyword_init: true)
+
+      # `path` is the source file path (or nil for in-memory parses).
+      # `templates` is an Array<Template>, `script` is a single concatenated
+      # String of all Ruby blocks joined by a newline.
+      Component = Struct.new(:path, :templates, :script, keyword_init: true) do
+        def default_templates
+          templates.select { |t| t.name.nil? }
+        end
+
+        def named_templates
+          templates.reject { |t| t.name.nil? }
+        end
+      end
+
+      class ParseError < StandardError; end
+
+      TEMPLATE_OPEN = /<template(?:\s+data-template="([^"]*)")?\s*>/
+      TEMPLATE_CLOSE = "</template>"
+      SCRIPT_OPEN = /<script\s+type="text\/ruby"\s*>/
+      SCRIPT_CLOSE = "</script>"
+
+      def self.parse_file(path)
+        parse(File.read(path), path: path)
+      end
+
+      # Walks the source linearly so nested `<template>` / `<script>` tags
+      # don't get matched by a greedy regex. Each iteration:
+      #   1. find the earliest opening tag (template or script)
+      #   2. find its matching close, extract the body
+      #   3. advance past the close
+      def self.parse(source, path: nil)
+        templates = []
+        script_parts = []
+        cursor = 0
+
+        while cursor < source.length
+          tmpl_match = source.match(TEMPLATE_OPEN, cursor)
+          script_match = source.match(SCRIPT_OPEN, cursor)
+
+          # Earlier of the two openings wins; nil-safe sort by offset.
+          next_match = [tmpl_match, script_match].compact
+                                                 .min_by { |m| m.begin(0) }
+          break unless next_match
+
+          if next_match == tmpl_match
+            templates << extract_template(source, tmpl_match, path)
+            cursor = source.index(TEMPLATE_CLOSE, tmpl_match.end(0)) + TEMPLATE_CLOSE.length
+          else
+            script_parts << extract_script(source, script_match, path)
+            cursor = source.index(SCRIPT_CLOSE, script_match.end(0)) + SCRIPT_CLOSE.length
+          end
+        end
+
+        Component.new(
+          path: path,
+          templates: templates,
+          script: script_parts.join("\n"),
+        )
+      end
+
+      def self.extract_template(source, match, path)
+        name = match[1].to_s.empty? ? nil : match[1]
+        body_start = match.end(0)
+        body_end = source.index(TEMPLATE_CLOSE, body_start)
+        raise ParseError, "Unterminated <template> in #{path || '<input>'}" unless body_end
+
+        Template.new(name: name, body: source[body_start...body_end])
+      end
+
+      def self.extract_script(source, match, path)
+        body_start = match.end(0)
+        body_end = source.index(SCRIPT_CLOSE, body_start)
+        raise ParseError, "Unterminated <script type=\"text/ruby\"> in #{path || '<input>'}" unless body_end
+
+        source[body_start...body_end]
+      end
+
+      # Walk an arbitrary HTML string for `<script type="text/ruby">…</script>`
+      # blocks (the same shape `.lil` files use). Returns the source strings in
+      # document order plus an HTML copy with each block removed verbatim
+      # (open tag + body + close tag). Other `<script>` types (e.g. `module`,
+      # untyped) are untouched.
+      #
+      # Used by the page-build path so a page may embed inline Ruby without
+      # being silently dropped on the compiled target.
+      def self.extract_inline_ruby_scripts(html, path: nil)
+        scripts = []
+        ranges = []
+        cursor = 0
+
+        while (script_match = html.match(SCRIPT_OPEN, cursor))
+          body_start = script_match.end(0)
+          body_end = html.index(SCRIPT_CLOSE, body_start) or
+            raise ParseError, "Unterminated <script type=\"text/ruby\"> in #{path || '<input>'}"
+
+          scripts << html[body_start...body_end]
+          ranges << (script_match.begin(0)...(body_end + SCRIPT_CLOSE.length))
+          cursor = body_end + SCRIPT_CLOSE.length
+        end
+
+        stripped = remove_ranges(html, ranges)
+        { stripped_html: stripped, scripts: scripts }
+      end
+
+      # Drop the byte ranges (sorted in document order) from `html` and
+      # collapse the now-empty surrounding whitespace minimally — we keep
+      # surrounding HTML formatting untouched and only delete the matched
+      # script tags themselves.
+      def self.remove_ranges(html, ranges)
+        return html if ranges.empty?
+
+        result = +""
+        prev_end = 0
+        ranges.each do |r|
+          result << html[prev_end...r.begin]
+          prev_end = r.end
+        end
+        result << html[prev_end..]
+        result
+      end
+      private_class_method :remove_ranges
+    end
+  end
+end

data/lib/lilac/cli/build/template_ast.rb

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+require "nokogiri"
+require_relative "build_error"
+require_relative "directive"
+
+module Lilac
+  module CLI
+    # Parses a template body HTML fragment with Nokogiri, walks the
+    # element tree, and:
+    #
+    #   1. Collects every `data-*` directive into a flat list of
+    #      `Directive` records (in document order) for the lint layer.
+    #   2. Assigns a synthetic `data-ref="lilN"` to any element bearing
+    #      a binding directive but no explicit `data-ref`, so the
+    #      runtime scanner can resolve it positionally at mount.
+    #   3. Builds `refs_map` keyed by ref name, recording each ref's
+    #      source line for duplicate / reserved-name lint checks.
+    #
+    # SFC's regex-based template extraction (`SFC.parse`) preserves the
+    # template body byte-for-byte. TemplateAST does NOT preserve byte
+    # equality on the way out — Nokogiri normalizes quoting and
+    # boolean attribute serialization. The HTML returned by `parse` is
+    # round-tripped through Nokogiri::HTML5.
+    #
+    # Directive values are NOT validated against the value grammar here
+    # — directive attributes are left in the output HTML so the runtime
+    # scanner sees `data-component` / `data-ref` and the directives it
+    # binds at mount time.
+    class TemplateAST
+      # Subclass of BuildError so callers can `rescue BuildError` to
+      # catch every build-time failure uniformly, regardless of source.
+      class Error < BuildError; end
+
+      Result = Struct.new(:html, :directives, :refs_map, keyword_init: true)
+
+      # Maps an attribute-name regex to its directive kind. Order matters:
+      # the more specific X-family patterns (`data-on-X` etc.) must be
+      # checked before the simpler ones so that `data-on-click` is
+      # classified as `:on` not as an unknown attribute.
+      #
+      # `class_` trailing underscore avoids shadowing Ruby's reserved
+      # `class` keyword in pattern-match contexts; symbol-side only.
+
+      DIRECTIVE_PATTERNS = [
+        [/\Adata-text\z/,        :text,        false],
+        [/\Adata-unsafe-html\z/, :unsafe_html, false],
+        # data-bind is the form-independent two-way binding directive
+        # (Phase E revival/unification of data-value / data-checked).
+        # Property auto-selected from element type:
+        # <input type=checkbox> → :checked, others → :value.
+        # See directive-spec §6.2 for the full grammar; runtime parity
+        # lives in runtime/mruby-lilac-directives/.
+        [/\Adata-bind\z/,        :bind,        false],
+        [/\Adata-show\z/,        :show,        false],
+        [/\Adata-hide\z/,        :hide,        false],
+        [/\Adata-each\z/,        :each,        false],
+        [/\Adata-key\z/,         :key,         false],
+        [/\Adata-class\z/,       :class_,      false],
+        # data-component is detected only so collision checks can see
+        # it; it has no emit_* of its own (the runtime autoregister
+        # reads the HTML attribute directly) and `walk` skips Directive
+        # records when it appears alone, to keep the dist HTML and the
+        # linter input unchanged for the common case.
+        [/\Adata-component\z/,   :component,   false],
+        # Form directives (mruby-lilac-form gem). Collected so scope
+        # validation / lint can see them; the runtime form scanner wires
+        # the actual behavior at mount (resolves scope via ancestor walk).
+        [/\Adata-form\z/,        :form,        false],
+        [/\Adata-field\z/,       :field,       false],
+        [/\Adata-button\z/,      :button,      false],
+        [/\Adata-on-(.+)\z/,     :on,          true],
+        [/\Adata-attr-(.+)\z/,   :attr,        true],
+        [/\Adata-arg-(.+)\z/,    :arg,         true],
+        [/\Adata-css-(.+)\z/,    :css,         true],
+      ].freeze
+
+      def initialize(body_html, source_path: nil)
+        @body_html = body_html
+        @source_path = source_path
+      end
+
+      # Immutable per-frame walk state: the stacks that get pushed/popped
+      # as the walker descends/ascends. Bundled so `walk` doesn't have to
+      # thread individual args through recursion (the accumulators —
+      # directives / refs_map — are mutated in place and stay separate).
+      class WalkScopes
+        # each_scope: ref_ids of currently-open `data-each` elements;
+        #             children's directives carry `scope_id = each_scope.last`
+        # ref_scopes: Stack<{ ref_name => line }> for duplicate ref detection
+        #             per `data-each` / `data-component` scope
+        attr_reader :each_scope, :ref_scopes
+
+        def initialize(each_scope: [], ref_scopes: [{}])
+          @each_scope = each_scope
+          @ref_scopes = ref_scopes
+        end
+
+        # Push helpers return a NEW WalkScopes — frames are immutable so
+        # the recursive call doesn't accidentally mutate the parent's stack.
+        def push_each(ref_id)
+          self.class.new(each_scope: @each_scope + [ref_id], ref_scopes: @ref_scopes)
+        end
+
+        def push_ref_scope
+          self.class.new(each_scope: @each_scope, ref_scopes: @ref_scopes + [{}])
+        end
+
+        def current_ref_scope
+          @ref_scopes.last
+        end
+
+        def current_each_ref
+          @each_scope.last
+        end
+      end
+
+      def parse
+        fragment = Nokogiri::HTML5.fragment(@body_html)
+        directives = []
+        refs_map = {}
+        # `at_root: true` for the outermost walk — when the first
+        # element child of the fragment carries `data-component`, it's
+        # the component's own root (this AST run IS that component),
+        # so its directives + body belong to this component. Any deeper
+        # `data-component` element is a different component; we treat
+        # those subtrees opaquely so their directives don't leak into
+        # the current component's scope.
+        walk(fragment, directives, refs_map, WalkScopes.new, at_root: true)
+
+        Result.new(
+          html: fragment.to_html,
+          directives: directives,
+          refs_map: refs_map,
+        )
+      end
+
+      private
+
+      # `scopes` is a WalkScopes carrying two immutable stacks:
+      #   - each_scope: ref_ids of currently-open `data-each` elements
+      #     (children carry `scope_id` pointing at the enclosing iteration).
+      #   - ref_scopes: per-scope `data-ref` namespace for duplicate detection.
+      #     `data-each` AND `data-component` both open a fresh ref scope —
+      #     iteration bodies and nested component subtrees each get clean
+      #     ref sets. The directive `each_scope` is unaffected by
+      #     `data-component` (its body's directives still belong to the
+      #     parent component's scope).
+      def walk(node, directives, refs_map, scopes, at_root: false)
+        node.element_children.to_a.each do |elem|
+          element_directives = collect_directives_with_synthesis(elem)
+          has_each = element_directives.any? { |k, _, _| k == :each }
+          has_component = element_directives.any? { |k, _, _| k == :component }
+
+          # Nested `data-component` (not the parse's outermost element)
+          # is a different component, whose directives + body are
+          # handled by its OWN AST run. Skip the entire subtree —
+          # don't record directives, don't recurse — so the parent's
+          # bindings don't double-cover what the nested component will
+          # already wire at mount.
+          if has_component && !at_root
+            next
+          end
+
+          # A bare `data-component` element needs no ref_id (the runtime
+          # mounts via the data-component attribute), so we skip the
+          # Directive record entirely to keep the dist HTML byte-identical
+          # and the linter input clean. The :component record only matters
+          # when it coexists with another directive (e.g. `data-each`)
+          # so Lilac::Directives::Lints can flag the collision.
+          has_real_directive = element_directives.any? { |k, _, _| k != :component }
+          ref_id = nil
+
+          if has_real_directive
+            ref_id = assign_or_reuse_ref(elem, scopes.current_ref_scope)
+            element_directives.each do |kind, name, attr_value|
+              directives << Directive.new(
+                kind: kind,
+                name: name,
+                value: attr_value,
+                ref_id: ref_id,
+                line: elem.line,
+                element_tag: elem.name,
+                scope_id: scopes.current_each_ref,
+              )
+            end
+            refs_map[ref_id] ||= elem.line
+          elsif (explicit = elem["data-ref"]) && !explicit.empty?
+            # Ref declared on an element without any other directive
+            # (e.g. `<input data-ref="email">` used only by user-side
+            # `refs.email`). Still register so duplicates trip the
+            # check, but don't allocate a synthetic / Directive record.
+            unless scopes.current_ref_scope.key?(explicit)
+              register_ref!(explicit, elem.line, scopes.current_ref_scope)
+            end
+          end
+
+          child_scopes = scopes
+          # `has_component` only pushes a fresh ref scope for NESTED
+          # data-component elements — and we already `next` on those
+          # above, so we never reach this branch for them. The root
+          # data-component shares its ref scope with this AST run.
+          child_scopes = child_scopes.push_ref_scope if has_each
+
+          if has_each
+            # scanner-canonical: keep the data-each row IN-PLACE. The
+            # runtime scanner's `dispatch_each` snapshots the live
+            # innerHTML, empties the container, and clones per item — so
+            # the builder must NOT extract the row. We still recurse to
+            # collect directives for lint scoping.
+            walk(elem, directives, refs_map, child_scopes.push_each(ref_id))
+          else
+            walk(elem, directives, refs_map, child_scopes)
+          end
+        end
+      end
+
+      # Returns Array<[kind, name, value]> for every directive on `elem`.
+      # `name` is nil for non-X-family directives.
+      def extract_directives(elem)
+        result = []
+        elem.attributes.each do |attr_name, attr|
+          match_row = DIRECTIVE_PATTERNS.find { |pattern, _, _| pattern.match(attr_name) }
+          next unless match_row
+
+          pattern, kind, captures_name = match_row
+          match = pattern.match(attr_name)
+          name = captures_name ? match[1] : nil
+          result << [kind, name, attr.value]
+        end
+        result
+      end
+
+      # Wraps `extract_directives` to inject a synthetic `:form` directive
+      # for bare `<form>` elements (no data-form attr), so the lint layer
+      # sees the form even when the author didn't name a scope. Keeping
+      # this in one named helper makes the "directives can include things
+      # not in the HTML" surprise explicit rather than buried in `walk`.
+      def collect_directives_with_synthesis(elem)
+        directives = extract_directives(elem)
+        if elem.name == "form" && directives.none? { |k, _, _| k == :form }
+          directives << [:form, nil, ""]
+        end
+        directives
+      end
+
+      # If the element already has an explicit `data-ref`, reuse it
+      # (so user-chosen refs remain stable across rebuilds) but
+      # register it so a duplicate in the same scope raises. Otherwise
+      # allocate a fresh synthetic name based on the scope's current
+      # size — `refs.lilN` is resolved positionally at runtime, so the
+      # name doesn't need to be written back to the DOM (decisions §19).
+      def assign_or_reuse_ref(elem, current_ref_scope)
+        existing = elem["data-ref"]
+        if existing && !existing.empty?
+          # register_ref! enforces the `lilN`-namespace reservation +
+          # in-scope uniqueness.
+          register_ref!(existing, elem.line, current_ref_scope)
+          return existing
+        end
+
+        # Per-scope counter — synthetic refs are positional indices
+        # (0-based) within the current data-component / data-each scope.
+        # The runtime walks the same DFS order and maps `lilN` → N-th
+        # directive-bearing element. NO DOM mutation: the dist HTML
+        # carries no synthetic `data-ref` attributes for normal
+        # directive elements (decisions §19).
+        counter = current_ref_scope.size
+        loop do
+          candidate = "lil#{counter}"
+          counter += 1
+          next if current_ref_scope.key?(candidate)
+
+          current_ref_scope[candidate] = elem.line
+          return candidate
+        end
+      end
+
+      def register_ref!(ref, line, current_ref_scope)
+        # `lilN` is reserved for runtime positional ref slots — see ADR-0019.
+        if ref.match?(/^lil\d+$/)
+          raise Error.new(
+            "data-ref=#{ref.inspect}: the `lilN` namespace is reserved for runtime-internal directive slots.",
+            at: SourceLocation.new(file: source_file, line: line),
+            suggestion: "Use a domain name like `email` / `list` instead.",
+          )
+        end
+        previous = current_ref_scope[ref]
+        if previous
+          raise Error.new(
+            "Duplicate data-ref #{ref.inspect} — already declared at line #{previous} in the same template scope.",
+            at: SourceLocation.new(file: source_file, line: line),
+            suggestion: "Rename one of them; data-ref names must be unique within a top-level / data-each / data-component scope.",
+          )
+        end
+        current_ref_scope[ref] = line
+      end
+
+      def source_file
+        @source_path ? File.basename(@source_path) : "(template)"
+      end
+    end
+  end
+end

data/lib/lilac/cli/build/template_ast_cache.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "template_ast"
+
+module Lilac
+  module CLI
+    # Memoizes parsed component template ASTs by component name. The
+    # same `.lil` shape often appears on many pages; the parse step is
+    # not free and the parsed result is immutable, so caching once per
+    # build keeps multi-page builds linear in components rather than
+    # `pages × components`.
+    #
+    # Shared by `Builder` (when emitting the :bundle delivery file) and
+    # `PageCompiler` (per-page injection). Both read through `fetch`;
+    # writes happen lazily on miss.
+    class TemplateASTCache
+      # A user-defined named template (from `<template data-template="...">`
+      # in `.lil` source) ready to be injected as `<template
+      # data-template="X">` into the page.
+      RenderedTemplate = Struct.new(:name, :html, keyword_init: true)
+
+      def initialize
+        @cache = {}
+      end
+
+      # Returns a Hash with:
+      #   :default_html        — concatenated body HTML of the default templates
+      #   :default_directives  — Array<Directive> for top-level binding emission
+      #   :default_refs_map    — Hash { ref_name => line } for lint
+      #   :named               — Array<RenderedTemplate> (user-defined)
+      #   :source_path         — Path to the `.lil` (or in-memory page)
+      def fetch(name, component)
+        @cache[name] ||= parse(component)
+      end
+
+      private
+
+      def parse(component)
+        default_results = component.default_templates.map do |t|
+          TemplateAST.new(t.body, source_path: component.path).parse
+        end
+
+        named = component.named_templates.map do |t|
+          result = TemplateAST.new(t.body, source_path: component.path).parse
+          RenderedTemplate.new(name: t.name, html: result.html)
+        end
+
+        {
+          default_html: default_results.map(&:html).join.strip,
+          default_directives: default_results.flat_map(&:directives),
+          default_refs_map: default_results.map(&:refs_map).reduce({}, :merge),
+          named: named,
+          source_path: component.path
+        }
+      end
+    end
+  end
+end