hecks 3.2.0 → 3.3.0

data/rust/project/exemplar.rb

@@ -1,148 +0,0 @@
-module RustProjection
-  # Loads the `// TMPL:<id> BEGIN/END` shapes in rust/src/exemplar/*.rs and renders them
-  # by substituting the fixed `Tmpl`/`tmpl_`/`TMPL_` placeholders with real domain names.
-  module Exemplar
-    # Matches any placeholder token. After substitution nothing may match, so an
-    # unfilled placeholder raises instead of leaking `TmplType` into generated output.
-    LEFTOVER_PLACEHOLDER = /\b(?:Tmpl\w*|tmpl_\w*|TMPL_\w*)\b/
-
-    DEFAULT_DIR = File.expand_path("../src/exemplar", __dir__)
-
-    class DriftError < StandardError; end
-
-    class << self
-      # Overridable so specs can point at a scratch fixture tree.
-      def dir
-        @dir ||= DEFAULT_DIR
-      end
-
-      # `id` -> raw shape text (dedented, marker lines excluded).
-      # A nested region leaves a `<<TMPL_SLOT:<id>:<sub>>>` sentinel; see `compose`.
-      def shapes
-        @shapes ||= parse_all
-      end
-
-      # Renders `shape_id`, replacing each `subs` key (a literal substring) with its value.
-      # Raises DriftError on a key absent from the shape or a placeholder left over.
-      #
-      # Uses the block form of gsub: the two-arg form interprets backslash sequences in
-      # the replacement, which corrupts escaped regex sources.
-      def render(shape_id, subs)
-        text = raw(shape_id)
-
-        subs.keys.sort_by { |k| -k.length }.each do |marker|
-          raise DriftError, "Exemplar.render(#{shape_id.inspect}): marker #{marker.inspect} not found in shape text — " \
-                             "exemplar and Ruby caller have drifted" unless text.include?(marker)
-
-          value = subs[marker]
-          text = text.gsub(marker) { value }
-        end
-
-        if (leftover = text.scan(LEFTOVER_PLACEHOLDER)).any?
-          raise DriftError, "Exemplar.render(#{shape_id.inspect}): unrendered placeholder(s) #{leftover.uniq.inspect} — " \
-                             "subs is missing a marker this shape actually contains"
-        end
-
-        text
-      end
-
-      # Renders `shape_id` once per entry in `subs_list`, joined by `join_with`.
-      def render_each(shape_id, subs_list, join_with: "\n")
-        subs_list.map { |subs| render(shape_id, subs) }.join(join_with)
-      end
-
-      # Fills every nested slot of `outer_id` (`slots` maps field_id => rendered content),
-      # reindenting each to its marker's depth, then applies `outer_subs` last so a marker
-      # cannot match text that came from a slot.
-      def assemble(outer_id, outer_subs, slots:)
-        outer_text = raw(outer_id)
-
-        slots.each do |field_id, content|
-          slot = "<<TMPL_SLOT:#{field_id}>>"
-          slot_line = outer_text.match(/^([ \t]*)#{Regexp.escape(slot)}$/)
-          raise DriftError, "Exemplar.assemble(#{outer_id.inspect}): no nested slot for #{field_id.inspect} — " \
-                             "expected a `// TMPL:#{field_id} BEGIN/END` region nested inside `// TMPL:#{outer_id} BEGIN/END`" unless slot_line
-
-          # The nested marker's indentation in the exemplar sets the depth, not the caller.
-          indent = slot_line[1]
-          reindented = content.lines.map { |l| l.strip.empty? ? l : "#{indent}#{l}" }.join
-          outer_text = outer_text.sub(slot_line[0]) { reindented } # block form: see render
-        end
-
-        outer_subs.keys.sort_by { |k| -k.length }.each do |marker|
-          raise DriftError, "Exemplar.assemble(#{outer_id.inspect}): marker #{marker.inspect} not found in outer shape text" unless outer_text.include?(marker)
-
-          value = outer_subs[marker]
-          outer_text = outer_text.gsub(marker) { value }
-        end
-
-        if (leftover = outer_text.scan(LEFTOVER_PLACEHOLDER)).any?
-          raise DriftError, "Exemplar.assemble(#{outer_id.inspect}): unrendered placeholder(s) #{leftover.uniq.inspect}"
-        end
-
-        outer_text
-      end
-
-      # `assemble` for the single-slot case: renders the inner shape `field_id` once per
-      # entry in `field_subs_list` and splices the joined result into `outer_id`.
-      def compose(outer_id, outer_subs, field_id:, field_subs_list:, join_with: "\n")
-        assemble(outer_id, outer_subs, slots: { field_id => render_each(field_id, field_subs_list, join_with: join_with) })
-      end
-
-      def raw(shape_id)
-        shapes.fetch(shape_id) do
-          raise DriftError, "Exemplar: no shape #{shape_id.inspect} — " \
-                             "checked rust/src/exemplar/*.rs for `// TMPL:#{shape_id} BEGIN`"
-        end
-      end
-
-      # Test-only: repoints `dir` and clears the memoized shapes.
-      def reset!(dir: DEFAULT_DIR)
-        @dir = dir
-        @shapes = nil
-      end
-
-      private
-
-      def parse_all
-        result = {}
-        Dir.glob(File.join(dir, "*.rs")).sort.each { |path| parse_file(path, result) }
-        result
-      end
-
-      def parse_file(path, result)
-        stack = [] # each frame: [id, lines, begin_indent]
-        File.readlines(path).each do |line|
-          if (id = begin_marker(line))
-            stack.push([id, [], line[/^[ \t]*/]])
-          elsif (id = end_marker(line))
-            raise "#{path}: TMPL:#{id} END with no matching BEGIN (stack: #{stack.map(&:first).inspect})" if stack.empty? || stack.last[0] != id
-
-            _, lines, begin_indent = stack.pop
-            result[id] = dedent(lines)
-            # Keep the nested marker's indentation; it sets the depth of the spliced lines.
-            stack.last[1] << "#{begin_indent}<<TMPL_SLOT:#{id}>>\n" if stack.any?
-          elsif stack.any?
-            stack.last[1] << line
-          end
-        end
-        raise "#{path}: unclosed TMPL region(s): #{stack.map(&:first).inspect}" if stack.any?
-      end
-
-      def begin_marker(line)
-        line[%r{//\s*TMPL:(\S+)\s+BEGIN\s*$}, 1]
-      end
-
-      def end_marker(line)
-        line[%r{//\s*TMPL:(\S+)\s+END\s*$}, 1]
-      end
-
-      # Drops the leading whitespace shared by all non-blank lines, like `<<~`.
-      def dedent(lines)
-        indents = lines.reject { |l| l.strip.empty? }.map { |l| l[/^[ \t]*/].length }
-        margin = indents.min || 0
-        lines.map { |l| l.empty? ? l : l[margin..] }.join.rstrip
-      end
-    end
-  end
-end

data/rust/project/expr_emitter.rb

@@ -1,72 +0,0 @@
-module RustProjection
-  # Emits Rust `Expr` data-literal source from the `ast` tree of an IR rule row.
-  # Mirrors rust/codegen/src/expr_emitter.rs node for node; see `AstJson::OPS`.
-  # `include` arm below only ever sees a real field/string haystack.
-  module ExprEmitter
-    module_function
-
-    # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
-    def emit_ast(node)
-      case at(node, :op)
-      when "or"  then "Expr::Or(Box::new(#{emit_ast(at(node, :left))}), Box::new(#{emit_ast(at(node, :right))}))"
-      when "and" then "Expr::And(Box::new(#{emit_ast(at(node, :left))}), Box::new(#{emit_ast(at(node, :right))}))"
-      when "not" then "Expr::Not(Box::new(#{emit_ast(at(node, :expr))}))"
-      when "compare"
-        "Expr::Compare { op: #{emit_comparison(at(node, :cmp))}, left: Box::new(#{emit_ast(at(node, :left))}), right: Box::new(#{emit_ast(at(node, :right))}) }"
-      when "include"
-        "Expr::Include { haystack: Box::new(#{emit_ast(at(node, :haystack))}), needle: Box::new(#{emit_ast(at(node, :needle))}) }"
-      when "int"    then "Expr::Int(#{at(node, :value)})"
-      when "float"  then "Expr::Float(#{at(node, :value)}f64)"
-      when "str"    then "Expr::Str(#{at(node, :value).inspect}.to_string())"
-      when "bool"   then "Expr::Bool(#{at(node, :value)})"
-      when "nil"    then "Expr::Nil"
-      when "lookup" then "Expr::Lookup(#{at(node, :path).join('.').inspect})"
-      when "add"    then "Expr::Add(Box::new(#{emit_ast(at(node, :left))}), Box::new(#{emit_ast(at(node, :right))}))"
-      when "sign_test"
-        "Expr::SignTest { op: #{emit_comparison(at(node, :cmp))}, receiver: Box::new(#{emit_ast(at(node, :receiver))}) }"
-      when "empty"  then "Expr::Empty(Box::new(#{emit_ast(at(node, :receiver))}))"
-      when "to_s"   then "Expr::ToS(Box::new(#{emit_ast(at(node, :receiver))}))"
-      when "modulo"
-        "Expr::Modulo { receiver: Box::new(#{emit_ast(at(node, :receiver))}), divisor: Box::new(#{emit_ast(at(node, :divisor))}) }"
-      when "size"   then "Expr::Size(Box::new(#{emit_ast(at(node, :receiver))}))"
-      when "block_predicate"
-        "Expr::BlockPredicate { mode: crate::kernel::BlockMode::#{at(node, :mode).capitalize}, receiver: Box::new(#{emit_ast(at(node, :receiver))}), " \
-          "param: #{at(node, :param).inspect}, predicate: Box::new(#{emit_ast(at(node, :predicate))}) }"
-      when "find"
-        "Expr::Find { receiver: Box::new(#{emit_ast(at(node, :receiver))}), param: #{at(node, :param).inspect}, " \
-          "predicate: Box::new(#{emit_ast(at(node, :predicate))}), path: &[#{at(node, :path).map(&:inspect).join(', ')}] }"
-      when "array"
-        "Expr::Array(vec![#{at(node, :elements).map { |element| emit_ast(element) }.join(', ')}])"
-      when "matches_regex"
-        "Expr::MatchesRegex { receiver: Box::new(#{emit_ast(at(node, :receiver))}), pattern: #{at(node, :pattern).inspect}.to_string(), flags: #{at(node, :flags).inspect}.to_string() }"
-      when "presence"
-        "Expr::Presence { receiver: Box::new(#{emit_ast(at(node, :receiver))}), negated: #{at(node, :negated)} }"
-      when "assignment"
-        "Expr::Assignment { receiver: Box::new(#{emit_ast(at(node, :receiver))}), negated: #{at(node, :negated)} }"
-      when "split"
-        "Expr::Split { receiver: Box::new(#{emit_ast(at(node, :receiver))}), separator: #{at(node, :separator).inspect}.to_string() }"
-      when "starts_with"
-        "Expr::StartsWith { receiver: Box::new(#{emit_ast(at(node, :receiver))}), substring: #{at(node, :substring).inspect}.to_string() }"
-      when "ends_with"
-        "Expr::EndsWith { receiver: Box::new(#{emit_ast(at(node, :receiver))}), substring: #{at(node, :substring).inspect}.to_string() }"
-      when "first" then "Expr::First(Box::new(#{emit_ast(at(node, :receiver))}))"
-      when "last"  then "Expr::Last(Box::new(#{emit_ast(at(node, :receiver))}))"
-      else
-        # An op with no arm above means `AstJson::OPS` grew and this file did not.
-        raise "unhandled ast op #{at(node, :op).inspect} — no Rust rendering exists for it in this generator (rust/project/expr_emitter.rb#emit_ast)"
-      end
-    end
-    # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
-
-    # Fully qualified: the grammar's own "Comparison" closed set would collide with the
-    # kernel struct of the same name in a file that needs both.
-    def emit_comparison(cmp)
-      "crate::kernel::Comparison { less_than: #{at(cmp, :less_than)}, equal: #{at(cmp, :equal)}, negated: #{at(cmp, :negated)} }"
-    end
-
-    # Reads a key from a symbol-keyed (round-tripped) or string-keyed (`AstJson`) node.
-    def at(node, key)
-      node.key?(key) ? node[key] : node.fetch(key.to_s)
-    end
-  end
-end

data/rust/project/fielded.rb

@@ -1,141 +0,0 @@
-module RustProjection
-  module Projector
-    module_function
-
-    # One `Fielded` match arm per attribute, shared by value objects, args structs and
-    # (via emit_fielded_record) aggregate records.
-    # `extra_arms:` are raw `"key" => ...,` lines appended verbatim, e.g. an entity's lifecycle
-    # field. Arms render from the leaf shapes in rust/src/exemplar/fielded.rs with a fixed
-    # 12-space prefix, using plain `render` because the leaves are shared across outer shapes.
-    def emit_fielded_flat(struct_name, attributes, value_objects_by_name, extra_arms: [], entity_names: [])
-      arms = attributes.filter_map do |attr|
-        key   = rust_field(attr[:name])
-        ident = rust_ident_field(attr[:name])
-        scalar = effective_scalar_type(attr[:type])
-        if attr[:list] && attr[:optional]
-          Exemplar.render("fielded_arm_list_optional", '"tmpl_field"' => key.inspect, "tmpl_ident" => ident)
-        elsif attr[:list]
-          Exemplar.render("fielded_arm_list", '"tmpl_field"' => key.inspect, "tmpl_ident" => ident)
-        elsif attr[:optional] && scalar
-          Exemplar.render(
-            "fielded_arm_optional_scalar",
-            '"tmpl_field"' => key.inspect,
-            "tmpl_ident" => ident,
-            "tmpl_value_expr_placeholder(v)" => scalar_to_value(scalar, "v")
-          )
-        elsif attr[:optional]
-          nested = value_objects_by_name[attr[:type]]
-          next nil unless nested && fielded_capable_nested?(nested)
-
-          Exemplar.render("fielded_arm_optional_nested", '"tmpl_field"' => key.inspect, "tmpl_ident" => ident)
-        elsif scalar
-          Exemplar.render(
-            "fielded_arm_scalar",
-            '"tmpl_field"' => key.inspect,
-            "tmpl_value_expr_placeholder(&self.tmpl_ident)" => scalar_to_value(scalar, "self.#{ident}")
-          )
-        else
-          nested = value_objects_by_name[attr[:type]]
-          next nil unless nested && fielded_capable_nested?(nested)
-
-          Exemplar.render("fielded_arm_nested", '"tmpl_field"' => key.inspect, "tmpl_ident" => ident)
-        end
-      end
-      arms = arms.map { |a| "            #{a}" }
-      arms += extra_arms
-
-      # The trailing "\n" keeps the blank-line count callers expect; render's dedent rstrips.
-      "#{Exemplar.render(
-        'fielded_flat',
-        'TmplFlatType' => struct_name,
-        '"tmpl_arms_placeholder" => tmpl_arms_block(),' => arms.join("\n"),
-        # `entity_names`: a list of entities is enumerated the same way the record does.
-        '"tmpl_items_placeholder" => tmpl_items_block(),' => items_arms(attributes, value_objects_by_name, entity_names, optional: ->(attr) { attr[:optional] }).join("\n"),
-        "tmpl_as_scalar_placeholder()" => as_scalar_expr(attributes),
-        # Import only what the arms use, so a struct with no arms leaves no unused `use`.
-        'use crate::kernel::Field;' => (arms.any? { |arm| arm.include?('Field') } ? 'use crate::kernel::Field;' : ''),
-        'use crate::kernel::Value;' => (arms.any? { |arm| arm.include?('Value') } ? 'use crate::kernel::Value;' : '')
-      )}\n"
-    end
-
-    # `Fielded::items`: one arm per list attribute whose element is a scalar or a fielded-capable
-    # nested type or entity. `optional` says whether the list is `Option`-wrapped.
-    def items_arms(attributes, value_objects_by_name, entity_names, optional:)
-      attributes.filter_map do |attr|
-        next nil unless attr[:list]
-
-        key    = rust_field(attr[:name])
-        ident  = rust_ident_field(attr[:name])
-        scalar = effective_scalar_type(attr[:type])
-        nested = value_objects_by_name[attr[:type]]
-        fielded_element = scalar || (nested && fielded_capable_nested?(nested)) || entity_names.include?(attr[:type])
-        next nil unless fielded_element
-
-        shape = "fielded_items_arm_list_#{optional.call(attr) ? 'optional_' : ''}#{scalar ? 'scalar' : 'nested'}"
-        subs = { '"tmpl_field"' => key.inspect, "tmpl_ident" => ident }
-        subs["tmpl_value_expr_placeholder(v)"] = scalar_to_value(scalar, "v") if scalar
-        "            #{Exemplar.render(shape, subs)}"
-      end
-    end
-
-    # Record variant of emit_fielded_flat: non-list attributes are `Option`-wrapped, so `None`
-    # reads as `Value::Nil`. Adds lifecycle and corrects-flag arms.
-    def emit_fielded_record(aggregate, value_objects_by_name)
-      name = rust_ident(aggregate[:name])
-      arms = aggregate[:attributes].filter_map do |attr|
-        key   = rust_field(attr[:name])
-        ident = rust_ident_field(attr[:name])
-        scalar = effective_scalar_type(attr[:type])
-        if attr[:list] && list_attr_creation_optional?(aggregate, attr[:name], value_objects_by_name)
-          Exemplar.render("fielded_arm_list_optional", '"tmpl_field"' => key.inspect, "tmpl_ident" => ident)
-        elsif attr[:list]
-          Exemplar.render("fielded_arm_list", '"tmpl_field"' => key.inspect, "tmpl_ident" => ident)
-        elsif scalar
-          Exemplar.render(
-            "fielded_arm_optional_scalar",
-            '"tmpl_field"' => key.inspect,
-            "tmpl_ident" => ident,
-            "tmpl_value_expr_placeholder(v)" => scalar_to_value(scalar, "v")
-          )
-        else
-          nested = value_objects_by_name[attr[:type]]
-          next nil unless nested && fielded_capable_nested?(nested)
-
-          Exemplar.render("fielded_arm_optional_nested", '"tmpl_field"' => key.inspect, "tmpl_ident" => ident)
-        end
-      end
-      if aggregate[:lifecycle]
-        key   = rust_field(aggregate[:lifecycle][:field])
-        ident = rust_ident_field(aggregate[:lifecycle][:field])
-        arms << Exemplar.render("fielded_lifecycle_arm", '"tmpl_field"' => key.inspect, "tmpl_ident" => ident)
-      end
-      correctable_event_names(aggregate).each do |ev|
-        ident = corrects_flag_field(ev)
-        arms << Exemplar.render("fielded_corrects_flag_arm", '"tmpl_field"' => ident.inspect, "tmpl_ident" => ident)
-      end
-      arms = arms.map { |a| "            #{a}" }
-
-      # Trailing "\n": see emit_fielded_flat.
-      entity_names = (aggregate[:entities] || []).map { |e| e[:name] }
-      "#{Exemplar.render(
-        'fielded_record',
-        'TmplRecordType' => name,
-        '"tmpl_arms_placeholder" => tmpl_arms_block(),' => arms.join("\n"),
-        '"tmpl_items_placeholder" => tmpl_items_block(),' => items_arms(
-          aggregate[:attributes], value_objects_by_name, entity_names,
-          optional: ->(attr) { list_attr_creation_optional?(aggregate, attr[:name], value_objects_by_name) }
-        ).join("\n"),
-        "tmpl_as_scalar_placeholder()" => as_scalar_expr(aggregate[:attributes])
-      )}\n"
-    end
-
-    # `Resolver#unwrap_scalar`: a struct with exactly one scalar attribute reads as that
-    # attribute's value whatever its name; anything else answers `None`.
-    def as_scalar_expr(attributes)
-      sole = attributes.size == 1 && !attributes.first[:list] ? attributes.first : nil
-      return "None" unless sole && effective_scalar_type(sole[:type])
-
-      "match self.field(#{rust_field(sole[:name]).inspect}) { Some(crate::kernel::Field::Value(v)) => Some(v), _ => None }"
-    end
-  end
-end