expressir 2.4.29-arm-linux

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

@@ -0,0 +1,18 @@
+module Expressir
+  module Model
+    module Statements
+      # Specified in ISO 10303-11:2004
+      # - section 13.6 Escape statement
+      class Escape < ModelElement
+        include Statement
+
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "untagged_remarks", to: :untagged_remarks
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Expressir
+  module Model
+    module Statements
+      # Specified in ISO 10303-11:2004
+      # - section 13.7 If ... Then ... Else statement
+      class If < ModelElement
+        include Statement
+
+        collection_attributes :statements, :else_statements
+        child_attributes :expression
+        attribute :expression, ModelElement
+        attribute :statements, ModelElement, collection: true
+        attribute :else_statements, ModelElement, collection: true
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "untagged_remarks", to: :untagged_remarks
+          map "expression", to: :expression
+          map "statements", to: :statements
+          map "else_statements", to: :else_statements
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Expressir
+  module Model
+    module Statements
+      # Specified in ISO 10303-11:2004
+      # - section 13.1 Null (statement)
+      class Null < ModelElement
+        include Statement
+
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "untagged_remarks", to: :untagged_remarks
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Expressir
+  module Model
+    module Statements
+      # Specified in ISO 10303-11:2004
+      # - section 13.8 Procedure call statement
+      class ProcedureCall < ModelElement
+        include Statement
+
+        attribute :procedure, ModelElement
+        attribute :parameters, ModelElement, collection: true
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "untagged_remarks", to: :untagged_remarks
+          map "procedure", to: :procedure
+          map "parameters", to: :parameters
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Expressir
+  module Model
+    module Statements
+      # Specified in ISO 10303-11:2004
+      # - section 13.9 Repeat statement
+      class Repeat < ModelElement
+        include Statement
+        include Identifier
+
+        collection_attributes :statements
+        child_attributes :while_expression, :until_expression
+        attribute :bound1, ModelElement
+        attribute :bound2, ModelElement
+        attribute :increment, ModelElement
+        attribute :while_expression, ModelElement
+        attribute :until_expression, ModelElement
+        attribute :statements, ModelElement, collection: true
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "bound1", to: :bound1
+          map "bound2", to: :bound2
+          map "increment", to: :increment
+          map "while_expression", to: :while_expression
+          map "until_expression", to: :until_expression
+          map "statements", to: :statements
+        end
+
+        # @return [Array<Declaration>]
+        def children
+          [
+            self,
+            *remark_items,
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Expressir
+  module Model
+    module Statements
+      # Specified in ISO 10303-11:2004
+      # - section 13.10 Return statement
+      class Return < ModelElement
+        include Statement
+
+        attribute :expression, ModelElement
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "untagged_remarks", to: :untagged_remarks
+          map "expression", to: :expression
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Expressir
+  module Model
+    module Statements
+      # Specified in ISO 10303-11:2004
+      # - section 13.11 Skip statement
+      class Skip < ModelElement
+        include Statement
+
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "untagged_remarks", to: :untagged_remarks
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Expressir
+  module Model
+    module SupertypeExpressions
+      # Specified in ISO 10303-11:2004
+      # - section 9.2.5.3 ANDOR
+      # - section 9.2.5.4 AND
+      class BinarySupertypeExpression < ModelElement
+        AND = "AND".freeze
+        ANDOR = "ANDOR".freeze
+
+        attribute :operator, :string, values: %w[AND ANDOR]
+        attribute :operand1, ModelElement
+        attribute :operand2, ModelElement
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "operator", to: :operator
+          map "operand1", to: :operand1
+          map "operand2", to: :operand2
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Expressir
+  module Model
+    module SupertypeExpressions
+      # Specified in ISO 10303-11:2004
+      # - section 9.2.5.2 ONEOF
+      class OneofSupertypeExpression < ModelElement
+        attribute :operands, ModelElement, collection: true
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "operands", to: :operands
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# lib/expressir/model.rb
+
+module Expressir
+  module Model
+    # Marker modules — autoload the same concerns.rb file from each name.
+    # The first reference triggers the load; the file defines all eight markers.
+    autoload :HasId, "#{__dir__}/model/concerns"
+    autoload :HasRemarkItems, "#{__dir__}/model/concerns"
+    autoload :HasRemarks, "#{__dir__}/model/concerns"
+    autoload :ScopeContainer, "#{__dir__}/model/concerns"
+    autoload :HasInformalPropositions, "#{__dir__}/model/concerns"
+    autoload :HasWhereRules, "#{__dir__}/model/concerns"
+    autoload :TakesInlineRemark, "#{__dir__}/model/concerns"
+    autoload :Statement, "#{__dir__}/model/concerns"
+
+    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 :RemarkFormat, "#{__dir__}/model/remark_format"
+    autoload :RemarkPlacement, "#{__dir__}/model/remark_placement"
+    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

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require "zip"
+require "time"
+
+module Expressir
+  module Package
+    # Builds LER packages from Repository instances
+    # Single responsibility: Create .ler ZIP packages
+    class Builder
+      # Build LER package from repository
+      # @param repository [Model::Repository] Repository to package
+      # @param output_path [String] Output .ler file path
+      # @param options [Hash] Package options
+      # @option options [String] :name Package name
+      # @option options [String] :version Package version
+      # @option options [String] :description Package description
+      # @option options [String] :express_mode ('include_all') Bundling mode
+      # @option options [String] :resolution_mode ('resolved') Resolution mode
+      # @option options [String] :serialization_format ('marshal') Serialization format
+      # @return [String] Path to created package
+      def build(repository, output_path, options = {})
+        options = normalize_options(options)
+        metadata = build_metadata(repository, options)
+
+        # Validate metadata
+        validation = metadata.validate
+        unless validation[:valid?]
+          raise ArgumentError,
+                "Invalid metadata: #{validation[:errors].join(', ')}"
+        end
+
+        # Create ZIP package
+        Zip::File.open(output_path, create: true) do |zip|
+          add_metadata(zip, metadata)
+          add_schemas(zip, repository, options)
+          add_indexes(zip, repository)
+          add_manifest(zip, repository)
+        end
+
+        output_path
+      end
+
+      private
+
+      # Normalize options with defaults
+      # @param options [Hash] Raw options
+      # @return [Hash] Normalized options
+      def normalize_options(options)
+        {
+          name: options[:name] || "Unnamed Package",
+          version: options[:version] || "1.0.0",
+          description: options[:description] || "",
+          express_mode: options[:express_mode] || "include_all",
+          resolution_mode: options[:resolution_mode] || "resolved",
+          serialization_format: options[:serialization_format] || "marshal",
+        }
+      end
+
+      # Build metadata from repository and options
+      # @param repository [Model::Repository] Repository instance
+      # @param options [Hash] Package options
+      # @return [Metadata] Package metadata
+      def build_metadata(repository, options)
+        Metadata.new(
+          name: options[:name],
+          version: options[:version],
+          description: options[:description],
+          created_at: Time.now.utc.iso8601,
+          created_by: "expressir",
+          expressir_version: Expressir::Version::VERSION,
+          express_mode: options[:express_mode],
+          resolution_mode: options[:resolution_mode],
+          serialization_format: options[:serialization_format],
+          files: count_files(repository),
+          schemas: repository.schemas.size,
+        )
+      end
+
+      # Count files in repository
+      # @param repository [Model::Repository] Repository instance
+      # @return [Integer] File count
+      def count_files(repository)
+        repository.schemas.count(&:file)
+      end
+
+      # Add metadata to package
+      # @param zip [Zip::File] ZIP archive
+      # @param metadata [Metadata] Package metadata
+      # @return [void]
+      def add_metadata(zip, metadata)
+        zip.get_output_stream("metadata.yaml") do |stream|
+          stream.write(metadata.to_yaml)
+        end
+      end
+
+      # Add schemas to package based on resolution mode
+      # @param zip [Zip::File] ZIP archive
+      # @param repository [Model::Repository] Repository instance
+      # @param options [Hash] Package options
+      # @return [void]
+      def add_schemas(zip, repository, options)
+        case options[:resolution_mode]
+        when "resolved"
+          add_serialized_repository(zip, repository,
+                                    options[:serialization_format])
+        end
+
+        # Add EXPRESS files if include_all mode
+        if options[:express_mode] == "include_all"
+          add_express_files(zip, repository)
+        end
+      end
+
+      # Add serialized repository to package
+      # @param zip [Zip::File] ZIP archive
+      # @param repository [Model::Repository] Repository instance
+      # @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(normalized_repo))
+          end
+        when "json"
+          zip.get_output_stream("repository.json") do |stream|
+            stream.write(normalized_repo.to_json)
+          end
+        when "yaml"
+          zip.get_output_stream("repository.yaml") do |stream|
+            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
+      # @return [void]
+      def add_express_files(zip, repository)
+        repository.schemas.each do |schema|
+          next unless schema.file && File.exist?(schema.file)
+
+          # Use schema id as filename
+          filename = "express_files/#{schema.id}.exp"
+          zip.get_output_stream(filename) do |stream|
+            stream.write(File.read(schema.file))
+          end
+        end
+      end
+
+      # Add indexes to package
+      # @param zip [Zip::File] ZIP archive
+      # @param repository [Model::Repository] Repository instance
+      # @return [void]
+      def add_indexes(zip, repository)
+        # Ensure indexes are built
+        repository.build_indexes if repository.entity_index.nil?
+
+        # Serialize indexes using Marshal for performance
+        zip.get_output_stream("entity_index.marshal") do |stream|
+          stream.write(Marshal.dump(repository.entity_index))
+        end
+
+        zip.get_output_stream("type_index.marshal") do |stream|
+          stream.write(Marshal.dump(repository.type_index))
+        end
+
+        zip.get_output_stream("reference_index.marshal") do |stream|
+          stream.write(Marshal.dump(repository.reference_index))
+        end
+      end
+
+      # Add manifest to package with rewritten paths
+      # @param zip [Zip::File] ZIP archive
+      # @param repository [Model::Repository] Repository instance
+      # @return [void]
+      def add_manifest(zip, repository)
+        # Create manifest with package-internal paths
+        manifest = Expressir::SchemaManifest.new
+
+        repository.schemas.each do |schema|
+          manifest.schemas << Expressir::SchemaManifestEntry.new(
+            id: schema.id,
+            path: "express_files/#{schema.id}.exp", # Package-internal path
+          )
+        end
+
+        # Set output_path to suppress relative path calculation
+        manifest.output_path = "manifest.yaml"
+
+        zip.get_output_stream("manifest.yaml") do |stream|
+          stream.write(manifest.to_yaml)
+        end
+      end
+    end
+  end
+end

data/lib/expressir/package/metadata.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Package
+    # Package metadata with serialization support
+    # Stores configuration and statistics for LER packages
+    class Metadata < Lutaml::Model::Serializable
+      attribute :name, :string
+      attribute :version, :string
+      attribute :description, :string
+      attribute :created_at, :string
+      attribute :created_by, :string, default: -> { "expressir" }
+      attribute :expressir_version, :string
+      attribute :express_mode, :string, default: -> { "include_all" }
+      attribute :resolution_mode, :string, default: -> { "resolved" }
+      attribute :serialization_format, :string, default: -> { "marshal" }
+      attribute :files, :integer
+      attribute :schemas, :integer
+
+      yaml do
+        map "name", to: :name
+        map "version", to: :version
+        map "description", to: :description
+        map "created_at", to: :created_at
+        map "created_by", to: :created_by
+        map "expressir_version", to: :expressir_version
+        map "express_mode", to: :express_mode
+        map "resolution_mode", to: :resolution_mode
+        map "serialization_format", to: :serialization_format
+        map "files", to: :files
+        map "schemas", to: :schemas
+      end
+
+      # Validate metadata configuration
+      # @return [Hash] Validation result with :valid? and :errors
+      def validate
+        errors = []
+
+        errors << "name is required" if name.nil? || name.empty?
+        errors << "version is required" if version.nil? || version.empty?
+
+        unless %w[include_all allow_external].include?(express_mode)
+          errors << "express_mode must be 'include_all' or 'allow_external'"
+        end
+
+        unless %w[resolved bare].include?(resolution_mode)
+          errors << "resolution_mode must be 'resolved' or 'bare'"
+        end
+
+        unless %w[marshal json yaml].include?(serialization_format)
+          errors << "serialization_format must be 'marshal', 'json', or 'yaml'"
+        end
+
+        {
+          valid?: errors.empty?,
+          errors: errors,
+        }
+      end
+
+      # Convert metadata to hash
+      # @return [Hash] Metadata as hash
+      def to_h
+        {
+          "name" => name,
+          "version" => version,
+          "description" => description,
+          "created_at" => created_at,
+          "created_by" => created_by,
+          "expressir_version" => expressir_version,
+          "express_mode" => express_mode,
+          "resolution_mode" => resolution_mode,
+          "serialization_format" => serialization_format,
+          "files" => files,
+          "schemas" => schemas,
+        }
+      end
+    end
+  end
+end