expressir 2.3.1 → 2.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c855bf4d946e55fcd6e67cbe9e7116c4bae1e5fb3b1078b71661f45e2fa595d3
-  data.tar.gz: 6973d40c8ec148024102cbffcadfd5719dbf7d0ceba002caf33e55c0ad02acda
+  metadata.gz: e0cd9487796289d666f64e0d96628efb1e54a7d7b5fe02f051edd7ff886cbd38
+  data.tar.gz: 1f4dc35360f53c93c987ca8bab26cbbcf677c421bd05e050451315735dd78039
 SHA512:
-  metadata.gz: 543ea137c1a7705e9aa899db477d7bf947ebe678d105197d1545355156a07f2d5dd66f9a9a7e812c64c9b4a446f05adede91ebbe51632c827607c429fd1d148d
-  data.tar.gz: 3f44737379fbf50a0990e42bd711ddfb23765f7648c12340617f38d7cab2a57a69647ef7763c8f9e1607861e778e64a25db29f0d257901d58df59bd9bbe1718f
+  metadata.gz: bf984c0fa68ad04c83d05b3cc4268d2e67baa0a6789545378e7599533cfa8e8332673b303793d485b46a12212c1b2e84087ba4decd4c54dc9fe671c52d13faf4
+  data.tar.gz: a2f68e1091a39b336abe009e2cc5b2f576d0a72deb58a79f831c52741345422f4651d22edf133d5c5e1d8d4d83dd6f63fed555d13e62e6bd68a79a84666cf1b0

data/lib/expressir/express/remark_attacher.rb

@@ -11,6 +11,17 @@ 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
+
       def initialize(source)
         @source = source
         @attached_spans = Set.new
@@ -23,8 +34,14 @@ module Expressir
       def attach(model)
         @model = model
         remarks = extract_all_remarks
-        attach_tagged_remarks(model, remarks)
-        attach_untagged_remarks(model, remarks)
+
+        # Build nodes_with_positions ONCE for both tagged and untagged remark passes.
+        # This avoids double tree walk (381K nodes × 2 = 762K visits) which was
+        # the largest memory overhead in remark attachment (~430MB for large files).
+        nodes_with_positions = build_sorted_nodes_with_positions(model)
+
+        attach_tagged_remarks(model, remarks, nodes_with_positions)
+        attach_untagged_remarks(remarks, nodes_with_positions)
 
         # Free expensive data structures after attachment is complete.
         # These are only needed during the attach process.
@@ -32,7 +49,6 @@ module Expressir
         @source_lines = nil
         @scope_map = nil
         @line_cache = nil
-        @remarks_cache = nil
 
         model
       end
@@ -131,9 +147,7 @@ module Expressir
         @line_cache[position] ||= @source.byteslice(0...position).count("\n") + 1
       end
 
-      alias get_line_number_from_offset get_line_number
-
-      def attach_tagged_remarks(model, remarks)
+      def attach_tagged_remarks(model, remarks, nodes_with_positions)
         tagged = remarks.select { |r| r[:tag] }
         return if tagged.empty?
 
@@ -143,12 +157,6 @@ module Expressir
         # This is the key optimization that makes scope lookup O(1) per remark
         @scope_map ||= build_scope_map
 
-        # Collect nodes with positions for position-based fallback
-        nodes_with_positions = []
-        collect_nodes_with_positions(model, nodes_with_positions)
-        # Use stable sort to ensure deterministic ordering across Ruby versions
-        nodes_with_positions.sort_by!.with_index { |n, i| [n[:position] || Float::INFINITY, i] }
-
         tagged.sort_by { |r| r[:position] }.each do |remark|
           next if @attached_spans.include?(remark[:position])
 
@@ -566,102 +574,6 @@ module Expressir
         find_containing_scope_position(remark_line, nodes_with_positions)
       end
 
-      def find_scope_by_text_search(remark_line)
-        lines = source_lines
-        return nil if remark_line < 1 || remark_line > lines.length
-
-        # Track nested scopes by searching backwards from remark_line
-        scope_stack = []
-
-        lines.each_with_index do |line, idx|
-          line_num = idx + 1
-          break if line_num > remark_line
-
-          # Check for START keywords first
-          if line =~ /^\s*SCHEMA\s+(\w+)/i
-            scope_stack << { type: :schema, name: $1, line: line_num }
-          end
-
-          if line =~ /^\s*FUNCTION\s+(\w+)/i
-            scope_stack << { type: :function, name: $1, line: line_num }
-          end
-
-          if line =~ /^\s*PROCEDURE\s+(\w+)/i
-            scope_stack << { type: :procedure, name: $1, line: line_num }
-          end
-
-          if line =~ /^\s*RULE\s+(\w+)/i
-            scope_stack << { type: :rule, name: $1, line: line_num }
-          end
-
-          if line =~ /^\s*ENTITY\s+(\w+)/i
-            scope_stack << { type: :entity, name: $1, line: line_num }
-          end
-
-          if line =~ /^\s*TYPE\s+(\w+)/i
-            scope_stack << { type: :type, name: $1, line: line_num }
-          end
-
-          # Then check for END keywords (to handle inline closures on same line)
-          if (line =~ /END_TYPE/i) && (scope_stack.last&.dig(:type) == :type)
-            scope_stack.pop
-          end
-          if (line =~ /END_FUNCTION/i) && (scope_stack.last&.dig(:type) == :function)
-            scope_stack.pop
-          end
-          if (line =~ /END_PROCEDURE/i) && (scope_stack.last&.dig(:type) == :procedure)
-            scope_stack.pop
-          end
-          if (line =~ /END_RULE/i) && (scope_stack.last&.dig(:type) == :rule)
-            scope_stack.pop
-          end
-          if (line =~ /END_ENTITY/i) && (scope_stack.last&.dig(:type) == :entity)
-            scope_stack.pop
-          end
-          if (line =~ /END_SCHEMA/i) && (scope_stack.last&.dig(:type) == :schema)
-            scope_stack.pop
-          end
-        end
-
-        # Find the innermost scope and get the corresponding model node
-        return nil if scope_stack.empty?
-
-        innermost = scope_stack.last
-        find_scope_node(innermost[:type], innermost[:name])
-      end
-
-      def find_scope_node(type, name)
-        return nil unless @model && name
-
-        @model.schemas.each do |schema|
-          # Check schema itself
-          if type == :schema && schema.id == name
-            return schema
-          end
-
-          # Check schema-level declarations
-          case type
-          when :function
-            found = schema.functions&.find { |f| f.id == name }
-            return found if found
-          when :procedure
-            found = schema.procedures&.find { |p| p.id == name }
-            return found if found
-          when :rule
-            found = schema.rules&.find { |r| r.id == name }
-            return found if found
-          when :entity
-            found = schema.entities&.find { |e| e.id == name }
-            return found if found
-          when :type
-            found = schema.types&.find { |t| t.id == name }
-            return found if found
-          end
-        end
-
-        nil
-      end
-
       def build_scope_path(node)
         return nil unless node
 
