expressir 2.2.1 → 2.3.1

data/lib/expressir/model/exp_file.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Model
+    # Represents a single EXPRESS file containing schemas and preamble remarks.
+    # This class preserves file-level information including:
+    # - File path for reference
+    # - Preamble remarks (comments at the top of the file before any schema)
+    # - Schemas defined in this file
+    #
+    # A Repository contains multiple ExpFile instances when parsing multiple files,
+    # or a single ExpFile when parsing a single file.
+    class ExpFile < ModelElement
+      include ScopeContainer
+
+      attribute :path, :string
+      attribute :schemas, Declarations::Schema, collection: true,
+                                                initialize_empty: true
+      attribute :_class, :string, default: -> { self.class.name }
+
+      key_value do
+        map "_class", to: :_class, render_default: true
+        map "path", to: :path
+        map "schemas", to: :schemas
+      end
+
+      # Returns the file path as the identifier
+      # @return [String, nil] The file path or nil
+      def id
+        path
+      end
+
+      # @return [Array<Declaration>]
+      def children
+        schemas
+      end
+    end
+  end
+end

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

@@ -5,7 +5,7 @@ module Expressir
       # - section 12.9 Aggregate initializer
       class AggregateInitializer < ModelElement
         attribute :items, 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/expressions/aggregate_initializer_item.rb

@@ -6,7 +6,7 @@ module Expressir
       class AggregateInitializerItem < ModelElement
         attribute :expression, ModelElement
         attribute :repetition, 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/binary_expression.rb

@@ -44,7 +44,7 @@ module Expressir
                   ]
         attribute :operand1, ModelElement
         attribute :operand2, 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/entity_constructor.rb

@@ -6,7 +6,7 @@ module Expressir
       class EntityConstructor < ModelElement
         attribute :entity, ModelElement
         attribute :parameters, 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/expressions/function_call.rb

@@ -6,7 +6,7 @@ module Expressir
       class FunctionCall < ModelElement
         attribute :function, ModelElement
         attribute :parameters, 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/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.grep(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,48 @@ 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)
-        super(*args, **kwargs)
+      def initialize(*, base_dir: nil, schemas: nil, **)
+        super(*, **)
         @base_dir = base_dir
         @entity_index = nil
         @type_index = nil
         @reference_index = nil
+        @_schemas = []
+
+        # Support direct schemas initialization
+        schemas&.each { |schema| @_schemas << schema }
+      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
+
+      # 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<Declaration>]
+      # @return [Array<Declarations::Schema>]
       def children
         schemas
       end
@@ -40,9 +73,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 +138,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 +149,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 +175,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 +194,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 +221,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 +240,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 +267,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 +285,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 +298,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 +312,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
@@ -306,16 +341,16 @@ module Expressir
       # @param format [Symbol] Output format
       # @yield [item] Block to convert item to hash
       # @return [Array, String] Formatted output
-      def format_output(items, format, &block)
+      def format_output(items, format, &)
         case format
         when :hash
-          items.map(&block)
+          items.map(&)
         when :json
           require "json"
-          items.map(&block).to_json
+          items.map(&).to_json
         when :yaml
           require "yaml"
-          items.map(&block).to_yaml
+          items.map(&).to_yaml
         else
           items
         end
@@ -325,7 +360,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 +376,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 +397,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 +418,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 +427,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