expressir 2.2.1 → 2.3.0

data/lib/expressir/model/expressions/interval.rb

@@ -12,7 +12,7 @@ module Expressir
         attribute :item, ModelElement
         attribute :operator2, :string, values: %w[LESS_THAN LESS_THAN_OR_EQUAL]
         attribute :high, ModelElement
-        attribute :_class, :string, default: -> { send(:name) }
+        attribute :_class, :string, default: -> { self.class.name }
 
         key_value do
           map "_class", to: :_class, render_default: true

data/lib/expressir/model/expressions/query_expression.rb

@@ -8,7 +8,7 @@ module Expressir
 
         attribute :aggregate_source, ModelElement
         attribute :expression, ModelElement
-        attribute :_class, :string, default: -> { send(:name) }
+        attribute :_class, :string, default: -> { self.class.name }
 
         key_value do
           map "_class", to: :_class, render_default: true

data/lib/expressir/model/expressions/unary_expression.rb

@@ -11,7 +11,7 @@ module Expressir
 
         attribute :operator, :string, values: %w[MINUS NOT PLUS]
         attribute :operand, ModelElement
-        attribute :_class, :string, default: -> { send(:name) }
+        attribute :_class, :string, default: -> { self.class.name }
 
         key_value do
           map "_class", to: :_class, render_default: true

data/lib/expressir/model/expressions.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Model
+    module Expressions
+      autoload :AggregateInitializer,
+               "#{__dir__}/expressions/aggregate_initializer"
+      autoload :AggregateInitializerItem,
+               "#{__dir__}/expressions/aggregate_initializer_item"
+      autoload :BinaryExpression, "#{__dir__}/expressions/binary_expression"
+      autoload :EntityConstructor, "#{__dir__}/expressions/entity_constructor"
+      autoload :FunctionCall, "#{__dir__}/expressions/function_call"
+      autoload :Interval, "#{__dir__}/expressions/interval"
+      autoload :QueryExpression, "#{__dir__}/expressions/query_expression"
+      autoload :UnaryExpression, "#{__dir__}/expressions/unary_expression"
+    end
+  end
+end

data/lib/expressir/model/identifier.rb

@@ -2,11 +2,15 @@ module Expressir
   module Model
     module Identifier
       def self.included(mod)
+        # Auto-include marker - all Identifier types can have remark_items
+        mod.include(HasRemarkItems)
+
         mod.attribute :id, :string
         mod.attribute :remarks, :string, collection: true
         mod.attribute :remark_items,
                       ::Expressir::Model::Declarations::RemarkItem, collection: true
-        mod.attribute :untagged_remarks, ::Expressir::Model::RemarkInfo, collection: true
+        mod.attribute :untagged_remarks, ::Expressir::Model::RemarkInfo,
+                      collection: true
 
         mod.key_value do
           map "id", to: :id

data/lib/expressir/model/indexes.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Model
+    module Indexes
+      autoload :EntityIndex, "#{__dir__}/indexes/entity_index"
+      autoload :TypeIndex, "#{__dir__}/indexes/type_index"
+      autoload :ReferenceIndex, "#{__dir__}/indexes/reference_index"
+    end
+  end
+end

data/lib/expressir/model/literals/binary.rb

@@ -5,7 +5,7 @@ module Expressir
       # - section 7.5.1 Binary literal
       class Binary < ModelElement
         attribute :value, :string
-        attribute :_class, :string, default: -> { send(:name) }
+        attribute :_class, :string, default: -> { self.class.name }
 
         key_value do
           map "_class", to: :_class, render_default: true

data/lib/expressir/model/literals/integer.rb

@@ -5,7 +5,7 @@ module Expressir
       # - section 7.5.2 Integer literal
       class Integer < ModelElement
         attribute :value, :string
-        attribute :_class, :string, default: -> { send(:name) }
+        attribute :_class, :string, default: -> { self.class.name }
 
         key_value do
           map "_class", to: :_class, render_default: true

data/lib/expressir/model/literals/logical.rb

