expressir 1.2.10-aarch64-linux → 2.4.29-aarch64-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

@@ -3,17 +3,16 @@ module Expressir
     module Expressions
       # Specified in ISO 10303-11:2004
       # - section 12.9 Aggregate initializer
-      class AggregateInitializer < Expression
-        model_attr_accessor :items, 'Array<AggregateInitializerItem>'
+      class AggregateInitializer < ModelElement
+        child_attributes :items
+        attribute :items, ModelElement, collection: true
+        attribute :_class, :string, default: -> { self.class.name }
 
-        # @param [Hash] options
-        # @option options [Array<AggregateInitializerItem>] :items
-        def initialize(options = {})
-          @items = options[:items] || []
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "items", to: :items
         end
       end
     end
   end
-end
+end

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

@@ -3,20 +3,18 @@ module Expressir
     module Expressions
       # Specified in ISO 10303-11:2004
       # - section 12.9 Aggregate initializer
-      class AggregateInitializerItem < Expression
-        model_attr_accessor :expression, 'Expression'
-        model_attr_accessor :repetition, 'Expression'
+      class AggregateInitializerItem < ModelElement
+        child_attributes :expression, :repetition
+        attribute :expression, ModelElement
+        attribute :repetition, ModelElement
+        attribute :_class, :string, default: -> { self.class.name }
 
-        # @param [Hash] options
-        # @option options [Expression] :expression
-        # @option options [Expression] :repetition
-        def initialize(options = {})
-          @expression = options[:expression]
-          @repetition = options[:repetition]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "expression", to: :expression
+          map "repetition", to: :repetition
         end
       end
     end
   end
-end
+end

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

@@ -9,45 +9,51 @@ module Expressir
       # - section 12.5 String operators
       # - section 12.6 Aggregate operators
       # - section 12.10 Complex entity instance construction operator
-      class BinaryExpression < Expression
-        ADDITION = :ADDITION
-        AND = :AND
-        COMBINE = :COMBINE
-        EQUAL = :EQUAL
-        EXPONENTIATION = :EXPONENTIATION
-        GREATER_THAN = :GREATER_THAN
-        GREATER_THAN_OR_EQUAL = :GREATER_THAN_OR_EQUAL
-        IN = :IN
-        INSTANCE_EQUAL = :INSTANCE_EQUAL
-        INSTANCE_NOT_EQUAL = :INSTANCE_NOT_EQUAL
-        INTEGER_DIVISION = :INTEGER_DIVISION
-        LESS_THAN = :LESS_THAN
-        LESS_THAN_OR_EQUAL = :LESS_THAN_OR_EQUAL
-        LIKE = :LIKE
-        MODULO = :MODULO
-        MULTIPLICATION = :MULTIPLICATION
-        NOT_EQUAL = :NOT_EQUAL
-        OR = :OR
-        REAL_DIVISION = :REAL_DIVISION
-        SUBTRACTION = :SUBTRACTION
-        XOR = :XOR
+      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
 
-        model_attr_accessor :operator, ':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'
-        model_attr_accessor :operand1, 'Expression'
-        model_attr_accessor :operand2, 'Expression'
+        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 }
 
-        # @param [Hash] options
-        # @option options [: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] :operator
-        # @option options [Expression] :operand1
-        # @option options [Expression] :operand2
-        def initialize(options = {})
-          @operator = options[:operator]
-          @operand1 = options[:operand1]
-          @operand2 = options[:operand2]
-
-          super
+        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
+end

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

@@ -3,20 +3,18 @@ module Expressir
     module Expressions
       # Specified in ISO 10303-11:2004
       # - section 9.2.6 Implicit declarations
-      class EntityConstructor < Expression
-        model_attr_accessor :entity, 'Reference'
-        model_attr_accessor :parameters, 'Array<Expression>'
+      class EntityConstructor < ModelElement
+        child_attributes :parameters
+        attribute :entity, ModelElement
+        attribute :parameters, ModelElement, collection: true
+        attribute :_class, :string, default: -> { self.class.name }
 
-        # @param [Hash] options
-        # @option options [Reference] :entity
-        # @option options [Array<Expression>] :parameters
-        def initialize(options = {})
-          @entity = options[:entity]
-          @parameters = options[:parameters] || []
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "entity", to: :entity
+          map "parameters", to: :parameters
         end
       end
     end
   end
-end
+end

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

@@ -3,20 +3,18 @@ module Expressir
     module Expressions
       # Specified in ISO 10303-11:2004
       # - section 12.8 Function call
