suma 0.5.7 → 0.5.8

data/lib/suma/closure_validator.rb

@@ -0,0 +1,317 @@
+# frozen_string_literal: true
+
+require "expressir"
+# Expressir::SchemaManifest references Pathname without requiring it
+# (expressir upstream gap); load it before any manifest parsing.
+require "pathname"
+
+module Suma
+  # S1 referential closure: extracts every EXPRESS-internal reference from
+  # a schema collection and resolves it against the {CorpusGraph}.
+  #
+  # Reference classes covered (one predicate, many extractors):
+  # attribute domains, SELECT/AGGREGATE branches, where-rule expressions,
+  # subtype constraints, supertype/subtype lists, rule applies-to targets,
+  # and inter-schema interfaces.
+  #
+  # A reference resolves against, in order: the enclosing schema's declared
+  # elements, elements of schemas it interfaces to, the enclosing entity's
+  # own attributes (for entity-scoped expressions), the enclosing rule's
+  # applies-to attributes and variables, and the EXPRESS builtin vocabulary.
+  #
+  # The predicate is zero-tolerance: any unresolved reference is a
+  # violation, and `violations.empty?` is the corpus well-formedness gate.
+  class ClosureValidator
+    UnresolvedReference = Struct.new(:file, :line, :schema_id, :owner_id,
+                                     :kind, :reference, :reason,
+                                     keyword_init: true)
+
+    # Attributes that hold resolved links rather than syntactic children.
+    # Traversing them would walk the whole resolved graph (and its cycles)
+    # instead of the expression/type tree.
+    RESOLUTION_LINK_ATTRIBUTES = %i[ref entity].freeze
+
+    BUILTIN_IDENTIFIERS = %w[
+      abs acos asin atan atan2 bexists blength const_e cos exists exp
+      format hibound hiindex length lobound loindex log log2 log10 nvl odd
+      roles_of sin sizeof sqrt tan typeof usedin value value_in
+      value_range value_list_by unique
+      self and or xor not in like equal instanceof
+      e pi
+    ].freeze
+
+    attr_reader :graph
+
+    # @param graph [CorpusGraph]
+    def initialize(graph)
+      @graph = graph
+      @source_lines = {}
+    end
+
+    # Validate every schema of the manifest.
+    #
+    # @param manifest_file [String] schema manifest path
+    # @return [Array<UnresolvedReference>]
+    def validate_manifest(manifest_file)
+      manifest = Expressir::SchemaManifest.from_file(
+        File.expand_path(manifest_file),
+      )
+      manifest.schemas.flat_map do |entry|
+        repo = Expressir::Express::Parser.from_file(entry.path.to_s)
+        repo.schemas.flat_map do |schema|
+          validate_schema(entry.path.to_s, schema)
+        end
+      end
+    end
+
+    # All unresolved references in one schema.
+    #
+    # @param file [String] source file path (for diagnostics)
+    # @param schema [Expressir::Model::Declarations::Schema]
+    # @return [Array<UnresolvedReference>]
+    def validate_schema(file, schema)
+      violations = []
+      scope = SchemaScope.new(schema, graph)
+
+      schema.interfaces.each do |interface|
+        next if graph.schema_exists?(interface.schema.id)
+
+        violations << unresolved(file, schema.id, schema.id, "interface",
+                                 interface.schema.id,
+                                 "interface target not declared")
+      end
+
+      schema.children.each do |owner|
+        violations.concat(declared_element_references(file, schema.id, owner,
+                                                      scope))
+      end
+      violations
+    end
+
+    private
+
+    # Type- and structure-position references of one declared element.
+    def declared_element_references(file, schema_id, owner, scope)
+      refs = typed_references(owner)
+      refs.filter_map do |(kind, identifier)|
+        if resolvable?(identifier, scope)
+          nil
+        else
+          unresolved(
+            file, schema_id, owner_id_of(owner), kind, identifier,
+            "'#{identifier}' is not declared in this schema, its " \
+            "interfaces, or the EXPRESS builtins"
+          )
+        end
+      end
+    end
+
+    # (kind, identifier) pairs from every position of one declaration.
+    def typed_references(owner)
+      case owner
+      when Expressir::Model::Declarations::Entity then entity_references(owner)
+      when Expressir::Model::Declarations::Type then type_references(owner)
+      when Expressir::Model::Declarations::Rule then rule_references(owner)
+      when Expressir::Model::Declarations::Constant
+        datatype_references(owner.type, "constant")
+      when Expressir::Model::Declarations::Function
+        function_references(owner)
+      when Expressir::Model::Declarations::SubtypeConstraint
+        subtype_constraint_references(owner)
+      else []
+      end
+    end
+
+    def entity_references(entity)
+      refs = (entity.where_rules || []).flat_map do |rule|
+        expression_references(rule.expression, "where")
+      end
+      entity.attributes.each do |attribute|
+        refs.concat(datatype_references(attribute.type, "attribute"))
+      end
+      refs.concat(supertype_references(entity))
+    end
+
+    def type_references(type)
+      refs = (type.where_rules || []).flat_map do |rule|
+        expression_references(rule.expression, "where")
+      end
+      refs.concat(datatype_references(type.underlying_type, "underlying"))
+    end
+
+    def rule_references(rule)
+      refs = rule.applies_to.map { |ref| ["rule_applies_to", ref.id] }
+      refs += (rule.where_rules || []).flat_map do |where|
+        expression_references(where.expression, "where")
+      end
+      refs += (rule.variables || []).flat_map do |variable|
+        datatype_references(variable.type, "variable")
+      end
+      refs
+    end
+
+    def function_references(function)
+      refs = (function.parameters || []).flat_map do |parameter|
+        datatype_references(parameter.type, "parameter")
+      end
+      if function.return_type
+        refs.concat(datatype_references(function.return_type, "return"))
+      end
+      refs
+    end
+
+    def subtype_constraint_references(constraint)
+      refs = []
+      refs << ["subtype_constraint", constraint.entity.id] if constraint.entity
+      refs.concat(supertype_references(constraint))
+    end
+
+    def supertype_references(owner)
+      refs = []
+      (owner.subtype_of || []).each do |ref|
+        refs << ["subtype_of", ref.id] if ref.respond_to?(:id) && ref.id
+      end
+      if owner.respond_to?(:supertype_expression) && owner.supertype_expression
+        refs.concat(expression_references(owner.supertype_expression,
+                                          "supertype"))
+      end
+      refs
+    end
+
+    # (kind, identifier) pairs from a datatype or expression tree.
+    def datatype_references(node, kind)
+      expression_references(node, kind)
+    end
+
+    def expression_references(node, kind)
+      refs = []
+      walk(node) do |child|
+        refs << [kind, child.id] if simple_reference?(child)
+      end
+      refs
+    end
+
+    def simple_reference?(node)
+      node.is_a?(Expressir::Model::References::SimpleReference) &&
+        !node.id.nil?
+    end
+
+    # Depth-first walk over the syntactic tree of a model element.
+    # Expressir only implements `children` on some classes, so traversal
+    # goes through the lutaml-model attribute definitions: every attribute
+    # whose value is a ModelElement (or a collection of them) is a child.
+    # The model graph has reference cycles, so visited nodes are tracked
+    # by identity.
+    def walk(node, seen = {}.compare_by_identity, &block)
+      return unless node.is_a?(Expressir::Model::ModelElement)
+      return if seen.key?(node)
+
+      seen[node] = true
+      yield node
+      each_model_child(node) { |child| walk(child, seen, &block) }
+    end
+
+    def each_model_child(node)
+      node.class.attributes.each_key do |name|
+        next if RESOLUTION_LINK_ATTRIBUTES.include?(name)
+
+        value = begin
+          node.public_send(name)
+        rescue StandardError
+          next
+        end
+        values = value.is_a?(Array) ? value : [value]
+        values.each do |child|
+          yield child if child.is_a?(Expressir::Model::ModelElement)
+        end
+      end
+    end
+
+    # A reference resolves when its root identifier is declared in the
+    # schema, visible through an interface, or is an EXPRESS builtin.
+    def resolvable?(identifier, scope)
+      root = identifier.split(".").first.downcase
+      return true if BUILTIN_IDENTIFIERS.include?(root)
+
+      scope.visible?(root)
+    end
+
+    def unresolved(file, schema_id, owner_id, kind, reference, reason)
+      UnresolvedReference.new(
+        file: file,
+        line: approximate_line(file, reference),
+        schema_id: schema_id,
+        owner_id: owner_id,
+        kind: kind,
+        reference: reference,
+        reason: reason,
+      )
+    end
+
+    # Expressir's Ruby model carries no source positions, so diagnostics
+    # approximate the line by the first token occurrence in the file.
+    def approximate_line(file, identifier)
+      lines = (@source_lines[file] ||= read_source(file))
+      token = identifier.split(".").first
+      pattern = /\b#{Regexp.escape(token)}\b/i
+      index = lines.index { |line| line.match?(pattern) }
+      index ? index + 1 : nil
+    end
+
+    def read_source(file)
+      File.readlines(file)
+    rescue StandardError
+      []
+    end
+
+    def owner_id_of(owner)
+      owner.respond_to?(:id) && owner.id ? owner.id : "(anonymous)"
+    end
+
+    # Names visible for expression resolution inside one schema: declared
+    # elements, the attributes of every entity, rule applies-to entity
+    # attributes, rule variables, constants, and function parameters.
+    # Only declarations are collected — expression contents are the very
+    # references being validated and must never enter the scope.
+    class SchemaScope
+      def initialize(schema, graph)
+        @names = {}
+        @graph = graph
+        @schema_id = schema.id
+
+        schema.children.each { |declaration| add(declaration) }
+        schema.entities.each do |entity|
+          entity.attributes.each { |attribute| add(attribute) }
+        end
+        schema.rules.each do |rule|
+          rule.variables.each { |variable| add(variable) }
+          rule.applies_to.each do |ref|
+            entity = schema.entities.find do |candidate|
+              candidate.id&.downcase == ref.id&.downcase
+            end
+            next unless entity
+
+            entity.attributes.each { |attribute| add(attribute) }
+          end
+        end
+        schema.constants.each { |constant| add(constant) }
+        schema.functions.each do |function|
+          (function.parameters || []).each { |parameter| add(parameter) }
+        end
+      end
+
+      def visible?(name)
+        @names[name.downcase] ||
+          @graph.element_visible?(@schema_id, name)
+      end
+
+      private
+
+      def add(node)
+        return unless node.respond_to?(:id) && node.id
+
+        @names[node.id.downcase] = true
+      end
+    end
+  end
+end

