expressir 2.2.1 → 2.3.0

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,52 @@ 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 { |s| file_schema_ids.include?(s.id) }
+
+        # 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,6 +1,5 @@
 # frozen_string_literal: true
 
-require "lutaml/model"
 
 module Expressir
   module Package

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,12 @@
 # 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 +27,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,11 @@
 # 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.0".freeze
 end

data/lib/expressir.rb

@@ -1,11 +1,6 @@
 require_relative "expressir/version"
 require_relative "expressir/errors"
-require_relative "expressir/cli"
-require_relative "expressir/config"
-require_relative "expressir/benchmark"
-require_relative "expressir/coverage"
-require_relative "expressir/schema_manifest"
-require_relative "expressir/schema_manifest_entry"
+
 require "lutaml/model"
 require "liquid" # To enable Lutaml::Model::Liquefiable
 
@@ -29,6 +24,28 @@ else
 end
 
 module Expressir
+  # Namespace modules - autoload loads the namespace file which contains
+  # autoload definitions for classes within that namespace
+  autoload :Config, "#{__dir__}/expressir/config"
+  extend Config
+
+  autoload :Benchmark, "#{__dir__}/expressir/benchmark"
+  autoload :Coverage, "#{__dir__}/expressir/coverage"
+
+  autoload :Express, "#{__dir__}/expressir/express"
+  autoload :Model, "#{__dir__}/expressir/model"
+  autoload :Commands, "#{__dir__}/expressir/commands"
+  autoload :Changes, "#{__dir__}/expressir/changes"
+  autoload :Package, "#{__dir__}/expressir/package"
+  autoload :Manifest, "#{__dir__}/expressir/manifest"
+  autoload :Eengine, "#{__dir__}/expressir/eengine"
+  autoload :SchemaManifest, "#{__dir__}/expressir/schema_manifest"
+  autoload :SchemaManifestEntry, "#{__dir__}/expressir/schema_manifest_entry"
+
+  # CLI is loaded last so that namespace autoloads are defined first
+  # CLI uses Expressir::Commands::* which triggers autoload
+  autoload :Cli, "#{__dir__}/expressir/cli"
+
   def self.root
     File.dirname(__dir__)
   end
@@ -36,169 +53,4 @@ module Expressir
   def self.root_path
     @root_path ||= Pathname.new(Expressir.root)
   end
