expressir 2.3.6 → 2.4.0

data/lib/expressir/express/remark_attacher.rb

@@ -11,21 +11,44 @@ module Expressir
     # 2. Proximity-based matching for simple tags
     # 3. NOT creating spurious schema-level items for ambiguous tags
     class RemarkAttacher
-      # Child collection attributes to walk when traversing model elements.
-      # These are the named collections on model elements (e.g., entity.attributes,
-      # schema.entities, function.parameters). Extracted to a constant to avoid
-      # duplication between calculate_children_end_line and collect_children.
-      CHILD_COLLECTION_ATTRIBUTES = %i[
-        schemas types entities functions procedures rules constants
-        attributes derived_attributes inverse_attributes
-        where_rules unique_rules informal_propositions
-        parameters variables statements items remark_items
-      ].freeze
+      # Type-driven registry: maps each model class to its collection attributes.
+      # Replaces runtime method probing (method_defined?) with explicit type declarations.
+      COLLECTION_REGISTRY = {
+        Model::Declarations::Schema => %i[
+          constants types entities subtype_constraints
+          functions rules procedures remark_items
+        ],
+        Model::Declarations::Entity => %i[
+          attributes derived_attributes inverse_attributes
+          unique_rules where_rules informal_propositions remark_items
+        ],
+        Model::Declarations::Function => %i[
+          parameters types entities subtype_constraints
+          functions procedures constants variables statements remark_items
+        ],
+        Model::Declarations::Procedure => %i[
+          parameters types entities subtype_constraints
+          functions procedures constants variables statements remark_items
+        ],
+        Model::Declarations::Rule => %i[
+          applies_to types entities subtype_constraints
+          functions procedures constants variables statements
+          where_rules informal_propositions remark_items
+        ],
+        Model::Declarations::Type => %i[
+          where_rules informal_propositions remark_items
+        ],
+        Model::ExpFile => %i[schemas],
+        Model::Statements::Compound => %i[statements],
+        Model::Statements::If => %i[statements],
+        Model::Statements::Alias => %i[statements],
+        Model::Statements::Repeat => %i[statements],
+      }.freeze
 
       def initialize(source)
         @source = source
         @attached_spans = Set.new
-        @line_cache = {}
+        @line_map = LineMap.new(source.b)
         @model = nil
         @source_lines = nil # cached @source.lines
         @scope_map = nil # cached scope at each line number
@@ -33,7 +56,7 @@ module Expressir
 
       def attach(model)
         @model = model
-        remarks = extract_all_remarks
+        remarks = RemarkScanner.new(@source).scan
 
         # Build nodes_with_positions ONCE for both tagged and untagged remark passes.
         # This avoids double tree walk (381K nodes × 2 = 762K visits) which was
@@ -48,103 +71,22 @@ module Expressir
         @source = nil
         @source_lines = nil
         @scope_map = nil
-        @line_cache = nil
+        @line_map = nil
 
         model
       end
 
       private
 