data/lib/suma/corpus_graph.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "expressir"
+# Expressir::SchemaManifest references Pathname without requiring it
+# (expressir upstream gap); load it before any manifest parsing.
+require "pathname"
+
+module Suma
+  # The declared-element graph of a schema collection: which schemas exist,
+  # which elements each declares, and which schemas interface to which.
+  #
+  # This is the resolution substrate for S1 referential closure and, later,
+  # change-impact analysis (S3) and dependency-driven builds (S6). Nodes are
+  # schemas and their declared elements; edges are USE/REFERENCE interfaces.
+  class CorpusGraph
+    attr_reader :schema_ids
+
+    def initialize(repositories)
+      @schemas = {}
+      @elements = {}
+      @interfaces = {}
+
+      repositories.each do |repo|
+        repo.schemas.each { |schema| add_schema(schema) }
+      end
+      @schema_ids = @schemas.keys
+      freeze
+    end
+
+    # Parse every schema in a manifest and build the graph.
+    #
+    # @param manifest_file [String] path to the schema manifest
+    # @return [CorpusGraph]
+    def self.from_manifest(manifest_file)
+      manifest = Expressir::SchemaManifest.from_file(
+        File.expand_path(manifest_file),
+      )
+      repositories = manifest.schemas.map do |entry|
+        Expressir::Express::Parser.from_file(entry.path.to_s)
+      end
+      new(repositories)
+    end
+
+    # @param id [String]
+    # @return [Boolean]
+    def schema_exists?(id)
+      @schemas.key?(normalize(id))
+    end
+
+    # Does +schema_id+ (or a schema it interfaces to) declare +element_id+?
+    # EXPRESS resolves unqualified names against the local schema and
+    # implicitly-used schemas.
+    #
+    # @param schema_id [String]
+    # @param element_id [String]
+    # @return [Boolean]
+    def element_visible?(schema_id, element_id)
+      key = normalize(schema_id)
+      return false unless @elements.key?(key)
+
+      return true if @elements[key].key?(normalize(element_id))
+
+      visible_from_interfaces(key).include?(normalize(element_id))
+    end
+
+    # Schemas that +schema_id+ USEs FROM or REFERENCEs.
+    #
+    # @param schema_id [String]
+    # @return [Array<String>] normalized ids of interface targets
+    def interface_targets(schema_id)
+      @interfaces[normalize(schema_id)] || []
+    end
+
+    # Transitive interface closure: every schema +schema_id+ depends on,
+    # directly or through other schemas.
+    #
+    # @param schema_id [String]
+    # @return [Array<String>] normalized ids (excluding +schema_id+)
+    def dependency_closure(schema_id)
+      seen = {}
+      queue = interface_targets(schema_id).dup
+      until queue.empty?
+        id = queue.shift
+        next if seen.key?(id)
+
+        seen[id] = true
+        queue.concat(interface_targets(id))
+      end
+      seen.keys
+    end
+
+    # Schemas that transitively depend on +schema_id+ — the reverse of
+    # {#dependency_closure}; used by change-impact analysis (S3).
+    #
+    # @param schema_id [String]
+    # @return [Array<String>] normalized ids, sorted
+    def dependents_of(schema_id)
+      target = normalize(schema_id)
+      @schemas.keys
+        .reject { |candidate| candidate == target }
+        .select do |candidate|
+          dependency_closure(candidate).include?(target)
+        end
+        .sort
+    end
+
+    private
+
+    def add_schema(schema)
+      key = normalize(schema.id)
+      @schemas[key] = true
+      @elements[key] = declared_elements(schema)
+      targets = (schema.interfaces || [])
+        .filter_map { |i| i.schema&.id }
+        .map { |id| normalize(id) }
+        .uniq
+      @interfaces[key] = targets
+    end
+
+    def declared_elements(schema)
+      index = {}
+      schema.children.each do |element|
+        if element.respond_to?(:id) && element.id
+          index[normalize(element.id)] =
+            true
+        end
+      end
+      index
+    end
+
+    def visible_from_interfaces(key)
+      (@interfaces[key] || []).flat_map do |target|
+        @elements[target]&.keys || []
+      end
+    end
+
+    def normalize(id)
+      id&.downcase
+    end
+  end
+end

