expressir 2.1.30 → 2.1.31

data/lib/expressir/model/dependency_resolver.rb

@@ -0,0 +1,270 @@
+# 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)
+        require_relative "../express/parser"
+
+        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/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

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

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Model
+    module Indexes
+      # Index for cross-schema reference tracking
+      # Maintains USE FROM, REFERENCE FROM relationships and dependency graphs
+      class ReferenceIndex
+        attr_reader :use_from, :reference_from, :dependencies
+
+        # Initialize a new reference index
+        # @param schemas [Array<Declarations::Schema>] Schemas to index
+        def initialize(schemas = [])
+          @use_from = {}
+          @reference_from = {}
+          @dependencies = {}
+          build(schemas) unless schemas.empty?
+        end
+
+        # Build indexes from schemas
+        # @param schemas [Array<Declarations::Schema>] Schemas to index
+        # @return [void]
+        def build(schemas)
+          @use_from = {}
+          @reference_from = {}
+          @dependencies = {}
+
+          schemas.each do |schema|
+            schema_id = schema.id.safe_downcase
+
+            # Initialize schema entries even if there are no interfaces
+            @use_from[schema_id] = []
+            @reference_from[schema_id] = []
+
+            next unless schema.interfaces
+
+            schema.interfaces.each do |interface|
+              referenced_schema = interface.schema.id.safe_downcase
+              items = interface.items.map { |item| item.ref.id }
+
+              if interface.kind == Declarations::Interface::USE
+                @use_from[schema_id] << {
+                  schema: referenced_schema,
+                  items: items,
+                }
+              elsif interface.kind == Declarations::Interface::REFERENCE
+                @reference_from[schema_id] << {
+                  schema: referenced_schema,
+                  items: items,
+                }
+              end
+
+              @dependencies[schema_id] ||= Set.new
+              @dependencies[schema_id] << referenced_schema
+            end
+          end
+        end
+
+        # Get USE FROM references for a schema
+        # @param schema [String] Schema name
+        # @return [Array<Hash>] List of USE FROM references
+        def use_references(schema)
+          @use_from[schema.safe_downcase] || []
+        end
+
+        # Get REFERENCE FROM references for a schema
+        # @param schema [String] Schema name
+        # @return [Array<Hash>] List of REFERENCE FROM references
+        def reference_references(schema)
+          @reference_from[schema.safe_downcase] || []
+        end
+
+        # Get all dependencies for a schema
+        # @param schema [String] Schema name
+        # @return [Set<String>] Set of dependent schema names
+        def schema_dependencies(schema)
+          @dependencies[schema.safe_downcase] || Set.new
+        end
+
+        # Detect circular dependencies in schema references
+        # @return [Array<Array<String>>] List of circular dependency cycles
+        def detect_circular_dependencies
+          cycles = []
+          visited = Set.new
+          rec_stack = Set.new
+
+          @dependencies.each_key do |schema_id|
+            next if visited.include?(schema_id)
+
+            path = []
+            detect_cycle(schema_id, visited, rec_stack, path, cycles)
+          end
+
+          cycles
+        end
+
+        # Check if index is empty
+        # @return [Boolean] True if no references indexed
+        def empty?
+          @dependencies.empty?
+        end
+
+        # Count total USE FROM references
+        # @return [Integer] Total USE FROM references
+        def use_from_count
+          @use_from.values.sum(&:size)
+        end
+
+        # Count total REFERENCE FROM references
+        # @return [Integer] Total REFERENCE FROM references
+        def reference_from_count
+          @reference_from.values.sum(&:size)
+        end
+
+        private
+
+        # Helper method for cycle detection using DFS
+        # @param node [String] Current schema node
+        # @param visited [Set] Set of visited nodes
+        # @param rec_stack [Set] Recursion stack for current path
+        # @param path [Array] Current path
+        # @param cycles [Array] Accumulated cycles
+        # @return [Boolean] True if cycle detected
+        def detect_cycle(node, visited, rec_stack, path, cycles)
+          visited << node
+          rec_stack << node
+          path << node
+
+          deps = @dependencies[node] || Set.new
+          deps.each do |dep|
+            if !visited.include?(dep)
+              return true if detect_cycle(dep, visited, rec_stack, path, cycles)
+            elsif rec_stack.include?(dep)
+              # Found a cycle
+              cycle_start = path.index(dep)
+              cycles << (path[cycle_start..] + [dep])
+              return true
+            end
+          end
+
+          path.pop
+          rec_stack.delete(node)
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Model
+    module Indexes
+      # Index for fast type lookup across schemas
+      # Maintains indexes by qualified name, by schema, and by category
+      class TypeIndex
+        attr_reader :by_schema, :by_qualified_name, :by_category
+
+        # Initialize a new type index
+        # @param schemas [Array<Declarations::Schema>] Schemas to index
+        def initialize(schemas = [])
+          @by_schema = {}
+          @by_qualified_name = {}
+          @by_category = {}
+          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 = {}
+          @by_category = {}
+
+          schemas.each do |schema|
+            schema_id = schema.id.safe_downcase
+            @by_schema[schema_id] = {}
+
+            next unless schema.types
+
+            schema.types.each do |type|
+              type_id = type.id.safe_downcase
+              qualified_name = "#{schema_id}.#{type_id}"
+              category = categorize(type)
+
+              @by_schema[schema_id][type_id] = type
+              @by_qualified_name[qualified_name] = type
+              @by_category[category] ||= []
+              @by_category[category] << type
+            end
+          end
+        end
+
+        # Find type by qualified name
+        # @param qualified_name [String] Type qualified name (e.g., "schema.type")
+        # @return [Declarations::Type, nil] Found type 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
+          type = @by_qualified_name[normalized_name]
+          return type if type
+
+          # Try as simple name across all schemas
+          schema_name, type_name = normalized_name.split(".", 2)
+          if type_name.nil?
+            # Search all schemas for simple name
+            @by_schema.each_value do |types|
+              type = types[schema_name]
+              return type if type
+            end
+          else
+            # Look in specific schema
+            schema_types = @by_schema[schema_name]
+            return schema_types[type_name] if schema_types
+          end
+
+          nil
+        end
+
+        # List all types
+        # @param schema [String, nil] Filter by schema name
+        # @param category [String, nil] Filter by category
+        # @return [Array<Declarations::Type>] List of types
+        def list(schema: nil, category: nil)
+          types = if schema
+                    @by_schema[schema.safe_downcase]&.values || []
+                  else
+                    @by_qualified_name.values
+                  end
+
+          types = filter_by_category(types, category) if category
+
+          types
+        end
+
+        # Check if index is empty
+        # @return [Boolean] True if no types indexed
+        def empty?
+          @by_qualified_name.empty?
+        end
+
+        # Count total types
+        # @return [Integer] Total number of types
+        def count
+          @by_qualified_name.size
+        end
+
+        # Get types for a specific schema
+        # @param schema [String] Schema name
+        # @return [Hash<String, Declarations::Type>] Types in schema
+        def schema_types(schema)
+          @by_schema[schema.safe_downcase] || {}
+        end
+
+        # Get types for a specific category
+        # @param category [String] Category name
+        # @return [Array<Declarations::Type>] Types in category
+        def category_types(category)
+          @by_category[category] || []
+        end
+
+        # Categorize type by its underlying type
+        # @param type [Declarations::Type] Type to categorize
+        # @return [String] Type category
+        def categorize(type)
+          return "defined" unless type.underlying_type
+
+          underlying = type.underlying_type
+
+          # Use explicit is_a? checks for test double compatibility
+          return "select" if underlying.is_a?(DataTypes::Select)
+          return "enumeration" if underlying.is_a?(DataTypes::Enumeration)
+          return "aggregate" if underlying.is_a?(DataTypes::Array) ||
+            underlying.is_a?(DataTypes::Bag) ||
+            underlying.is_a?(DataTypes::List) ||
+            underlying.is_a?(DataTypes::Set)
+
+          "defined"
+        end
+
+        private
+
+        # Filter types by category
+        # @param types [Array<Declarations::Type>] List of types
+        # @param category [String] Category to filter by
+        # @return [Array<Declarations::Type>] Filtered types
+        def filter_by_category(types, category)
+          types.select { |type| categorize(type) == category }
+        end
+      end
+    end
+  end
+end