@@ -9,7 +9,7 @@ module Expressir
         UNKNOWN = "UNKNOWN".freeze
 
         attribute :value, :string, values: %w[TRUE FALSE UNKNOWN]
-        attribute :_class, :string, default: -> { send(:name) }
+        attribute :_class, :string, default: -> { self.class.name }
 
         key_value do
           map "_class", to: :_class, render_default: true

data/lib/expressir/model/literals/real.rb

@@ -5,7 +5,7 @@ module Expressir
       # - section 7.5.3 Real literal
       class Real < ModelElement
         attribute :value, :string
-        attribute :_class, :string, default: -> { send(:name) }
+        attribute :_class, :string, default: -> { self.class.name }
 
         key_value do
           map "_class", to: :_class, render_default: true

data/lib/expressir/model/literals/string.rb

@@ -6,7 +6,7 @@ module Expressir
       class String < ModelElement
         attribute :value, :string
         attribute :encoded, :boolean
-        attribute :_class, :string, default: -> { send(:name) }
+        attribute :_class, :string, default: -> { self.class.name }
 
         key_value do
           map "_class", to: :_class, render_default: true

data/lib/expressir/model/literals.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Model
+    module Literals
+      autoload :Binary, "#{__dir__}/literals/binary"
+      autoload :Integer, "#{__dir__}/literals/integer"
+      autoload :Logical, "#{__dir__}/literals/logical"
+      autoload :Real, "#{__dir__}/literals/real"
+      autoload :String, "#{__dir__}/literals/string"
+    end
+  end
+end

data/lib/expressir/model/model_element.rb

@@ -10,7 +10,7 @@ module Expressir
       # attribute :parent, ModelElement
       attr_accessor :parent
 
-      attribute :_class, :string, default: -> { send(:name) },
+      attribute :_class, :string, default: -> { self.class.name },
                                   polymorphic_class: true
       attribute :source, :string
       attribute :source_offset, :integer