-
-  # Autoload for Express module classes
-  module Express
-    autoload :Builder, "expressir/express/builder"
-    autoload :Cache, "expressir/express/cache"
-    autoload :Error, "expressir/express/error"
-    autoload :Formatter, "expressir/express/formatter"
-    autoload :HyperlinkFormatter, "expressir/express/hyperlink_formatter"
-    autoload :ModelVisitor, "expressir/express/model_visitor"
-    autoload :Parser, "expressir/express/parser"
-    autoload :PrettyFormatter, "expressir/express/pretty_formatter"
-    autoload :RemarkAttacher, "expressir/express/remark_attacher"
-    autoload :ResolveReferencesModelVisitor,
-             "expressir/express/resolve_references_model_visitor"
-    autoload :SchemaHeadFormatter, "expressir/express/schema_head_formatter"
-    autoload :StreamingBuilder, "expressir/express/streaming_builder"
-  end
-
-  # Autoload for Model module classes
-  module Model
-    autoload :ModelElement, "expressir/model/model_element"
-    autoload :Cache, "expressir/model/cache"
-    autoload :Identifier, "expressir/model/identifier"
-    autoload :Repository, "expressir/model/repository"
-    autoload :RepositoryValidator, "expressir/model/repository_validator"
-    autoload :DependencyResolver, "expressir/model/dependency_resolver"
-    autoload :RemarkInfo, "expressir/model/remark_info"
-
-    module Indexes
-      autoload :EntityIndex, "expressir/model/indexes/entity_index"
-      autoload :TypeIndex, "expressir/model/indexes/type_index"
-      autoload :ReferenceIndex, "expressir/model/indexes/reference_index"
-    end
-
-    module DataTypes
-      autoload :Aggregate, "expressir/model/data_types/aggregate"
-      autoload :Array, "expressir/model/data_types/array"
-      autoload :Bag, "expressir/model/data_types/bag"
-      autoload :Binary, "expressir/model/data_types/binary"
-      autoload :Boolean, "expressir/model/data_types/boolean"
-      autoload :Enumeration, "expressir/model/data_types/enumeration"
-      autoload :EnumerationItem, "expressir/model/data_types/enumeration_item"
-      autoload :GenericEntity, "expressir/model/data_types/generic_entity"
-      autoload :Generic, "expressir/model/data_types/generic"
-      autoload :Integer, "expressir/model/data_types/integer"
-      autoload :List, "expressir/model/data_types/list"
-      autoload :Logical, "expressir/model/data_types/logical"
-      autoload :Number, "expressir/model/data_types/number"
-      autoload :Real, "expressir/model/data_types/real"
-      autoload :Select, "expressir/model/data_types/select"
-      autoload :Set, "expressir/model/data_types/set"
-      autoload :String, "expressir/model/data_types/string"
-    end
-
-    module Declarations
-      autoload :Attribute, "expressir/model/declarations/attribute"
-      autoload :Constant, "expressir/model/declarations/constant"
-      autoload :DerivedAttribute,
-               "expressir/model/declarations/derived_attribute"
-      autoload :Entity, "expressir/model/declarations/entity"
-      autoload :Function, "expressir/model/declarations/function"
-      autoload :Interface, "expressir/model/declarations/interface"
-      autoload :InterfaceItem, "expressir/model/declarations/interface_item"
-      autoload :InterfacedItem, "expressir/model/declarations/interfaced_item"
-      autoload :InverseAttribute,
-               "expressir/model/declarations/inverse_attribute"
-      autoload :Parameter, "expressir/model/declarations/parameter"
-      autoload :Procedure, "expressir/model/declarations/procedure"
-      autoload :RemarkItem, "expressir/model/declarations/remark_item"
-      autoload :Rule, "expressir/model/declarations/rule"
-      autoload :Schema, "expressir/model/declarations/schema"
-      autoload :SchemaVersion, "expressir/model/declarations/schema_version"
-      autoload :SchemaVersionItem,
-               "expressir/model/declarations/schema_version_item"
-      autoload :SubtypeConstraint,
-               "expressir/model/declarations/subtype_constraint"
-      autoload :Type, "expressir/model/declarations/type"
-      autoload :UniqueRule, "expressir/model/declarations/unique_rule"
-      autoload :Variable, "expressir/model/declarations/variable"
-      autoload :WhereRule, "expressir/model/declarations/where_rule"
-      autoload :InformalPropositionRule,
-               "expressir/model/declarations/informal_proposition_rule"
-    end
-
-    module Expressions
-      autoload :AggregateInitializer,
-               "expressir/model/expressions/aggregate_initializer"
-      autoload :AggregateInitializerItem,
-               "expressir/model/expressions/aggregate_initializer_item"
-      autoload :BinaryExpression,
-               "expressir/model/expressions/binary_expression"
-      autoload :EntityConstructor,
-               "expressir/model/expressions/entity_constructor"
-      autoload :FunctionCall, "expressir/model/expressions/function_call"
-      autoload :Interval, "expressir/model/expressions/interval"
-      autoload :QueryExpression, "expressir/model/expressions/query_expression"
-      autoload :UnaryExpression, "expressir/model/expressions/unary_expression"
-    end
-
-    module Literals
-      autoload :Binary, "expressir/model/literals/binary"
-      autoload :Integer, "expressir/model/literals/integer"
-      autoload :Logical, "expressir/model/literals/logical"
-      autoload :Real, "expressir/model/literals/real"
-      autoload :String, "expressir/model/literals/string"
-    end
-
-    module References
-      autoload :AttributeReference,
-               "expressir/model/references/attribute_reference"
-      autoload :GroupReference, "expressir/model/references/group_reference"
-      autoload :IndexReference, "expressir/model/references/index_reference"
-      autoload :SimpleReference, "expressir/model/references/simple_reference"
-    end
-
-    module Statements
-      autoload :Alias, "expressir/model/statements/alias"
-      autoload :Assignment, "expressir/model/statements/assignment"
-      autoload :Case, "expressir/model/statements/case"
-      autoload :CaseAction, "expressir/model/statements/case_action"
-      autoload :Compound, "expressir/model/statements/compound"
-      autoload :Escape, "expressir/model/statements/escape"
-      autoload :If, "expressir/model/statements/if"
-      autoload :Null, "expressir/model/statements/null"
-      autoload :ProcedureCall, "expressir/model/statements/procedure_call"
-      autoload :Repeat, "expressir/model/statements/repeat"
-      autoload :Return, "expressir/model/statements/return"
-      autoload :Skip, "expressir/model/statements/skip"
-    end
-
-    module SupertypeExpressions
-      autoload :BinarySupertypeExpression,
-               "expressir/model/supertype_expressions/binary_supertype_expression"
-      autoload :OneofSupertypeExpression,
-               "expressir/model/supertype_expressions/oneof_supertype_expression"
-    end
-  end
-
-  # Autoload for Package module classes
-  module Package
-    autoload :Metadata, "expressir/package/metadata"
-    autoload :Builder, "expressir/package/builder"
-    autoload :Reader, "expressir/package/reader"
-  end
-
-  # Autoload for Commands module classes
-  module Commands
-    autoload :Base, "expressir/commands/base"
-    autoload :Benchmark, "expressir/commands/benchmark"
-    autoload :BenchmarkCache, "expressir/commands/benchmark_cache"
-    autoload :Clean, "expressir/commands/clean"
-    autoload :ImportComparison, "expressir/commands/import_comparison"
-    autoload :Coverage, "expressir/commands/coverage"
-    autoload :Format, "expressir/commands/format"
-    autoload :Validate, "expressir/commands/validate"
-    autoload :Version, "expressir/commands/version"
-  end
-
-  # Autoload for Changes module classes
-  module Changes
-    autoload :SchemaChange, "expressir/changes/schema_change"
-    autoload :VersionChange, "expressir/changes/version_change"
-    autoload :ItemChange, "expressir/changes/item_change"
-    autoload :MappingChange, "expressir/changes/mapping_change"
-  end
 end