expressir 2.4.29-arm-linux

data/lib/expressir/model/dependency_resolver.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Model
+    # Resolves dependencies between EXPRESS schemas
+    # Handles USE FROM and REFERENCE FROM interfaces
+    # Detects circular dependencies
+    class DependencyResolver
+      # Exception for circular dependencies
+      class CircularDependencyError < StandardError
+        attr_reader :dependency_chain
+
+        def initialize(message, chain)
+          super(message)
+          @dependency_chain = chain
+        end
+      end
+
+      attr_reader :base_dirs, :schema_registry, :verbose, :unresolved
+
+      # Initialize resolver
+      # @param base_dirs [String, Array<String>] Base directories to search
+      # @param schema_registry [Hash] Manual schema name => path mappings
+      # @param verbose [Boolean] Enable verbose logging
+      def initialize(base_dirs: Dir.pwd, schema_registry: {}, verbose: false)
+        @base_dirs = Array(base_dirs).map { |d| File.expand_path(d) }
+        @schema_registry = schema_registry || {}
+        @verbose = verbose
+        @resolved_schemas = Set.new
+        @resolution_stack = []
+        @unresolved = []
+        @last_found_base_index = nil
+        @last_found_base_dir = nil
+        @multiple_matches = []
+      end
+
+      # Resolve all dependencies starting from root schema
+      # @param root_schema_path [String] Path to root schema file
+      # @return [Array<String>] Ordered list of schema file paths
+      def resolve_dependencies(root_schema_path)
+        @resolved_schemas.clear
+        @resolution_stack.clear
+        @unresolved.clear
+
+        resolve_recursive(File.expand_path(root_schema_path))
+        @resolved_schemas.to_a
+      end
+
+      # Extract interfaces from schema file using proper parsing
+      # @param schema_path [String] Path to schema file
+      # @return [Array<Hash>] List of interfaces with :kind, :schema_name
+      def extract_interfaces(schema_path)
+        interfaces = []
+
+        # Parse the schema file properly
+        repo = Expressir::Express::Parser.from_file(schema_path)
+
+        # Extract interfaces from first schema (file should contain one schema)
+        schema = repo.schemas.first
+        return interfaces unless schema&.interfaces
+
+        schema.interfaces.each do |interface|
+          kind = case interface.kind
+                 when Expressir::Model::Declarations::Interface::USE
+                   "USE"
+                 when Expressir::Model::Declarations::Interface::REFERENCE
+                   "REFERENCE"
+                 else
+                   interface.kind.first
+                 end
+
+          interfaces << {
+            kind: kind,
+            schema_name: interface.schema.id,
+          }
+        end
+
+        interfaces
+      end
+
+      # Resolve schema location
+      # @param schema_name [String] Schema name to find
+      # @param kind [String] Interface kind ("USE" or "REFERENCE")
+      # @param current_path [String] Path of schema requesting the reference
+      # @return [String, nil] Path to schema file, or nil if not found
+      def resolve_schema_location(schema_name, _kind, _current_path)
+        # Check schema_registry first
+        if @schema_registry[schema_name]
+          registry_path = File.expand_path(@schema_registry[schema_name])
+          return registry_path if File.exist?(registry_path)
+        end
+
+        # Search ONLY in base_dirs recursively and collect ALL matches
+        all_matches = []
+        @base_dirs.each_with_index do |base_dir, index|
+          candidate = find_schema_in_directory(schema_name, base_dir)
+          if candidate
+            all_matches << { path: candidate, base_dir: base_dir, index: index }
+          end
+        end
+
+        # If no matches found, return nil
+        return nil if all_matches.empty?
+
+        # If multiple matches found, record for warning
+        if all_matches.size > 1
+          @multiple_matches << {
+            schema_name: schema_name,
+            matches: all_matches,
+          }
+        end
+
+        # Use the first match
+        first_match = all_matches.first
+        @last_found_base_index = first_match[:index]
+        @last_found_base_dir = first_match[:base_dir]
+
+        first_match[:path]
+      end
+
+      # Get resolution statistics
+      # @return [Hash] Statistics about resolved schemas
+      def statistics
+        {
+          total_schemas: @resolved_schemas.size,
+          schemas: @resolved_schemas.to_a,
+          base_dirs: @base_dirs,
+          multiple_matches: @multiple_matches,
+        }
+      end
+
+      private
+
+      # Resolve schema and its dependencies recursively
+      # @param schema_path [String] Path to schema file
+      # @return [void]
+      def resolve_recursive(schema_path)
+        return if @resolved_schemas.include?(schema_path)
+
+        # Check for circular dependency - schema-level circular references are valid in EXPRESS
+        if @resolution_stack.include?(schema_path)
+          # Schema is already being processed - this is a back-reference
+          # Skip re-processing; the schema will be added to resolved_schemas when its original pass completes
+          return
+        end
+
+        @resolution_stack.push(schema_path)
+
+        # Extract and resolve interfaces
+        interfaces = extract_interfaces(schema_path)
+        interfaces.each do |interface|
+          if @verbose
+            schema_name = File.basename(schema_path, ".*")
+            print "  #{interface[:kind]} FROM #{interface[:schema_name]} (in #{schema_name}): "
+          end
+
+          dep_path = resolve_schema_location(
+            interface[:schema_name],
+            interface[:kind],
+            schema_path,
+          )
+
+          if dep_path
+            if @verbose
+              # Show which source and relative path
+              if @last_found_base_dir && @last_found_base_index
+                relative_path = dep_path.sub("#{@last_found_base_dir}/", "")
+                source_label = "[source #{@last_found_base_index + 1}]"
+                puts "\e[32m✓\e[0m #{source_label} #{relative_path}"
+              else
+                relative_path = File.basename(dep_path)
+                puts "\e[32m✓\e[0m #{relative_path}"
+              end
+            end
+            resolve_recursive(dep_path)
+          else
+            # Track unresolved reference
+            @unresolved << {
+              from: schema_path,
+              kind: interface[:kind],
+              schema_name: interface[:schema_name],
+            }
+
+            if @verbose
+              puts "\e[31m✗ not found\e[0m"
+            end
+          end
+        end
+
+        @resolution_stack.pop
+        @resolved_schemas.add(schema_path)
+      end
+
+      # Find schema file in directory
+      # @param schema_name [String] Schema name to find
+      # @param directory [String] Directory to search
+      # @param recursive [Boolean] Whether to search subdirectories
+      # @return [String, nil] Path to schema file or nil
+      def find_schema_in_directory(schema_name, directory)
+        return nil unless File.directory?(directory)
+
+        # Try direct match first (resource pattern: schema_name.exp)
+        candidate = File.join(directory, "#{schema_name}.exp")
+        return File.expand_path(candidate) if File.exist?(candidate)
+
+        # Try module pattern: {lower-case-prefix-without-_schema}/{arm|mim}.exp
+        # Examples:
+        #   Activity_method_mim -> activity_method/mim.exp
+        #   Activity_method_arm -> activity_method/arm.exp
+        module_path = try_module_pattern(schema_name, directory)
+        return module_path if module_path
+
+        # Search recursively in subdirectories
+        # Only in base_dirs to avoid permission errors in system directories
+        begin
+          # First try direct name match
+          Dir.glob(File.join(directory, "**",
+                             "#{schema_name}.exp")).each do |file|
+            return File.expand_path(file)
+          end
+
+          # Also try module pattern recursively for _arm/_mim schemas
+          if schema_name =~ /^(.+)_(arm|mim)$/i
+            prefix = Regexp.last_match(1)
+            suffix = Regexp.last_match(2).downcase
+            prefix = prefix.sub(/_schema$/i, "")
+            module_dir = prefix.downcase
+
+            # Search for **/module_dir/suffix.exp pattern
+            Dir.glob(File.join(directory, "**", module_dir,
+                               "#{suffix}.exp")).each do |file|
+              return File.expand_path(file)
+            end
+          end
+        rescue Errno::EACCES, Errno::EPERM
+          # Ignore permission errors when searching directories
+          nil
+        end
+
+        nil
+      end
+
+      # Try module naming pattern
+      # @param schema_name [String] Schema name (e.g., "Activity_method_mim")
+      # @param directory [String] Base directory
+      # @return [String, nil] Path if found, nil otherwise
+      def try_module_pattern(schema_name, directory)
+        # Check if schema name ends with _arm or _mim
+        if schema_name =~ /^(.+)_(arm|mim)$/i
+          prefix = Regexp.last_match(1)
+          suffix = Regexp.last_match(2).downcase
+
+          # Remove trailing _schema if present
+          prefix = prefix.sub(/_schema$/i, "")
+
+          # Convert to lowercase and replace underscores
+          module_dir = prefix.downcase
+
+          # Try: directory/module_dir/suffix.exp
+          candidate = File.join(directory, module_dir, "#{suffix}.exp")
+          return File.expand_path(candidate) if File.exist?(candidate)
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/expressir/model/exp_file.rb

