expressir 2.3.6 → 2.3.7

data/lib/expressir/express/remark_attacher.rb

@@ -11,16 +11,39 @@ 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
@@ -376,7 +399,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 +413,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 +463,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 +537,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 +557,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 +684,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
@@ -872,7 +901,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 +920,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 +992,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 +1014,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
@@ -1089,23 +1120,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 +1149,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

data/lib/expressir/express/schema_head_formatter.rb

@@ -8,14 +8,12 @@ module Expressir
     module SchemaHeadFormatter
       # @!visibility private
       def self.included(mod)
-        if !mod.superclass.private_method_defined?(:format_declarations_schema) || !mod.superclass.private_method_defined?(:format_declarations_schema_head)
+        unless mod.superclass <= Expressir::Express::Formatter
           raise Error::FormatterMethodMissingError.new("SchemaHeadFormatter",
                                                        "format_declarations_schema/format_declarations_schema_head")
         end
       end
 
-      private
-
       def format_declarations_schema(node)
         format_declarations_schema_head(node)
       end

data/lib/expressir/model/concerns.rb

@@ -2,10 +2,16 @@
 
 module Expressir
   module Model
+    # Marker for types that have an id attribute
+    module HasId; end
+
     # Marker for types that can have remark_items children
     # These are types where RemarkItem children can be created
     module HasRemarkItems; end
 
+    # Marker for types that have a `remarks` string collection
+    module HasRemarks; end
+
     # Marker for scope containers (can contain declarations)
     # Includes schemas, functions, procedures, rules, entities, types, and files
     module ScopeContainer; end

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

@@ -4,6 +4,8 @@ module Expressir
       # Specified in ISO 10303-11:2004
       # - section 11 Interface specification
       class InterfaceItem < ModelElement
+        include HasId
+
         attribute :ref, ModelElement
         attribute :id, :string
         attribute :_class, :string, default: -> { self.class.name }

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

@@ -4,6 +4,9 @@ module Expressir
       # Specified in ISO 10303-11:2004
       # - section 11 Interface specification
       class InterfacedItem < ModelElement
+        include HasId
+        include HasRemarks
+
         attribute :id, :string
         attribute :remarks, :string, collection: true
         attribute :remark_items, RemarkItem, collection: true

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

@@ -3,6 +3,9 @@ module Expressir
     module Declarations
       # Implicit item with remarks
       class RemarkItem < ModelElement
+        include HasId
+        include HasRemarks
+
         attribute :id, :string
         attribute :remarks, :string, collection: true
         attribute :_class, :string, default: -> { self.class.name }

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

@@ -70,7 +70,7 @@ module Expressir
         end
 
         def full_source
-          Expressir::Express::Formatter.format(self)
+          @full_source ||= Expressir::Express::Formatter.format(self)
         end
 
         def formatted
@@ -78,11 +78,13 @@ module Expressir
         end
 
         def source
-          formatter = Class.new(Expressir::Express::Formatter) do
-            include Expressir::Express::SchemaHeadFormatter
-            include Expressir::Express::HyperlinkFormatter
+          @source ||= begin
+            formatter = Class.new(Expressir::Express::Formatter) do
+              include Expressir::Express::SchemaHeadFormatter
+              include Expressir::Express::HyperlinkFormatter
+            end
+            formatter.format(self)
           end
-          formatter.format(self)
         end
 
         private

data/lib/expressir/model/exp_file.rb

@@ -11,6 +11,7 @@ module Expressir
     # A Repository contains multiple ExpFile instances when parsing multiple files,
     # or a single ExpFile when parsing a single file.
     class ExpFile < ModelElement
+      include HasId
       include ScopeContainer
 
       attribute :path, :string

data/lib/expressir/model/identifier.rb

@@ -2,8 +2,10 @@ module Expressir
   module Model
     module Identifier
       def self.included(mod)
-        # Auto-include marker - all Identifier types can have remark_items
+        # Auto-include markers - all Identifier types have id and can have remark_items and remarks
+        mod.include(HasId)
         mod.include(HasRemarkItems)
+        mod.include(HasRemarks)
 
         mod.attribute :id, :string
         mod.attribute :remarks, :string, collection: true

data/lib/expressir/model/model_element.rb

