expressir 2.3.1 → 2.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c855bf4d946e55fcd6e67cbe9e7116c4bae1e5fb3b1078b71661f45e2fa595d3
-  data.tar.gz: 6973d40c8ec148024102cbffcadfd5719dbf7d0ceba002caf33e55c0ad02acda
+  metadata.gz: bd7415865cfb8be37ccbd1dbeef665f6878230e396060cc6771c8c7df7d8fea3
+  data.tar.gz: b1fccc63fc2bfe3c6ab2a7772a6c634a85a45125917fd3b9fb15f366537a8bc0
 SHA512:
-  metadata.gz: 543ea137c1a7705e9aa899db477d7bf947ebe678d105197d1545355156a07f2d5dd66f9a9a7e812c64c9b4a446f05adede91ebbe51632c827607c429fd1d148d
-  data.tar.gz: 3f44737379fbf50a0990e42bd711ddfb23765f7648c12340617f38d7cab2a57a69647ef7763c8f9e1607861e778e64a25db29f0d257901d58df59bd9bbe1718f
+  metadata.gz: 5c9c971cdc4f3eabdcd05736f29da963c1eb947e190210b18ffb3712ea7359a93a803b3d28039fc1ec29ee0c53dd7420aba2f3be53b171829e1dcd5a91e420cb
+  data.tar.gz: dac877b21617de02ae79f622b5e58590e286d94f4c9d32702bbcbe157152249616598b6553128fcb9a9dc2bd80ae07d0d1abdd71f0ab3c6fdc08ce8172bd5211

data/lib/expressir/commands/changes_import_eengine.rb

@@ -115,26 +115,6 @@ module Expressir
           end
         end
 
-        def extract_description(compare_report)
-          parts = []
-
-          [compare_report.modifications, compare_report.additions,
-           compare_report.deletions].each do |section|
-            next unless section&.modified_objects
-
-            section.modified_objects.each do |obj|
-              next unless obj.description
-
-              description_text = normalize_description(obj.description)
-              next if description_text.strip.empty?
-
-              parts << convert_html_to_asciidoc(description_text.strip)
-            end
-          end
-
-          parts.empty? ? nil : parts.join("\n\n")
-        end
-
         def normalize_description(description)
           # Handle both String and Array (when XML has nested elements)
           case description

data/lib/expressir/express/builder.rb

@@ -340,14 +340,6 @@ module Expressir
           end
         end
 
-        def to_snake_case(name)
-          cached_snake_case(name)
-        end
-
-        def convert_keys_to_snake_case(obj)
-          fast_convert_keys(obj)
-        end
-
         def extract_source_info(data)
           return nil unless data
           return nil unless @source

data/lib/expressir/express/parser.rb

@@ -728,7 +728,6 @@ module Expressir
           @exp_file.schemas.each do |schema|
             schema.file = schema_file
             schema.file_basename = File.basename(schema_file, ".exp")
-            schema.formatted = schema.to_s(no_remarks: true)
           end
 
           unless skip_references
@@ -820,7 +819,6 @@ root_path: nil, use_native: nil)
         exp_file.schemas.each do |schema|
           schema.file = nil
           schema.file_basename = nil
-          schema.formatted = schema.to_s(no_remarks: true)
         end
 
         unless skip_references
@@ -855,7 +853,6 @@ include_source: nil)
         exp_file.schemas.each do |schema|
           schema.file = nil
           schema.file_basename = nil
-          schema.formatted = schema.to_s(no_remarks: true)
         end
 
         unless skip_references
@@ -903,7 +900,6 @@ include_source: nil)
         exp_file.schemas.each do |schema|
           schema.file = nil
           schema.file_basename = nil
-          schema.formatted = schema.to_s(no_remarks: true)
         end
 
         unless skip_references

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

@@ -19,9 +19,7 @@ module Expressir
         attribute :procedures, Procedure, collection: true
         attribute :_class, :string, default: -> { self.class.name }
         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
@@ -67,6 +65,10 @@ module Expressir
           Expressir::Express::Formatter.format(self)
         end
 
+        def formatted
+          @formatted ||= to_s(no_remarks: true)
+        end
+
         def source
           formatter = Class.new(Expressir::Express::Formatter) do
             include Expressir::Express::SchemaHeadFormatter

data/lib/expressir/model/model_element.rb

@@ -203,14 +203,6 @@ module Expressir
         self.untagged_remarks << remark_info
       end
 
-      # Get all remarks as RemarkInfo objects
-      # @return [Array<RemarkInfo>] Array of RemarkInfo objects
-      def remark_infos
-        return [] if untagged_remarks.nil?
-
-        untagged_remarks.grep(RemarkInfo)
-      end
-
       private
 
       # @return [nil]

data/lib/expressir/version.rb

@@ -1,3 +1,3 @@
 module Expressir
-  VERSION = "2.3.1".freeze
+  VERSION = "2.3.3".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.3
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-04-01 00:00:00.000000000 Z
+date: 2026-04-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -507,7 +507,6 @@ files:
 - lib/expressir/package/reader.rb
 - lib/expressir/schema_manifest.rb
 - lib/expressir/schema_manifest_entry.rb
-- lib/expressir/transformer.rb
 - lib/expressir/version.rb
 homepage: https://github.com/lutaml/expressir
 licenses:

data/lib/expressir/transformer.rb

@@ -1,7 +0,0 @@
-module Expressir
-  module Express
-    module Transformer
-      autoload :RemarkHandling, "#{__dir__}/express/transformer/remark_handling"
-    end
-  end
-end