-      class FunctionCall < Expression
-        model_attr_accessor :function, 'Reference'
-        model_attr_accessor :parameters, 'Array<Expression>'
+      class FunctionCall < ModelElement
+        child_attributes :parameters
+        attribute :function, ModelElement
+        attribute :parameters, ModelElement, collection: true
+        attribute :_class, :string, default: -> { self.class.name }
 
-        # @param [Hash] options
-        # @option options [Reference] :function
-        # @option options [Array<Expression>] :parameters
-        def initialize(options = {})
-          @function = options[:function]
-          @parameters = options[:parameters] || []
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "function", to: :function
+          map "parameters", to: :parameters
         end
       end
     end
   end
-end
+end

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

@@ -3,32 +3,27 @@ module Expressir
     module Expressions
       # Specified in ISO 10303-11:2004
       # - section 12.2.4 Interval expressions
-      class Interval < Expression
-        LESS_THAN = :LESS_THAN
-        LESS_THAN_OR_EQUAL = :LESS_THAN_OR_EQUAL
+      class Interval < ModelElement
+        child_attributes :low, :item, :high
+        LESS_THAN = "LESS_THAN".freeze
+        LESS_THAN_OR_EQUAL = "LESS_THAN_OR_EQUAL".freeze
 
-        model_attr_accessor :low, 'Expression'
-        model_attr_accessor :operator1, ':LESS_THAN, :LESS_THAN_OR_EQUAL'
-        model_attr_accessor :item, 'Reference'
-        model_attr_accessor :operator2, ':LESS_THAN, :LESS_THAN_OR_EQUAL'
-        model_attr_accessor :high, 'Expression'
+        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 }
 
-        # @param [Hash] options
-        # @option options [Expression] :low
-        # @option options [:LESS_THAN, :LESS_THAN_OR_EQUAL] :operator1
-        # @option options [Reference] :item
-        # @option options [:LESS_THAN, :LESS_THAN_OR_EQUAL] :operator2
-        # @option options [Expression] :high
-        def initialize(options = {})
-          @low = options[:low]
-          @operator1 = options[:operator1]
-          @item = options[:item]
-          @operator2 = options[:operator2]
-          @high = options[:high]
-
-          super
+        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
+end

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

@@ -3,33 +3,29 @@ module Expressir
     module Expressions
       # Specified in ISO 10303-11:2004
       # - section 12.6.7 Query expression
-      class QueryExpression < Expression
+      class QueryExpression < ModelElement
         include Identifier
 
-        model_attr_accessor :aggregate_source, 'Reference'
-        model_attr_accessor :expression, 'Expression'
+        child_attributes :expression, :aggregate_source
 
-        # @param [Hash] options
-        # @option (see Identifier#initialize_identifier)
-        # @option options [Reference] :aggregace_source
-        # @option options [Expression] :expression
-        def initialize(options = {})
-          initialize_identifier(options)
+        attribute :aggregate_source, ModelElement
+        attribute :expression, ModelElement
+        attribute :_class, :string, default: -> { self.class.name }
 
-          @aggregate_source = options[:aggregate_source]
-          @expression = options[:expression]
-
-          super
+        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
+            *remark_items,
           ]
         end
       end
     end
   end
-end
+end

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

@@ -4,24 +4,22 @@ module Expressir
       # Specified in ISO 10303-11:2004
       # - section 12.1 Arithmetic operators
       # - section 12.4.1 NOT operator
-      class UnaryExpression < Expression
-        MINUS = :MINUS
-        NOT = :NOT
-        PLUS = :PLUS
+      class UnaryExpression < ModelElement
+        child_attributes :operand
+        MINUS = "MINUS".freeze
+        NOT = "NOT".freeze
+        PLUS = "PLUS".freeze
 
-        model_attr_accessor :operator, ':MINUS, :NOT, :PLUS'
-        model_attr_accessor :operand, 'Expression'
+        attribute :operator, :string, values: %w[MINUS NOT PLUS]
+        attribute :operand, ModelElement
+        attribute :_class, :string, default: -> { self.class.name }
 
-        # @param [Hash] options
-        # @option options [:MINUS, :NOT, :PLUS] :operator
-        # @option options [Expression] :operand
-        def initialize(options = {})
-          @operator = options[:operator]
-          @operand = options[:operand]
-
-          super
+        key_value do
+          map "_class", to: :_class, render_default: true
+          map "operator", to: :operator
+          map "operand", to: :operand
         end
       end
     end
   end
-end
+end