@@ -120,7 +120,7 @@ module Expressir
         loop do
           # Skip adding the id if this is a RemarkItem that belongs to an InformalPropositionRule
           # and has the same id as its parent
-          if !(current_node.is_a? References::SimpleReference) && current_node.class.method_defined?(:id) &&
+          if !(current_node.is_a? References::SimpleReference) && current_node.is_a?(HasId) &&
               !(is_a?(Declarations::RemarkItem) &&
                 parent.is_a?(Declarations::InformalPropositionRule) &&
                 id == parent.id)
@@ -200,7 +200,7 @@ module Expressir
         self.untagged_remarks ||= []
         return unless remark_info.is_a?(RemarkInfo)
 
-        self.untagged_remarks << remark_info
+        untagged_remarks << remark_info
       end
 
       private
@@ -208,7 +208,7 @@ module Expressir
       # @return [nil]
       def attach_parent_to_children
         self.class.attributes.each_pair do |symbol, _lutaml_attr|
-          value = send(symbol)
+          value = public_send(symbol)
 
           case value
           when Array

data/lib/expressir/model/repository.rb

@@ -24,6 +24,14 @@ module Expressir
       # Index instances (lazy-loaded)
       attr_reader :entity_index, :type_index, :reference_index
 
+      # Restore deserialized indexes (used by Package::Reader)
+      def restore_indexes(entity_index: nil, type_index: nil,
+reference_index: nil)
+        @entity_index = entity_index if entity_index
+        @type_index = type_index if type_index
+        @reference_index = reference_index if reference_index
+      end
+
       # Internal schema storage for direct manipulation
       attr_reader :_schemas
 

data/lib/expressir/model/search_engine.rb

@@ -327,7 +327,7 @@ module Expressir
         # Guard against nil schemas array
         return [] unless schemas
 
-        schemas.flat_map { |s| s.send(method) || [] }
+        schemas.flat_map { |s| s.public_send(method) || [] }
       end
 
       # Collect all attributes from entities

data/lib/expressir/package/reader.rb

@@ -132,32 +132,17 @@ module Expressir
       # @param repository [Model::Repository] Repository instance
       # @return [void]
       def load_indexes(zip, repository)
-        # Load entity index
-        entity_index_entry = zip.find_entry("entity_index.marshal")
-        if entity_index_entry
-          repository.instance_variable_set(
-            :@entity_index,
-            Marshal.load(entity_index_entry.get_input_stream.read),
-          )
+        indexes = {}
+
+        %w[entity_index type_index reference_index].each do |name|
+          entry = zip.find_entry("#{name}.marshal")
+          if entry
+            indexes[name.to_sym] =
+              Marshal.load(entry.get_input_stream.read)
+          end
         end
 
-        # Load type index
-        type_index_entry = zip.find_entry("type_index.marshal")
-        if type_index_entry
-          repository.instance_variable_set(
-            :@type_index,
-            Marshal.load(type_index_entry.get_input_stream.read),
-          )
-        end
-
-        # Load reference index
-        reference_index_entry = zip.find_entry("reference_index.marshal")
-        if reference_index_entry
-          repository.instance_variable_set(
-            :@reference_index,
-            Marshal.load(reference_index_entry.get_input_stream.read),
-          )
-        end
+        repository.restore_indexes(**indexes) unless indexes.empty?
       end
     end
   end

data/lib/expressir/version.rb

@@ -1,3 +1,3 @@
 module Expressir
-  VERSION = "2.3.6".freeze
+  VERSION = "2.3.7".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: expressir
 version: !ruby/object:Gem::Version
-  version: 2.3.6
+  version: 2.3.7
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-05-14 00:00:00.000000000 Z
+date: 2026-06-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -233,6 +233,7 @@ files:
 - ".rspec"
 - ".rubocop.yml"
 - ".rubocop_todo.yml"
+- CHANGELOG.md
 - Gemfile
 - README.adoc
 - Rakefile
@@ -263,6 +264,7 @@ files:
 - docs/_guides/ler/loading-packages.adoc
 - docs/_guides/ler/package-formats.adoc
 - docs/_guides/ler/querying-packages.adoc
+- docs/_guides/ler/step-packages.adoc
 - docs/_guides/ler/validating-packages.adoc
 - docs/_guides/liquid/basic-templates.adoc
 - docs/_guides/liquid/documentation-generation.adoc