@@ -0,0 +1,42 @@
+# 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 HasId
+      include ScopeContainer
+
+      collection_attributes :schemas
+
+      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

@@ -0,0 +1,18 @@
+module Expressir
+  module Model
+    module Expressions
+      # Specified in ISO 10303-11:2004
+      # - section 12.9 Aggregate initializer
+      class AggregateInitializer < ModelElement
+        child_attributes :items
+        attribute :items, ModelElement, collection: true
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "items", to: :items
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Expressir
+  module Model
+    module Expressions
+      # Specified in ISO 10303-11:2004
+      # - section 12.9 Aggregate initializer
+      class AggregateInitializerItem < ModelElement
+        child_attributes :expression, :repetition
+        attribute :expression, ModelElement
+        attribute :repetition, ModelElement
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "expression", to: :expression
+          map "repetition", to: :repetition
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module Expressir
+  module Model
+    module Expressions
+      # Specified in ISO 10303-11:2004
+      # - section 12.1 Arithmetic operators
+      # - section 12.2 Relational operators
+      # - section 12.3 Binary operators
+      # - section 12.4 Logical operators
+      # - section 12.5 String operators
+      # - section 12.6 Aggregate operators
+      # - section 12.10 Complex entity instance construction operator
+      class BinaryExpression < ModelElement
+        child_attributes :operand1, :operand2
+        ADDITION = "ADDITION".freeze
+        AND = "AND".freeze
+        COMBINE = "COMBINE".freeze
+        EQUAL = "EQUAL".freeze
+        EXPONENTIATION = "EXPONENTIATION".freeze
+        GREATER_THAN = "GREATER_THAN".freeze
+        GREATER_THAN_OR_EQUAL = "GREATER_THAN_OR_EQUAL".freeze
+        IN = "IN".freeze
+        INSTANCE_EQUAL = "INSTANCE_EQUAL".freeze
+        INSTANCE_NOT_EQUAL = "INSTANCE_NOT_EQUAL".freeze
+        INTEGER_DIVISION = "INTEGER_DIVISION".freeze
+        LESS_THAN = "LESS_THAN".freeze
+        LESS_THAN_OR_EQUAL = "LESS_THAN_OR_EQUAL".freeze
+        LIKE = "LIKE".freeze
+        MODULO = "MODULO".freeze
+        MULTIPLICATION = "MULTIPLICATION".freeze
+        NOT_EQUAL = "NOT_EQUAL".freeze
+        OR = "OR".freeze
+        REAL_DIVISION = "REAL_DIVISION".freeze
+        SUBTRACTION = "SUBTRACTION".freeze
+        XOR = "XOR".freeze
+
+        attribute :operator, :string,
+                  values: %w[
+                    ADDITION AND COMBINE EQUAL EXPONENTIATION
+                    GREATER_THAN
+                    GREATER_THAN_OR_EQUAL IN INSTANCE_EQUAL
+                    INSTANCE_NOT_EQUAL
+                    INTEGER_DIVISION LESS_THAN LESS_THAN_OR_EQUAL LIKE
+                    MODULO MULTIPLICATION NOT_EQUAL OR REAL_DIVISION
+                    SUBTRACTION XOR
+                  ]
+        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/expressions/entity_constructor.rb