-      def extract_all_remarks
-        remarks = []
-        byte_position = 0
-
-        @source.each_line.with_index do |line, line_idx|
-          line_bytesize = line.bytesize
-          line_bytes = line.b # Get byte string for indexing
-          if (dash_byte_idx = line_bytes.index("--"))
-            remark_text = line.byteslice((dash_byte_idx + 2)..).strip
-
-            # Check for special patterns like --IP1: content (informal proposition)
-            if remark_text.match?(/^IP\d+:\s*(.*)$/)
-              tag = remark_text[/^(IP\d+):/, 1]
-              content = remark_text[/^IP\d+:\s*(.*)$/, 1]
-              remarks << {
-                position: byte_position + dash_byte_idx,
-                line: line_idx + 1,
-                text: content,
-                tag: tag,
-                format: "tail",
-              }
-            else
-              tag, content = parse_tagged_remark(remark_text)
-              remarks << {
-                position: byte_position + dash_byte_idx,
-                line: line_idx + 1,
-                text: content || remark_text,
-                tag: tag,
-                format: "tail",
-              }
-            end
-          end
-          byte_position += line_bytesize
-        end
-
-        extract_embedded_remarks(remarks)
-        # Sort by position to ensure remarks are processed in source order
-        remarks.sort_by! { |r| r[:position] }
-        remarks
-      end
-
-      def extract_embedded_remarks(remarks)
-        source_bytes = @source.b
-        start_pos = 0
-        while (start_idx = source_bytes.index("(*", start_pos))
-          end_idx = source_bytes.index("*)", start_idx + 2)
-          break unless end_idx
-
-          content = @source.byteslice((start_idx + 2)...end_idx)
-          line_num = get_line_number(start_idx)
-
-          tag, text = parse_tagged_embedded_remark(content)
-
-          remarks << {
-            position: start_idx,
-            line: line_num,
-            text: text,
-            tag: tag,
-            format: "embedded",
-          }
-
-          start_pos = end_idx + 2
-        end
-      end
-
-      def parse_tagged_remark(text)
-        if text.start_with?('"') && (end_quote = text.index('"', 1))
-          [text[1...end_quote], text[(end_quote + 1)..].strip]
-        else
-          [nil, text]
-        end
-      end
-
-      def parse_tagged_embedded_remark(content)
-        stripped = content.strip
-        if stripped.start_with?('"') && (end_quote = stripped.index('"', 1))
-          [stripped[1...end_quote], stripped[(end_quote + 1)..].strip]
-        else
-          [nil, stripped]
-        end
-      end
+      # Remark extraction lives in {RemarkScanner}; this class only attaches.
+      # Line-number lookup is delegated to {LineMap} for O(log n) queries.
 
       def source_lines
         @source_lines ||= @source.lines
       end
 
       def get_line_number(position)
-        return 1 if position.nil? || position.zero?
-
-        @line_cache[position] ||= @source.byteslice(0...position).count("\n") + 1
+        @line_map.line_number(position)
       end
 
       def attach_tagged_remarks(model, remarks, nodes_with_positions)
@@ -157,23 +99,23 @@ module Expressir
         # This is the key optimization that makes scope lookup O(1) per remark
         @scope_map ||= build_scope_map
 
-        tagged.sort_by { |r| r[:position] }.each do |remark|
-          next if @attached_spans.include?(remark[:position])
+        tagged.sort_by(&:position).each do |remark|
+          next if @attached_spans.include?(remark.position)
 
-          tag = remark[:tag]
+          tag = remark.tag
           target = nil
 
           # Find containing scope using pre-computed scope map (O(1))
           # Falls back to position-based lookup if scope map doesn't have the line
-          containing_scope = find_containing_scope_by_name(remark[:line])
-          containing_scope ||= find_containing_scope_position(remark[:line],
+          containing_scope = find_containing_scope_by_name(remark.line)
+          containing_scope ||= find_containing_scope_position(remark.line,
                                                               nodes_with_positions)
 
           # Check if this is an informal proposition tag (IP\d+)
           if tag.match?(/^IP\d+$/)
             scope = containing_scope
             if scope.nil?
-              scope = find_scope_by_source_text(remark[:line])
+              scope = find_scope_by_source_text(remark.line)
             end
             if scope && supports_informal_propositions?(scope)
               target = create_or_find_informal_proposition(scope, tag)
@@ -223,7 +165,7 @@ module Expressir
                 # Special handling for remarks inside WHERE clauses
                 if target.nil? && supports_where_rules?(containing_scope)
                   target = find_target_in_where_clause(containing_scope, tag,
-                                                       remark[:line])
+                                                       remark.line)
                 end
 
                 # Only fall back to schema prefix if NOT inside a function/rule/procedure
@@ -273,9 +215,8 @@ module Expressir
           end
 
           if target
-            add_remark(target, remark[:text], format: remark[:format],
-                                              tag: remark[:tag])
-            @attached_spans << remark[:position]
+            add_remark(target, remark.text, format: remark.format, tag: remark.tag)
+            @attached_spans << remark.position
           end
         end
       end
@@ -376,7 +317,7 @@ module Expressir
           return schema if schema.id == scope_name
 
           %i[functions procedures rules entities types].each do |decl_type|
