expressir 2.2.1 → 2.3.1

data/lib/expressir/model/search_engine.rb

@@ -84,10 +84,10 @@ module Expressir
       # @param max_depth [Integer] Maximum path depth (1=schema, 2=entity, 3=attribute)
       # @param options [Hash] Additional search options
       # @return [Array<Hash>] Filtered results
-      def search_with_depth(pattern:, max_depth:, **options)
+      def search_with_depth(pattern:, max_depth:, **)
         return [] if max_depth <= 0
 
-        results = search(pattern: pattern, **options)
+        results = search(pattern: pattern, **)
         filter_by_depth(results, max_depth)
       end
 
@@ -97,8 +97,8 @@ module Expressir
       # @param boost_prefix [Integer] Score boost for prefix matches
       # @param options [Hash] Additional search options
       # @return [Array<Hash>] Ranked results with :relevance_score
-      def search_ranked(pattern:, boost_exact: 10, boost_prefix: 5, **options)
-        results = search(pattern: pattern, **options)
+      def search_ranked(pattern:, boost_exact: 10, boost_prefix: 5, **)
+        results = search(pattern: pattern, **)
         rank_results(results, pattern, boost_exact, boost_prefix)
       end
 
@@ -108,8 +108,8 @@ module Expressir
       # @param ranked [Boolean] Enable relevance ranking
       # @param options [Hash] Additional filters and search options
       # @return [Array<Hash>] Filtered and optionally ranked results
-      def search_advanced(pattern:, max_depth: nil, ranked: false, **options)
-        results = search(pattern: pattern, **options)
+      def search_advanced(pattern:, max_depth: nil, ranked: false, **)
+        results = search(pattern: pattern, **)
 
         results = filter_by_depth(results, max_depth) if max_depth
         results = rank_results(results, pattern, 10, 5) if ranked
@@ -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,12 @@ 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
+          return current if current.is_a?(Declarations::Schema)
 
-            # 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
+          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

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

@@ -7,7 +7,7 @@ module Expressir
         attribute :expression, ModelElement
         attribute :statements, ModelElement, collection: true
         attribute :else_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/null.rb

@@ -4,7 +4,7 @@ module Expressir
       # Specified in ISO 10303-11:2004
       # - section 13.1 Null (statement)
       class Null < 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/procedure_call.rb

@@ -6,7 +6,7 @@ module Expressir
       class ProcedureCall < ModelElement
         attribute :procedure, 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/statements/repeat.rb

@@ -12,7 +12,7 @@ module Expressir
         attribute :while_expression, ModelElement
         attribute :until_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/return.rb

@@ -5,7 +5,7 @@ module Expressir
       # - section 13.10 Return statement
       class Return < 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/skip.rb

@@ -4,7 +4,7 @@ module Expressir
       # Specified in ISO 10303-11:2004
       # - section 13.11 Skip statement
       class Skip < 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.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Model
+    module Statements
+      autoload :Alias, "#{__dir__}/statements/alias"
+      autoload :Assignment, "#{__dir__}/statements/assignment"
+      autoload :Case, "#{__dir__}/statements/case"
+      autoload :CaseAction, "#{__dir__}/statements/case_action"
+      autoload :Compound, "#{__dir__}/statements/compound"
+      autoload :Escape, "#{__dir__}/statements/escape"
+      autoload :If, "#{__dir__}/statements/if"
+      autoload :Null, "#{__dir__}/statements/null"
+      autoload :ProcedureCall, "#{__dir__}/statements/procedure_call"
+      autoload :Repeat, "#{__dir__}/statements/repeat"
+      autoload :Return, "#{__dir__}/statements/return"
+      autoload :Skip, "#{__dir__}/statements/skip"
+    end
+  end
+end

data/lib/expressir/model/supertype_expressions/binary_supertype_expression.rb

@@ -11,7 +11,7 @@ module Expressir
         attribute :operator, :string, values: %w[AND ANDOR]
         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/supertype_expressions/oneof_supertype_expression.rb

@@ -5,7 +5,7 @@ module Expressir
       # - section 9.2.5.2 ONEOF
       class OneofSupertypeExpression < ModelElement
         attribute :operands, 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/supertype_expressions.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Model
+    module SupertypeExpressions
+      autoload :BinarySupertypeExpression,
+               "#{__dir__}/supertype_expressions/binary_supertype_expression"
+      autoload :OneofSupertypeExpression,
+               "#{__dir__}/supertype_expressions/oneof_supertype_expression"
+    end
+  end
+end

data/lib/expressir/model.rb

@@ -1,5 +1,29 @@
-# frozen_string_literal: true
+# lib/expressir/model.rb
 