@@ -0,0 +1,20 @@
+module Expressir
+  module Model
+    module Expressions
+      # Specified in ISO 10303-11:2004
+      # - section 9.2.6 Implicit declarations
+      class EntityConstructor < ModelElement
+        child_attributes :parameters
+        attribute :entity, ModelElement
+        attribute :parameters, ModelElement, collection: true
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "entity", to: :entity
+          map "parameters", to: :parameters
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Expressir
+  module Model
+    module Expressions
+      # Specified in ISO 10303-11:2004
+      # - section 12.8 Function call
+      class FunctionCall < ModelElement
+        child_attributes :parameters
+        attribute :function, ModelElement
+        attribute :parameters, ModelElement, collection: true
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "function", to: :function
+          map "parameters", to: :parameters
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Expressir
+  module Model
+    module Expressions
+      # Specified in ISO 10303-11:2004
+      # - section 12.2.4 Interval expressions
+      class Interval < ModelElement
+        child_attributes :low, :item, :high
+        LESS_THAN = "LESS_THAN".freeze
+        LESS_THAN_OR_EQUAL = "LESS_THAN_OR_EQUAL".freeze
+
+        attribute :low, ModelElement
+        attribute :operator1, :string, values: %w[LESS_THAN LESS_THAN_OR_EQUAL]
+        attribute :item, ModelElement
+        attribute :operator2, :string, values: %w[LESS_THAN LESS_THAN_OR_EQUAL]
+        attribute :high, ModelElement
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "low", to: :low
+          map "operator1", to: :operator1
+          map "item", to: :item
+          map "operator2", to: :operator2
+          map "high", to: :high
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+module Expressir
+  module Model
+    module Expressions
+      # Specified in ISO 10303-11:2004
+      # - section 12.6.7 Query expression
+      class QueryExpression < ModelElement
+        include Identifier
+
+        child_attributes :expression, :aggregate_source
+
+        attribute :aggregate_source, ModelElement
+        attribute :expression, ModelElement
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "aggregate_source", to: :aggregate_source
+          map "expression", to: :expression
+        end
+
+        # @return [Array<Declaration>]
+        def children
+          [
+            self,
+            *remark_items,
+          ]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Expressir
+  module Model
+    module Expressions
+      # Specified in ISO 10303-11:2004
+      # - section 12.1 Arithmetic operators
+      # - section 12.4.1 NOT operator
+      class UnaryExpression < ModelElement
+        child_attributes :operand
+        MINUS = "MINUS".freeze
+        NOT = "NOT".freeze
+        PLUS = "PLUS".freeze
+
+        attribute :operator, :string, values: %w[MINUS NOT PLUS]
+        attribute :operand, ModelElement
+        attribute :_class, :string, default: -> { self.class.name }
+
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "operator", to: :operator
+          map "operand", to: :operand
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Expressir
+  module Model
+    module Identifier
+      def self.included(mod)
+        # Auto-include markers - all Identifier types have id and can have remark_items and remarks
+        mod.include(HasId)
+        mod.include(HasRemarkItems)
+        mod.include(HasRemarks)
+
+        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.key_value do
+          map "id", to: :id
+          map "remarks", to: :remarks
+          map "remark_items", to: :remark_items
+          map "untagged_remarks", to: :untagged_remarks
+        end
+      end
+    end
+  end
+end