-            collection = schema.send(decl_type)
+            collection = schema.public_send(decl_type)
             next unless collection.is_a?(Array)
 
             found = collection.find { |n| n.id == scope_name }
@@ -390,30 +331,22 @@ module Expressir
       def find_node_in_scope(scope, tag)
         return nil unless scope
 
-        # Search within the scope for a node with the given tag/id
-        # Check all collections that might contain nodes with ids
-        %i[constants types variables parameters statements
-           attributes derived_attributes inverse_attributes
-           where_rules unique_rules informal_propositions].each do |attr|
-          collection = safe_get_collection(scope, attr)
-          next unless collection
-
+        collections_on(scope).each do |collection|
           collection.each do |item|
+            next unless item.is_a?(Model::HasRemarks)
             return item if item.id == tag
-          rescue NoMethodError
-            next
           end
         end
 
         # Search inside types for enumeration items
-        types = safe_get_collection(scope, :types)
+        types = get_collection(scope, :types)
         types&.each do |type|
           result = find_enumeration_item_in_type(type, tag)
           return result if result
         end
 
         # Search inside statements for nested items (alias, repeat, query)
-        statements = safe_get_collection(scope, :statements)
+        statements = get_collection(scope, :statements)
         statements&.each do |stmt|
           result = find_node_in_statement(stmt, tag)
           return result if result
@@ -448,34 +381,51 @@ module Expressir
         nil
       end
 
+      # Expression and statement child attributes for QueryExpression search.
+      # Targeted traversal prevents over-matching on unrelated model attributes.
+      EXPRESSION_CHILDREN = {
+        Model::Expressions::BinaryExpression => %i[operand1 operand2],
+        Model::Expressions::UnaryExpression => %i[operand],
+        Model::Expressions::QueryExpression => %i[expression aggregate_source],
+        Model::Expressions::AggregateInitializerItem => %i[expression
+                                                           repetition],
+        Model::Expressions::Interval => %i[low item high],
+        Model::Expressions::FunctionCall => %i[parameters],
+        Model::Expressions::EntityConstructor => %i[parameters],
+        Model::Expressions::AggregateInitializer => %i[items],
+        Model::Statements::Assignment => %i[expression],
+        Model::Statements::If => %i[expression],
+        Model::Statements::Case => %i[expression],
+        Model::Statements::CaseAction => %i[expression],
+        Model::Statements::Repeat => %i[while_expression until_expression],
+      }.freeze
+
       def find_query_in_expression(node, tag, visited = Set.new)
         return nil unless node
+        return nil unless node.is_a?(Model::ModelElement)
         return nil if visited.include?(node.object_id)
 
         visited.add(node.object_id)
 
-        # Check if this node is a QueryExpression with matching id
         if node.is_a?(Model::Expressions::QueryExpression) && node.id == tag
           return node
         end
 
-        # Recursively search expression attributes
-        %i[expression operand left right condition aggregate
-           query_expression repeat_control].each do |attr|
-          child = safe_send(node, attr)
-          next unless child
-
-          result = find_query_in_expression(child, tag, visited)
-          return result if result
-        end
+        attrs = EXPRESSION_CHILDREN[node.class]
+        return nil unless attrs
 
-        # Search in arrays
-        %i[expressions operands parameters arguments].each do |attr|
-          children = safe_send(node, attr)
-          next unless children.is_a?(Array)
+        attrs.each do |attr|
+          value = node.public_send(attr)
+          case value
+          when Array
+            value.each do |val|
+              next unless val.is_a?(Model::ModelElement)
 
-          children.each do |child|
-            result = find_query_in_expression(child, tag, visited)
+              result = find_query_in_expression(val, tag, visited)
+              return result if result
+            end
+          when Model::ModelElement
+            result = find_query_in_expression(value, tag, visited)
             return result if result
           end
         end
@@ -505,7 +455,7 @@ module Expressir
         return nil unless collection_attr
 
         # First try to find in containing scope
-        collection = safe_get_collection(containing_scope, collection_attr)
+        collection = get_collection(containing_scope, collection_attr)
         if collection
           found = collection.find { |item| item.is_a?(Model::ModelElement) && item.id == id }
           return found if found