@@ -682,36 +594,6 @@ module Expressir
         parts.empty? ? nil : parts.join(".")
       end
 
-      def find_containing_scope_for_ip(remark_line, nodes_with_positions)
-        # First try scope map (O(1))
-        scope = find_containing_scope_by_name(remark_line)
-        if scope && supports_informal_propositions?(scope)
-          return scope
-        end
-
-        # Fallback to position-based detection
-        containing_nodes = nodes_with_positions.select do |n|
-          n[:line] && n[:end_line] && remark_line >= n[:line] && remark_line <= n[:end_line] &&
-            !repository?(n[:node]) && !cache?(n[:node])
-        end
-
-        # Find the innermost node that supports informal propositions
-        if containing_nodes.any?
-          containing_nodes.reverse_each do |n|
-            node = n[:node]
-            if supports_informal_propositions?(node)
-              return node
-            end
-
-            # Fallback to schema
-            return node if node.is_a?(Model::Declarations::Schema)
-          end
-        end
-
-        # Fallback: search for containing entity/type/rule by source text
-        find_scope_by_source_text(remark_line)
-      end
-
       def find_scope_by_source_text(remark_line)
         # Search backwards from remark_line for containing scope
         lines = source_lines
@@ -917,15 +799,10 @@ module Expressir
         item
       end
 
-      def attach_untagged_remarks(model, remarks)
+      def attach_untagged_remarks(remarks, nodes_with_positions)
         untagged = remarks.reject { |r| r[:tag] }
         return unless untagged.any?
 
-        nodes_with_positions = []
-        collect_nodes_with_positions(model, nodes_with_positions)
-        # Use stable sort to preserve original order for equal keys
-        nodes_with_positions.sort_by!.with_index { |n, i| [n[:position] || Float::INFINITY, i] }
-
         untagged.each do |remark|
           next if @attached_spans.include?(remark[:position])
 
@@ -1092,10 +969,7 @@ module Expressir
         end
 
         # Check specific child collections
-        %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].each do |attr|
+        CHILD_COLLECTION_ATTRIBUTES.each do |attr|
           collection = safe_get_collection(node, attr)
           collection&.each do |child|
             if child.is_a?(Model::ModelElement) && child.source_offset && child.source
@@ -1114,10 +988,7 @@ module Expressir
           collect_nodes_with_positions(child, result, visited)
         end
 
-        %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].each do |attr|
+        CHILD_COLLECTION_ATTRIBUTES.each do |attr|
           collection = safe_get_collection(node, attr)
           collection&.each do |item|
             collect_nodes_with_positions(item, result, visited)
@@ -1125,6 +996,16 @@ module Expressir
         end
       end
 
+      # Build sorted nodes_with_positions ONCE for both tagged and untagged remark passes.
+      # This merges the two separate tree walks into one, cutting node visits in half.
+      def build_sorted_nodes_with_positions(model)
+        nodes_with_positions = []
+        collect_nodes_with_positions(model, nodes_with_positions)
+        # Stable sort: nil positions last, ties broken by insertion order
+        nodes_with_positions.sort_by!.with_index { |n, i| [n[:position] || Float::INFINITY, i] }
+        nodes_with_positions
+      end
+
       def find_nearest_node(remark, nodes)
         remark_line = remark[:line]
 

data/lib/expressir/model/declarations/schema.rb

@@ -21,7 +21,6 @@ module Expressir
         attribute :selected, :boolean, default: false
         attribute :formatted, :string
         attribute :file_basename, :string
-        attribute :full_source, :string
 
         key_value do
           map "_class", to: :_class, render_default: true

data/lib/expressir/version.rb

@@ -1,3 +1,3 @@
 module Expressir
-  VERSION = "2.3.1".freeze
+  VERSION = "2.3.2".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: expressir
 version: !ruby/object:Gem::Version
-  version: 2.3.1
+  version: 2.3.2
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-04-01 00:00:00.000000000 Z
+date: 2026-04-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64