@@ -18,6 +18,7 @@ module Expressir
 
       POLYMORPHIC_CLASS_MAP = {
         "Expressir::Model::Cache" => "Expressir::Model::Cache",
+        "Expressir::Model::ExpFile" => "Expressir::Model::ExpFile",
         "Expressir::Model::Repository" => "Expressir::Model::Repository",
         "Expressir::Model::RemarkInfo" => "Expressir::Model::RemarkInfo",
         "Expressir::Model::DataTypes::Aggregate" => "Expressir::Model::DataTypes::Aggregate",
@@ -194,29 +195,20 @@ module Expressir
       end
 
       # Add a remark to this element
-      # Supports both RemarkInfo objects and legacy strings
-      # @param remark_or_info [RemarkInfo, String] Remark to add
-      def add_remark(remark_or_info)
+      # @param remark_info [RemarkInfo] Remark to add
+      def add_remark(remark_info)
         self.untagged_remarks ||= []
+        return unless remark_info.is_a?(RemarkInfo)
 
-        if remark_or_info.is_a?(RemarkInfo)
-          self.untagged_remarks << remark_or_info
-        elsif remark_or_info.is_a?(String)
-          # Backward compatibility: assume embedded format for strings
-          self.untagged_remarks << RemarkInfo.new(text: remark_or_info,
-                                                  format: "embedded")
-        end
+        self.untagged_remarks << remark_info
       end
 
       # Get all remarks as RemarkInfo objects
-      # Converts legacy string remarks to RemarkInfo for consistency
       # @return [Array<RemarkInfo>] Array of RemarkInfo objects
       def remark_infos
         return [] if untagged_remarks.nil?
 
-        (untagged_remarks || []).map do |r|
-          r.is_a?(RemarkInfo) ? r : RemarkInfo.new(text: r, format: "embedded")
-        end
+        untagged_remarks.select { |r| r.is_a?(RemarkInfo) }
       end
 
       private

data/lib/expressir/model/references/attribute_reference.rb

@@ -6,7 +6,7 @@ module Expressir
       class AttributeReference < ModelElement
         attribute :ref, ModelElement
         attribute :attribute, ModelElement
-        attribute :_class, :string, default: -> { send(:name) }
+        attribute :_class, :string, default: -> { self.class.name }
 
         key_value do
           map "_class", to: :_class, render_default: true

data/lib/expressir/model/references/group_reference.rb

@@ -6,7 +6,7 @@ module Expressir
       class GroupReference < ModelElement
         attribute :ref, ModelElement
         attribute :entity, ModelElement
-        attribute :_class, :string, default: -> { send(:name) }
+        attribute :_class, :string, default: -> { self.class.name }
 
         key_value do
           map "_class", to: :_class, render_default: true

data/lib/expressir/model/references/index_reference.rb

@@ -9,7 +9,7 @@ module Expressir
         attribute :ref, ModelElement
         attribute :index1, ModelElement
         attribute :index2, ModelElement
-        attribute :_class, :string, default: -> { send(:name) }
+        attribute :_class, :string, default: -> { self.class.name }
 
         key_value do
           map "_class", to: :_class, render_default: true

data/lib/expressir/model/references/simple_reference.rb

@@ -7,7 +7,7 @@ module Expressir
         attribute :id, :string
         attribute :ref, ModelElement
         attribute :base_path, :string
-        attribute :_class, :string, default: -> { send(:name) }
+        attribute :_class, :string, default: -> { self.class.name }
 
         key_value do
           map "_class", to: :_class, render_default: true

data/lib/expressir/model/references.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Model
+    module References
+      autoload :AttributeReference, "#{__dir__}/references/attribute_reference"
+      autoload :GroupReference, "#{__dir__}/references/group_reference"
+      autoload :IndexReference, "#{__dir__}/references/index_reference"
+      autoload :SimpleReference, "#{__dir__}/references/simple_reference"
+    end
+  end
+end

data/lib/expressir/model/remark_info.rb

@@ -26,12 +26,6 @@ module Expressir
         !tag.nil? && !tag.empty?
       end
 
-      # For backward compatibility with string-based remarks
-      # @return [String] The remark text
-      def to_s
-        text.to_s
-      end
-
       # YAML serialization
       yaml do
         map "text", to: :text
@@ -41,7 +35,7 @@ module Expressir
 
       # XML serialization
       xml do
-        root "remark_info"
+        element "remark_info"
         map_element "text", to: :text
         map_element "format", to: :format
         map_element "tag", to: :tag

data/lib/expressir/model/repository.rb

@@ -1,17 +1,22 @@
 # frozen_string_literal: true
 
-require_relative "../schema_manifest"
-require_relative "../schema_manifest_entry"
-
 module Expressir
   module Model
     # Multi-schema global scope with enhanced repository features
     # Focuses on schema management and delegates indexing/validation to specialized classes
+    #
+    # A Repository contains multiple ExpFile instances (one per parsed .exp file).
+    #
+    # Structure:
+    #   Repository
+    #   └── files: [ExpFile, ...]
+    #       └── ExpFile (path: "a.exp")
+    #           ├── untagged_remarks: [...]  # file-level preamble
+    #           └── schemas: [SchemaA]
     class Repository < ModelElement
-      attribute :schemas, Expressir::Model::Declarations::Schema,
-                collection: true,
-                initialize_empty: true
-      attribute :_class, :string, default: -> { send(:name) }
+      # Internal storage for schemas (used for direct manipulation)
+      attribute :files, ExpFile, collection: true, initialize_empty: true
+      attribute :_class, :string, default: -> { self.class.name }
 
       # Base directory for schema files
       attr_accessor :base_dir
@@ -19,20 +24,49 @@ module Expressir
       # Index instances (lazy-loaded)
       attr_reader :entity_index, :type_index, :reference_index
 
+      # Internal schema storage for direct manipulation
+      attr_reader :_schemas
+
       key_value do
         map "_class", to: :_class, render_default: true
-        map "schemas", to: :schemas
+        map "files", to: :files
       end
 
-      def initialize(*args, base_dir: nil, **kwargs)
+      def initialize(*args, base_dir: nil, schemas: nil, **kwargs)
         super(*args, **kwargs)
         @base_dir = base_dir
         @entity_index = nil
         @type_index = nil
         @reference_index = nil
+        @_schemas = []
+
+        # Support direct schemas initialization
+        if schemas
+          schemas.each { |schema| @_schemas << schema }
+        end
+      end
+
+      # Get all schemas (from both files and direct storage)
+      # @return [Array<Declarations::Schema>]
+      def schemas
+        file_schemas = files&.flat_map(&:schemas)&.compact || []
+        file_schemas + @_schemas
       end
 
-      # @return [Array<Declaration>]
+      # Alias for schemas
+      # @return [Array<Declarations::Schema>]
+      def all_schemas
+        schemas
+      end
+
+      # Add a schema to the repository
+      # @param schema [Declarations::Schema] Schema to add
+      def add_schema(schema)
+        return unless schema
+        @_schemas << schema
+      end
+
+      # @return [Array<Declarations::Schema>]
       def children
         schemas
       end
@@ -40,9 +74,10 @@ module Expressir
       # Build indexes for entities, types, and references
       # @return [void]
       def build_indexes
-        @entity_index = Indexes::EntityIndex.new(schemas)
-        @type_index = Indexes::TypeIndex.new(schemas)
-        @reference_index = Indexes::ReferenceIndex.new(schemas)
+        target_schemas = all_schemas
+        @entity_index = Indexes::EntityIndex.new(target_schemas)
+        @type_index = Indexes::TypeIndex.new(target_schemas)
+        @reference_index = Indexes::ReferenceIndex.new(target_schemas)
       end
 
       # Find entity by qualified name
@@ -104,7 +139,7 @@ module Expressir
       # @return [Hash] Validation results with :valid?, :errors, :warnings
       def validate(strict: false)
         ensure_indexes_built
-        validator = RepositoryValidator.new(schemas, @reference_index)
+        validator = RepositoryValidator.new(all_schemas, @reference_index)
         validator.validate(strict: strict)
       end
 
@@ -115,7 +150,7 @@ module Expressir
         ensure_indexes_built
 
         stats = {
-          total_schemas: schemas.size,
+          total_schemas: all_schemas.size,
           total_entities: count_entities,
           total_types: count_types,
           total_functions: count_functions,
@@ -141,15 +176,16 @@ module Expressir
       # Group schemas by category based on their contents
       # @return [Hash] Hash with category keys and schema arrays
       def schemas_by_category
+        target_schemas = all_schemas
         {
-          with_entities: schemas.select { |s| s.entities&.any? },
-          with_types: schemas.select { |s| s.types&.any? },
-          with_functions: schemas.select { |s| s.functions&.any? },
-          with_rules: schemas.select { |s| s.rules&.any? },
-          interface_only: schemas.select do |s|
+          with_entities: target_schemas.select { |s| s.entities&.any? },
+          with_types: target_schemas.select { |s| s.types&.any? },
+          with_functions: target_schemas.select { |s| s.functions&.any? },
+          with_rules: target_schemas.select { |s| s.rules&.any? },
+          interface_only: target_schemas.select do |s|
             s.interfaces&.any? && !s.entities&.any? && !s.types&.any?
           end,
-          empty: schemas.select do |s|
+          empty: target_schemas.select do |s|
             !s.entities&.any? && !s.types&.any? && !s.functions&.any?
           end,
         }
@@ -159,7 +195,7 @@ module Expressir
       # @param limit [Integer] Maximum number of schemas to return
       # @return [Array<Hash>] Array of hashes with :schema and :total_elements
       def largest_schemas(limit = 10)
-        schemas.map do |s|
+        all_schemas.map do |s|
           {
             schema: s,
             total_elements: count_schema_elements(s),
@@ -186,7 +222,7 @@ module Expressir
       # @param limit [Integer] Maximum number of schemas to return
       # @return [Array<Hash>] Array of hashes with :schema and :complexity
       def schemas_by_complexity(limit = 10)
-        schemas.map { |s| { schema: s, complexity: schema_complexity(s) } }
+        all_schemas.map { |s| { schema: s, complexity: schema_complexity(s) } }
           .sort_by { |item| -item[:complexity] }
           .take(limit)
       end
@@ -205,7 +241,7 @@ module Expressir
         reference_counts = Hash.new(0)
         dependency_counts = Hash.new(0)
 
-        schemas.each do |schema|
+        all_schemas.each do |schema|
           next unless schema.interfaces&.any?
 
           stats[:total_interfaces] += schema.interfaces.size
@@ -232,7 +268,7 @@ module Expressir
       # @return [SchemaManifest] Manifest describing all schemas
       def to_manifest
         manifest = Expressir::SchemaManifest.new
-        schemas.each do |schema|
+        all_schemas.each do |schema|
           manifest.schemas << Expressir::SchemaManifestEntry.new(
             id: schema.id,
             path: schema.file || "#{schema.id}.exp",
@@ -250,7 +286,9 @@ module Expressir
 
         file_paths.each do |path|
           parsed = Expressir::Express::Parser.from_file(path)
-          parsed&.schemas&.each { |schema| repo.schemas << schema }
+          next unless parsed
+
+          repo.files << parsed if parsed.is_a?(ExpFile)
         end
 
         repo.resolve_all_references
@@ -261,7 +299,6 @@ module Expressir
       # @param package_path [String] Path to .ler package file
       # @return [Repository] Loaded repository
       def self.from_package(package_path)
-        require_relative "../package/reader"
         Package::Reader.load(package_path)
       end
 
@@ -276,7 +313,6 @@ module Expressir
       # @option options [String] :serialization_format ('marshal') Serialization format
       # @return [String] Path to created package
       def export_to_package(output_path, options = {})
-        require_relative "../package/builder"
         builder = Package::Builder.new
         builder.build(self, output_path, options)
       end
@@ -325,7 +361,7 @@ module Expressir
       # @return [Hash<String, Integer>] Entity counts per schema
       def entities_by_schema_counts
         counts = {}
-        schemas.each do |schema|
+        all_schemas.each do |schema|
           counts[schema.id] = schema.entities&.size || 0
         end
         counts
@@ -341,7 +377,7 @@ module Expressir
           defined: 0,
         }
 
-        schemas.each do |schema|
+        all_schemas.each do |schema|
           next unless schema.types
 
           schema.types.each do |type|
@@ -362,7 +398,7 @@ module Expressir
           reference_from: 0,
         }
 
-        schemas.each do |schema|
+        all_schemas.each do |schema|
           next unless schema.interfaces
 
           schema.interfaces.each do |interface|
@@ -383,7 +419,7 @@ module Expressir
       def count_entities
         return @entity_index.count if @entity_index && !@entity_index.empty?
 
-        schemas.sum { |schema| schema.entities&.size || 0 }
+        all_schemas.sum { |schema| schema.entities&.size || 0 }
       end
 
       # Count total types across all schemas
@@ -392,25 +428,25 @@ module Expressir
       def count_types
         return @type_index.count if @type_index && !@type_index.empty?
 
-        schemas.sum { |schema| schema.types&.size || 0 }
+        all_schemas.sum { |schema| schema.types&.size || 0 }
       end
 
       # Count total functions across all schemas
       # @return [Integer] Total function count
       def count_functions
-        schemas.sum { |schema| schema.functions&.size || 0 }
+        all_schemas.sum { |schema| schema.functions&.size || 0 }
       end
 
       # Count total rules across all schemas
       # @return [Integer] Total rule count
       def count_rules
-        schemas.sum { |schema| schema.rules&.size || 0 }
+        all_schemas.sum { |schema| schema.rules&.size || 0 }
       end
 
       # Count total procedures across all schemas
       # @return [Integer] Total procedure count
       def count_procedures
-        schemas.sum { |schema| schema.procedures&.size || 0 }
+        all_schemas.sum { |schema| schema.procedures&.size || 0 }
       end
     end
   end

data/lib/expressir/model/repository_validator.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "interface_validator"
-
 module Expressir
   module Model
     # Validator for repository consistency checks

data/lib/expressir/model/search_engine.rb

@@ -352,9 +352,7 @@ module Expressir
         return [] unless schemas
 
         entities = collect_from_schemas(schemas, :entities)
-        entities.flat_map { |e| e.attributes || [] }.select do |attr|
-          attr.is_a?(Declarations::DerivedAttribute)
-        end
+        entities.flat_map { |e| e.attributes || [] }.grep(Declarations::DerivedAttribute)
       end
 
       # Collect inverse attributes from entities
@@ -365,9 +363,7 @@ module Expressir
         return [] unless schemas
 
         entities = collect_from_schemas(schemas, :entities)
-        entities.flat_map { |e| e.attributes || [] }.select do |attr|
-          attr.is_a?(Declarations::InverseAttribute)
-        end
+        entities.flat_map { |e| e.attributes || [] }.grep(Declarations::InverseAttribute)
       end
 
       # Collect parameters from functions and procedures
@@ -488,31 +484,11 @@ module Expressir
       def find_parent_schema(element)
         current = element
         while current
-          # Duck typing - check if this looks like a schema
-          # A schema has no parent or is explicitly a Schema type
-          begin
-            # First check using is_a? for real objects
-            if current.is_a?(Declarations::Schema)
-              return current
-            end
-
-            # For mock objects, check if parent is nil and has id (likely a schema)
-            if !current.respond_to?(:parent) || current.parent.nil?
-              # This might be a schema - check if it has an id
-              if current.respond_to?(:id) && current.id
-                return current
-              end
-            end
-          rescue StandardError
-            # Ignore errors from type checking
-          end
-
-          current = begin
-            current.parent
-          rescue StandardError
-            nil
-          end
+          return current if current.is_a?(Declarations::Schema)
+          current = current.parent
         end
+      rescue StandardError
+        # Handle objects that don't fully implement the interface
         nil
       end
 

data/lib/expressir/model/statements/alias.rb

@@ -8,7 +8,7 @@ module Expressir
 
         attribute :expression, ModelElement
         attribute :statements, ModelElement, collection: true
-        attribute :_class, :string, default: -> { send(:name) }
+        attribute :_class, :string, default: -> { self.class.name }
 
         key_value do
           map "_class", to: :_class, render_default: true

data/lib/expressir/model/statements/assignment.rb

@@ -6,7 +6,7 @@ module Expressir
       class Assignment < ModelElement
         attribute :ref, ModelElement
         attribute :expression, ModelElement
-        attribute :_class, :string, default: -> { send(:name) }
+        attribute :_class, :string, default: -> { self.class.name }
 
         key_value do
           map "_class", to: :_class, render_default: true

data/lib/expressir/model/statements/case.rb

@@ -7,7 +7,7 @@ module Expressir
         attribute :expression, ModelElement
         attribute :actions, CaseAction, collection: true
         attribute :otherwise_statement, ModelElement
-        attribute :_class, :string, default: -> { send(:name) }
+        attribute :_class, :string, default: -> { self.class.name }
 
         key_value do
           map "_class", to: :_class, render_default: true

data/lib/expressir/model/statements/case_action.rb

@@ -6,7 +6,7 @@ module Expressir
       class CaseAction < ModelElement
         attribute :labels, ModelElement, collection: true
         attribute :statement, ModelElement
-        attribute :_class, :string, default: -> { send(:name) }
+        attribute :_class, :string, default: -> { self.class.name }
 
         key_value do
           map "_class", to: :_class, render_default: true

data/lib/expressir/model/statements/compound.rb

@@ -5,7 +5,7 @@ module Expressir
       # - section 13.5 Compound statement
       class Compound < ModelElement
         attribute :statements, ModelElement, collection: true
-        attribute :_class, :string, default: -> { send(:name) }
+        attribute :_class, :string, default: -> { self.class.name }
 
         key_value do
           map "_class", to: :_class, render_default: true

data/lib/expressir/model/statements/escape.rb

@@ -4,7 +4,7 @@ module Expressir
       # Specified in ISO 10303-11:2004
       # - section 13.6 Escape statement
       class Escape < ModelElement
-        attribute :_class, :string, default: -> { send(:name) }
+        attribute :_class, :string, default: -> { self.class.name }
 
         key_value do
           map "_class", to: :_class, render_default: true