@@ -525,7 +475,7 @@ module Expressir
       def find_target_in_where_clause(scope, tag, remark_line)
         return nil unless supports_where_rules?(scope)
 
-        where_rules = safe_get_collection(scope, :where_rules)
+        where_rules = get_collection(scope, :where_rules)
         return nil unless where_rules&.any?
 
         # Search source text for WHERE clause containing this remark
@@ -652,24 +602,21 @@ module Expressir
         nil
       end
 
+      COLLECTION_ACCESSOR = {
+        Expressir::Model::Declarations::Entity => lambda(&:entities),
+        Expressir::Model::Declarations::Type => lambda(&:types),
+        Expressir::Model::Declarations::Rule => lambda(&:rules),
+      }.freeze
+
       def find_node_by_type_and_name(node_class, name)
         return nil unless @model && name
 
-        # Search through all schemas
+        accessor = COLLECTION_ACCESSOR[node_class]
+        return nil unless accessor
+
         @model.schemas.each do |schema|
-          collection = case node_class.name
-                       when "Expressir::Model::Declarations::Entity"
-                         schema.entities
-                       when "Expressir::Model::Declarations::Type"
-                         schema.types
-                       when "Expressir::Model::Declarations::Rule"
-                         schema.rules
-                       end
-
-          if collection
-            found = collection.find { |n| n.id == name }
-            return found if found
-          end
+          found = accessor.call(schema)&.find { |n| n.id == name }
+          return found if found
         end
 
         nil
@@ -800,28 +747,26 @@ module Expressir
       end
 
       def attach_untagged_remarks(remarks, nodes_with_positions)
-        untagged = remarks.reject { |r| r[:tag] }
+        untagged = remarks.reject(&:tag)
         return unless untagged.any?
 
         untagged.each do |remark|
-          next if @attached_spans.include?(remark[:position])
+          next if @attached_spans.include?(remark.position)
 
-          if end_scope_line?(remark[:line])
+          if end_scope_line?(remark.line)
             matched_node = find_node_for_end_scope_remark(remark,
                                                           nodes_with_positions)
             if matched_node
-              add_remark(matched_node, remark[:text], format: remark[:format],
-                                                      tag: nil)
-              @attached_spans << remark[:position]
+              add_remark(matched_node, remark.text, format: remark.format, tag: nil)
+              @attached_spans << remark.position
               next
             end
           end
 
           matched_node = find_nearest_node(remark, nodes_with_positions)
           if matched_node
-            add_remark(matched_node, remark[:text], format: remark[:format],
-                                                    tag: nil)
-            @attached_spans << remark[:position]
+            add_remark(matched_node, remark.text, format: remark.format, tag: nil)
+            @attached_spans << remark.position
           end
         end
       end
@@ -839,7 +784,7 @@ module Expressir
       end
 
       def find_node_for_end_scope_remark(remark, nodes)
-        line_content = get_line_content(remark[:line])
+        line_content = get_line_content(remark.line)
 
         node_type = case line_content
                     when /END_SCHEMA/i then Model::Declarations::Schema
@@ -854,8 +799,8 @@ module Expressir
 
         matching_nodes = nodes.select do |n|
           n[:node].is_a?(node_type) &&
-            (n[:end_line] == remark[:line] ||
-             (n[:end_line] && n[:end_line] <= remark[:line] && n[:end_line] >= remark[:line] - 2))
+            (n[:end_line] == remark.line ||
+             (n[:end_line] && n[:end_line] <= remark.line && n[:end_line] >= remark.line - 2))
         end
 
         matching_nodes.first&.dig(:node) || find_node_by_type(nodes, node_type)
@@ -872,7 +817,7 @@ module Expressir
         # Only add remarks to nodes that support them
         if supports_remarks?(node)
           # Always add to remarks attribute (for types that have it)
-          if node.respond_to?(:remarks) && node.respond_to?(:remarks=)
+          if node_has_remarks?(node)
             node.remarks ||= []
             node.remarks << text
           end