data/lib/suma/express_schema.rb

@@ -7,47 +7,34 @@ module Suma
   class ExpressSchema
     module Type
       RESOURCE              = :resource
+      APPLICATION_PROTOCOL  = :application_protocol
       MODULE_ARM            = :module_arm
       MODULE_MIM            = :module_mim
       BUSINESS_OBJECT_MODEL = :business_object_model
       CORE_MODEL            = :core_model
       STANDALONE            = :standalone
 
-      ID_SUFFIXES = {
-        "_arm" => :MODULE_ARM,
-        "_mim" => :MODULE_MIM,
-        "_bom" => :BUSINESS_OBJECT_MODEL,
-      }.freeze
-
-      PATH_SEGMENTS = {
-        "/resources/" => :RESOURCE,
-        "/modules/" => :MODULE_ARM,
-        "/core_model/" => :CORE_MODEL,
-      }.freeze
-
-      def self.classify(id:, path:)
-        name = id&.downcase || ""
-
-        ID_SUFFIXES.each do |suffix, type|
-          return const_get(type) if name.end_with?(suffix)
-        end
-
-        path_str = path.to_s
-        PATH_SEGMENTS.each do |segment, type|
-          return const_get(type) if path_str.include?(segment)
-        end
-
-        STANDALONE
+      # Classify a schema under a schema profile (default: ISO 10303).
+      #
+      # @param id [String, nil] schema identifier
+      # @param path [String, Pathname, nil] schema file path
+      # @param profile [SchemaProfile, Symbol, String, nil] schema profile
+      # @return [Symbol] a Type constant value
+      def self.classify(id:, path:, profile: nil)
+        SchemaProfile.fetch(profile).classify(id: id, path: path)
       end
     end
 
     attr_accessor :path, :id, :parsed, :output_path, :is_standalone_file
 