data/lib/expressir/model/indexes/entity_index.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Model
+    module Indexes
+      # Index for fast entity lookup across schemas
+      # Maintains indexes by qualified name and by schema for efficient querying
+      class EntityIndex
+        attr_reader :by_schema, :by_qualified_name
+
+        # Initialize a new entity index
+        # @param schemas [Array<Declarations::Schema>] Schemas to index
+        def initialize(schemas = [])
+          @by_schema = {}
+          @by_qualified_name = {}
+          build(schemas) unless schemas.empty?
+        end
+
+        # Build indexes from schemas
+        # @param schemas [Array<Declarations::Schema>] Schemas to index
+        # @return [void]
+        def build(schemas)
+          @by_schema = {}
+          @by_qualified_name = {}
+
+          schemas.each do |schema|
+            schema_id = schema.id.safe_downcase
+            @by_schema[schema_id] = {}
+
+            next unless schema.entities
+
+            schema.entities.each do |entity|
+              entity_id = entity.id.safe_downcase
+              qualified_name = "#{schema_id}.#{entity_id}"
+
+              @by_schema[schema_id][entity_id] = entity
+              @by_qualified_name[qualified_name] = entity
+            end
+          end
+        end
+
+        # Find entity by qualified name
+        # @param qualified_name [String] Entity qualified name (e.g., "schema.entity")
+        # @return [Declarations::Entity, nil] Found entity or nil
+        def find(qualified_name)
+          return nil if qualified_name.nil? || qualified_name.empty?
+
+          normalized_name = qualified_name.safe_downcase
+
+          # Try qualified name first
+          entity = @by_qualified_name[normalized_name]
+          return entity if entity
+
+          # Try as simple name across all schemas
+          schema_name, entity_name = normalized_name.split(".", 2)
+          if entity_name.nil?
+            # Search all schemas for simple name
+            @by_schema.each_value do |entities|
+              entity = entities[schema_name]
+              return entity if entity
+            end
+          else
+            # Look in specific schema
+            schema_entities = @by_schema[schema_name]
+            return schema_entities[entity_name] if schema_entities
+          end
+
+          nil
+        end
+
+        # List all entities
+        # @param schema [String, nil] Filter by schema name
+        # @return [Array<Declarations::Entity>] List of entities
+        def list(schema: nil)
+          if schema
+            @by_schema[schema.safe_downcase]&.values || []
+          else
+            @by_qualified_name.values
+          end
+        end
+
+        # Check if index is empty
+        # @return [Boolean] True if no entities indexed
+        def empty?
+          @by_qualified_name.empty?
+        end
+
+        # Count total entities
+        # @return [Integer] Total number of entities
+        def count
+          @by_qualified_name.size
+        end
+
+        # Get entities for a specific schema
+        # @param schema [String] Schema name
+        # @return [Hash<String, Declarations::Entity>] Entities in schema
+        def schema_entities(schema)
+          @by_schema[schema.safe_downcase] || {}
+        end
+      end
+    end
+  end
+end