@@ -891,6 +836,10 @@ module Expressir
         obj.is_a?(Model::ModelElement)
       end
 
+      def node_has_remarks?(obj)
+        obj.is_a?(Model::HasRemarks)
+      end
+
       # Types that include HasRemarkItems can have remark_items
       def supports_remark_items?(obj)
         obj.is_a?(Model::HasRemarkItems)
@@ -959,22 +908,20 @@ module Expressir
       def calculate_children_end_line(node)
         children_end_lines = []
 
-        # Check standard children attribute
-        children = safe_get_collection(node, :children)
-        children&.each do |child|
-          if child.is_a?(Model::ModelElement) && child.source_offset && child.source
-            child_end_line = get_line_number(child.source_offset + child.source.length)
-            children_end_lines << child_end_line
+        # Check computed children (Schema, ExpFile have a children method)
+        if node.is_a?(Model::Declarations::Schema)
+          Array(node.children).each do |child|
+            if child.is_a?(Model::ModelElement) && child.source_offset && child.source
+              children_end_lines << get_line_number(child.source_offset + child.source.length)
+            end
           end
         end
 
-        # Check specific child collections
-        CHILD_COLLECTION_ATTRIBUTES.each do |attr|
-          collection = safe_get_collection(node, attr)
-          collection&.each do |child|
+        # Visit declared collections from type registry
+        collections_on(node).each do |collection|
+          collection.each do |child|
             if child.is_a?(Model::ModelElement) && child.source_offset && child.source
-              child_end_line = get_line_number(child.source_offset + child.source.length)
-              children_end_lines << child_end_line
+              children_end_lines << get_line_number(child.source_offset + child.source.length)
             end
           end
         end
@@ -983,14 +930,14 @@ module Expressir
       end
 
       def collect_children(node, result, visited)
-        children = safe_get_collection(node, :children)
-        children&.each do |child|
-          collect_nodes_with_positions(child, result, visited)
+        if node.is_a?(Model::Declarations::Schema)
+          Array(node.children).each do |child|
+            collect_nodes_with_positions(child, result, visited)
+          end
         end
 
-        CHILD_COLLECTION_ATTRIBUTES.each do |attr|
-          collection = safe_get_collection(node, attr)
-          collection&.each do |item|
+        collections_on(node).each do |collection|
+          collection.each do |item|
             collect_nodes_with_positions(item, result, visited)
           end
         end
@@ -1007,7 +954,7 @@ module Expressir
       end
 
       def find_nearest_node(remark, nodes)
-        remark_line = remark[:line]
+        remark_line = remark.line
 
         # For tail remarks, prefer nodes that START on the same line
         # This handles cases like: "attr : STRING; -- tail remark"
@@ -1089,23 +1036,23 @@ module Expressir
         obj.is_a?(Model::HasWhereRules)
       end
 
-      # Safe accessor methods that return nil instead of NoMethodError
+      # Type-driven collection access — returns all collections for a node's type.
+      def collections_on(node)
+        attrs = COLLECTION_REGISTRY[node.class]
+        return [] unless attrs
 
-      def safe_send(obj, method)
-        return nil unless obj
-
-        obj.send(method)
-      rescue NoMethodError
-        nil
+        attrs.filter_map do |attr|
+          col = node.public_send(attr)
+          col if col.is_a?(Array)
+        end
       end
 
-      def safe_get_collection(obj, attr)
-        return nil unless obj
+      # Type-driven single collection access — returns one named collection if the type has it.
+      def get_collection(node, attr_name)
+        return nil unless COLLECTION_REGISTRY[node.class]&.include?(attr_name)
 
-        collection = obj.send(attr)
+        collection = node.public_send(attr_name)
         collection if collection.is_a?(Array)
-      rescue NoMethodError
-        nil
       end
 
       def safe_find(model, path)
@@ -1118,10 +1065,9 @@ module Expressir
 
       def safe_reset_children_by_id(obj)
         return unless obj
+        return unless obj.is_a?(Model::ScopeContainer)
 
         obj.reset_children_by_id
-      rescue NoMethodError
-        nil
       end
     end
   end