expressir 2.4.29-arm-linux-musl

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

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Model
+    module Indexes
+      # Item-level graph over a resolved repository: nodes are schema
+      # items (canonical "schema.item" paths), edges are inheritance,
+      # interface imports, and attribute-type references.
+      #
+      # {Model::ModelElement#path} is file-qualified and empty for
+      # id-less nodes, so node identity is the last two path segments —
+      # unique because schema names are unique within a repository.
+      class ItemGraph
+        attr_reader :nodes, :subtype_of, :dependencies
+
+        # @param repository [Repository] a resolved repository
+        def initialize(repository)
+          @nodes = {}
+          @subtype_of = Hash.new { |h, k| h[k] = [] }
+          @dependencies = Hash.new { |h, k| h[k] = [] }
+          build(repository)
+        end
+
+        # Plain tables for artifact persistence — node keys only, no
+        # model references. `ItemGraph.from_tables` is the zero-model
+        # counterpart used on warm loads.
+        def tables
+          {
+            "nodes" => @nodes.keys,
+            "subtype_of" => @subtype_of.reject { |_, parents| parents.empty? },
+            "dependencies" => @dependencies.reject { |_, deps| deps.empty? },
+          }
+        end
+
+        def self.from_tables(tables)
+          graph = allocate
+          graph.instance_variable_set(:@nodes, tables["nodes"].to_h { |k| [k, nil] })
+          graph.instance_variable_set(
+            :@subtype_of,
+            Hash.new { |h, k| h[k] = [] }.update(tables["subtype_of"] || {}),
+          )
+          graph.instance_variable_set(
+            :@dependencies,
+            Hash.new { |h, k| h[k] = [] }.update(tables["dependencies"] || {}),
+          )
+          graph
+        end
+
+        def include?(path)
+          @nodes.key?(canonical(path))
+        end
+
+        # Transitive supertype closure of an entity, breadth-first.
+        def supertypes(path)
+          key = canonical(path)
+          return [] unless @nodes.key?(key)
+
+          seen = {}
+          result = []
+          queue = @subtype_of[key].dup
+          until queue.empty?
+            current = queue.shift
+            next if seen[current]
+
+            seen[current] = true
+            result << current
+            queue.concat(@subtype_of[current])
+          end
+          result
+        end
+
+        # Schemas whose items `schema` imports (USE FROM / REFERENCE
+        # FROM), direct only. Accepts a schema object or its id.
+        def dependencies_of(schema)
+          schema_id = schema.respond_to?(:id) ? schema.id : schema.to_s
+          @dependencies[schema_id.safe_downcase].dup
+        end
+
+        def subtype_edges
+          @subtype_of.flat_map { |child, parents| parents.map { |p| [child, p] } }
+        end
+
+        # Direct subtypes of an entity (the inverse of subtype_of).
+        def subtypes(path)
+          key = canonical(path)
+          return [] unless @nodes.key?(key)
+
+          @subtype_of.select { |_child, parents| parents.include?(key) }.keys
+        end
+
+        # Transitive subtype closure of an entity (everything below it
+        # in the hierarchy), breadth-first and cycle-safe.
+        def transitive_subtypes(path)
+          key = canonical(path)
+          return [] unless @nodes.key?(key)
+
+          seen = {}
+          queue = subtypes(key)
+          until queue.empty?
+            current = queue.shift
+            next if seen[current]
+
+            seen[current] = true
+            queue.concat(subtypes(current))
+          end
+          seen.keys
+        end
+
+        # Transitive interface closure of a schema — every schema it
+        # depends on, directly or through intermediates. Cycle-safe.
+        def dependency_closure(schema)
+          schema_id = schema.respond_to?(:id) ? schema.id : schema.to_s
+          seen = {}
+          queue = dependencies_of(schema_id).dup
+          until queue.empty?
+            current = queue.shift
+            next if seen[current]
+
+            seen[current] = true
+            queue.concat(@dependencies[current] || [])
+          end
+          seen.keys
+        end
+
+        # Schemas that import `schema` (USE FROM / REFERENCE FROM it),
+        # direct only — the "used by" direction for doc generation.
+        def dependents_of(schema)
+          schema_id = schema.respond_to?(:id) ? schema.id : schema.to_s
+          key = schema_id.safe_downcase
+          @dependencies.select { |_from, deps| deps.include?(key) }.keys
+        end
+
+        def cross_schema_subtype_edges
+          subtype_edges.count { |child, parent| child.split(".")[0] != parent.split(".")[0] }
+        end
+
+        private
+
+        def canonical(path)
+          return nil unless path
+
+          parts = path.to_s.split(".")
+          return nil if parts.size < 2
+
+          parts[-2, 2].join(".").safe_downcase
+        end
+
+        def build(repository)
+          # Nodes register before their subtype edges: subtype references
+          # may be unresolved (the declaring schema is not in the
+          # repository), and an edge to a node that does not exist would
+          # surface as a phantom path in supertype closures.
+          edges = []
+          repository.schemas.each do |schema|
+            schema_id = schema.id.safe_downcase
+            schema.entities.to_a.each do |entity|
+              key = node_key(schema_id, entity)
+              @nodes[key] = entity
+              edges << [key, schema_id, entity]
+            end
+            schema.types.to_a.each do |type|
+              @nodes[node_key(schema_id, type)] = type
+            end
+            schema.interfaces.to_a.each do |interface|
+              target = interface.schema.is_a?(String) ? interface.schema : interface.schema&.id
+              next unless target
+
+              @dependencies[schema_id] << target.safe_downcase
+            end
+          end
+          edges.each do |key, schema_id, entity|
+            entity.subtype_of.to_a.each do |ref|
+              parent = ref.base_path ? canonical(ref.base_path) : "#{schema_id}.#{ref.id.safe_downcase}"
+              @subtype_of[key] << parent if parent && @nodes.key?(parent)
+            end
+          end
+        end
+
+        def node_key(schema_id, element)
+          canonical(element.path) || "#{schema_id}.#{element.id.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

data/lib/expressir/model/indexes.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Model
+    module Indexes
+      autoload :EntityIndex, "#{__dir__}/indexes/entity_index"
+      autoload :TypeIndex, "#{__dir__}/indexes/type_index"
+      autoload :ReferenceIndex, "#{__dir__}/indexes/reference_index"
+      autoload :ItemGraph, "#{__dir__}/indexes/item_graph"
+    end
+  end
+end