-# This file is kept for backward compatibility when explicitly requiring 'expressir/model'
-# The actual autoload definitions are in lib/expressir.rb
-# This file does nothing - autoload handles everything automatically
+# Load marker modules for type checking
+require_relative "model/concerns"
+
+module Expressir
+  module Model
+    autoload :ModelElement, "#{__dir__}/model/model_element"
+    autoload :Cache, "#{__dir__}/model/cache"
+    autoload :ExpFile, "#{__dir__}/model/exp_file"
+    autoload :Identifier, "#{__dir__}/model/identifier"
+    autoload :Repository, "#{__dir__}/model/repository"
+    autoload :RepositoryValidator, "#{__dir__}/model/repository_validator"
+    autoload :DependencyResolver, "#{__dir__}/model/dependency_resolver"
+    autoload :RemarkInfo, "#{__dir__}/model/remark_info"
+    autoload :InterfaceValidator, "#{__dir__}/model/interface_validator"
+    autoload :SearchEngine, "#{__dir__}/model/search_engine"
+
+    # Submodules - autoload their namespace files
+    autoload :Indexes, "#{__dir__}/model/indexes"
+    autoload :DataTypes, "#{__dir__}/model/data_types"
+    autoload :Declarations, "#{__dir__}/model/declarations"
+    autoload :Expressions, "#{__dir__}/model/expressions"
+    autoload :Literals, "#{__dir__}/model/literals"
+    autoload :References, "#{__dir__}/model/references"
+    autoload :Statements, "#{__dir__}/model/statements"
+    autoload :SupertypeExpressions, "#{__dir__}/model/supertype_expressions"
+  end
+end

data/lib/expressir/package/builder.rb

@@ -2,7 +2,6 @@
 
 require "zip"
 require "time"
-require_relative "metadata"
 
 module Expressir
   module Package
@@ -119,22 +118,54 @@ module Expressir
       # @param format [String] Serialization format
       # @return [void]
       def add_serialized_repository(zip, repository, format)
+        # Normalize repository - ensure all schemas are in files for serialization
+        normalized_repo = normalize_repository(repository)
+
         case format
         when "marshal"
           zip.get_output_stream("repository.marshal") do |stream|
-            stream.write(Marshal.dump(repository))
+            stream.write(Marshal.dump(normalized_repo))
           end
         when "json"
           zip.get_output_stream("repository.json") do |stream|
-            stream.write(repository.to_json)
+            stream.write(normalized_repo.to_json)
           end
         when "yaml"
           zip.get_output_stream("repository.yaml") do |stream|
-            stream.write(repository.to_yaml)
+            stream.write(normalized_repo.to_yaml)
           end
         end
       end
 
+      # Normalize repository for serialization
+      # Ensures all schemas are in files (not in @_schemas)
+      # @param repository [Model::Repository] Repository to normalize
+      # @return [Model::Repository] Normalized repository
+      def normalize_repository(repository)
+        # Create a new repository with proper file structure
+        normalized = Model::Repository.new(base_dir: repository.base_dir)
+
+        # Copy existing files
+        repository.files&.each do |file|
+          normalized.files << file
+        end
+
+        # Get schemas that are not already in files
+        file_schema_ids = normalized.files.flat_map(&:schemas).compact.map(&:id)
+        direct_schemas = repository.schemas.reject do |s|
+          file_schema_ids.include?(s.id)
+        end
+
+        # Create an ExpFile for direct schemas
+        if direct_schemas.any?
+          exp_file = Model::ExpFile.new(path: "direct_schemas.exp")
+          exp_file.schemas = direct_schemas
+          normalized.files << exp_file
+        end
+
+        normalized
+      end
+
       # Add EXPRESS files to package
       # @param zip [Zip::File] ZIP archive
       # @param repository [Model::Repository] Repository instance

data/lib/expressir/package/metadata.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "lutaml/model"
-
 module Expressir
   module Package
     # Package metadata with serialization support

data/lib/expressir/package/reader.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "zip"
-require_relative "metadata"
 
 module Expressir
   module Package

data/lib/expressir/package.rb

@@ -0,0 +1,8 @@
+# lib/expressir/package.rb
+module Expressir
+  module Package
+    autoload :Metadata, "#{__dir__}/package/metadata"
+    autoload :Builder, "#{__dir__}/package/builder"
+    autoload :Reader, "#{__dir__}/package/reader"
+  end
+end

data/lib/expressir/schema_manifest.rb

@@ -1,13 +1,11 @@
 # frozen_string_literal: true
 
-require "lutaml/model"
-require_relative "schema_manifest_entry"
-
 module Expressir
   class SchemaManifest < Lutaml::Model::Serializable
-    attribute :schemas, SchemaManifestEntry, collection: true,
-                                             initialize_empty: true
-    attribute :path, Lutaml::Model::Type::String
+    attribute :schemas, "Expressir::SchemaManifestEntry",
+              collection: true,
+              initialize_empty: true
+    attribute :path, :string
     attr_accessor :output_path
 
     def initialize(**args)
@@ -28,7 +26,7 @@ module Expressir
         x.set_initial_path(path)
       end
     rescue StandardError => e
-      raise InvalidSchemaManifestError,
+      raise ManifestValidationError,
             "Invalid schema manifest format: #{e.message}"
     end
 

data/lib/expressir/schema_manifest_entry.rb

@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 
-require "lutaml/model"
-
 module Expressir
   class SchemaManifestEntry < Lutaml::Model::Serializable
-    attribute :id, Lutaml::Model::Type::String
-    attribute :path, Lutaml::Model::Type::String
-    # attribute :schemas_only, Lutaml::Model::Type::Boolean
+    attribute :id, :string
+    attribute :path, :string
+    # attribute :schemas_only, :boolean
 
     # container_path is a copy of Expressir::SchemaManifest.path,
     # used to resolve the path of each schema within

data/lib/expressir/transformer.rb

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

data/lib/expressir/version.rb

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