-    def initialize(id:, path:, output_path:, is_standalone_file: false)
+    def initialize(id:, path:, output_path:, is_standalone_file: false,
+                   profile: nil, cache: nil)
       @path = Pathname.new(path).expand_path
       @id = id
       @output_path = output_path
       @is_standalone_file = is_standalone_file
+      @profile = profile
+      @cache = cache
     end
 
     def type
@@ -57,7 +44,8 @@ module Suma
     def parsed
       return @parsed if @parsed
 
-      @parsed = Expressir::Express::Parser.from_file(@path.to_s)
+      source = File.read(@path.to_s, encoding: "UTF-8")
+      @parsed = @cache&.fetch_parsed(source) || parse_and_cache(source)
       Utils.log "Loaded EXPRESS schema: #{path}"
       @id = @parsed.schemas.first.id
       @parsed
@@ -98,8 +86,14 @@ module Suma
 
     private
 
+    def parse_and_cache(source)
+      repository = Expressir::Express::Parser.from_file(@path.to_s)
+      @cache&.store_parsed(source, repository)
+      repository
+    end
+
     def classify
-      Type.classify(id: @id, path: @path)
+      Type.classify(id: @id, path: @path, profile: @profile)
     end
   end
 end

data/lib/suma/null_cache.rb

@@ -7,5 +7,9 @@ module Suma
     def fetch(*, **) = nil
 
     def store(*, **) = nil
+
+    def fetch_parsed(*) = nil
+
+    def store_parsed(*, **) = nil
   end
 end