expressir 2.4.12 → 2.4.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 76901fb66e21e9752a5ba64f7b80c23e92a7fa54fac6df80ba221d46bee358e3
-  data.tar.gz: d02e64ac60b0b670f31f665e3834553e29dfd8abc9f7ff51c22bc33dbafcbe11
+  metadata.gz: e3cf38ff1a09f95805cc5a6dc8c074832e47eeb8ceb7e62c79f503d521d775ac
+  data.tar.gz: a308605c1d7c97d33f766d08e8262e6e2039104ff7362e36a0fa5bd8e3839ccf
 SHA512:
-  metadata.gz: c6c20c797b67efe96bf149207c2283b6e8ba3054e17feda55630fbccf92d337bdfc3322c0a77408262bf1066a60a30b2f137c5f2d4f5a62f78bcea69f818e567
-  data.tar.gz: 39f8f5f287a3d01df2f84cc3667afc00632de391415f9b6aad21538623f167330de9ea3b8857ebe25490d946113d7a85637b5884625ec445b52d3d4a2663b214
+  metadata.gz: 4c97b4d258e50604fba0bdc0365c3f8272d6944dc225755e6408c6b585324b917448134352a4ffb4da445ca21ef910858283931abef43625d0b4138c90ecf694
+  data.tar.gz: d268fd6aef2e11bdafe5f81845931e91742dcd33ff48f3a2f6bb0076a6f9bad440045609a501b81fcc2130fef6dcd565d972ebc6634861d0341f9efa2649b5b5

data/lib/expressir/commands/parity_inputs.rb

@@ -5,58 +5,92 @@ module Expressir
     # Common parser/discovery helpers shared by parity CLI commands
     # (expand, flatten, check) — they all need: list of files in the
     # interface closure of a root file, and the root schema parsed.
+    #
+    # Schema resolution order (per the ELF schema manifest directive):
+    #   1. `--manifest PATH` — an ELF schema manifest explicitly defines
+    #      where each schema lives; this is the primary mode.
+    #   2. `--stepmod DIR` — explicit opt-in to the STEPmod directory
+    #      convention (`schemas/**/<name>.exp`) as the fallback.
+    #   3. Otherwise the file's own directory is used; a lookup failure
+    #      warns and points at the two explicit modes.
     module ParityInputs
       module_function
 
-      # Resolve the transitive interface closure of +root_path+. Deps are
-      # looked up by schema name: first in the file's own directory, then
-      # across the enclosing STEPmod checkout (the nearest ancestor holding
-      # a `schemas/` directory, e.g. resources/ and modules/ trees).
+      # Resolve the transitive interface closure of +root_path+. The queue
+      # holds paths and `seen` guards by schema name: mutual USE FROM
+      # cycles must terminate (this loop once span rounds forever on them,
+      # re-reading the same files).
       def closure_paths(root_path, manifest: nil, stepmod: nil)
-        index = schema_index(root_path)
+        index = schema_index(root_path, manifest: manifest, stepmod: stepmod)
         seen = { File.basename(root_path, ".exp").downcase => root_path }
-        queue = [File.basename(root_path, ".exp").downcase]
+        missing = []
+        queue = [root_path]
         until queue.empty?
-          name = queue.shift
-          path = seen[name] || index[name]
-          next unless path
-          next if seen.key?(name) && seen[name] != root_path
+          closure_names(File.read(queue.shift)).each do |dep|
+            name = dep.downcase
+            next if seen.key?(name)
 
-          seen[name] = path
-          closure_names(File.read(path)).each { |d| queue << d.downcase }
+            path = index&.[](name)
+            unless path
+              missing << name
+              seen[name] = nil
+              next
+            end
+
+            seen[name] = path
+            queue << path
+          end
+        end
+        unless missing.empty?
+          warn "expressir: schema(s) not found: #{missing.uniq.join(', ')}" \
+               "#{resolver_hint(manifest, stepmod)}"
         end
-        seen.values.uniq
+        seen.values.compact.uniq
       end
 
-      # Schema-name → path map for the STEPmod checkout around +root_path+,
-      # built once per invocation. The index root is the nearest ancestor
-      # directory NAMED `schemas` (wg12-step layout:
-      # `schemas/modules/<module>/mim.exp`), and entries key on the schema
-      # name declared inside each file — module files are `arm.exp` /
-      # `mim.exp`, so basenames cannot be the key. Falls back to the file's
-      # own directory when there is no schemas/ ancestor.
-      def schema_index(root_path)
-        dir = File.dirname(File.expand_path(root_path))
-        until dir == "/" || File.basename(dir) == "schemas"
-          parent = File.dirname(dir)
-          break if parent == dir
+      def resolver_hint(manifest, stepmod)
+        if manifest
+          " (not in schema manifest #{manifest})"
+        elsif stepmod
+          " (not found under STEPmod root #{stepmod})"
+        else
+          " - provide --manifest PATH (ELF schema manifest) or " \
+            "--stepmod DIR to resolve them"
+        end
+      end
 
-          dir = parent
+      # Schema-name → path index from the ELF schema manifest.
+      def manifest_index(manifest_path)
+        manifest = Expressir::SchemaManifest.from_file(manifest_path)
+        manifest.schemas.to_h do |entry|
+          [entry.id.downcase, entry.path]
         end
-        return same_dir_index(root_path) unless File.basename(dir) == "schemas"
+      rescue StandardError => e
+        warn "expressir: could not load schema manifest #{manifest_path}: #{e.message}"
+        nil
+      end
 
-        @@indexes ||= {}
-        @@indexes[dir] ||= begin
-          h = {}
-          Find.find(dir) do |path|
-            next unless path.end_with?(".exp")
+      # Schema-name → path index over a STEPmod checkout root (the
+      # directory holding `schemas/`, or that directory itself).
+      def stepmod_index(stepmod_dir)
+        root = File.join(File.expand_path(stepmod_dir), "schemas")
+        root = File.expand_path(stepmod_dir) unless File.directory?(root)
+        h = {}
+        Find.find(root) do |path|
+          next unless path.end_with?(".exp")
 
-            declared = File.read(path)[/\bSCHEMA\s+(\w+)/i, 1]
-            h[declared.downcase] = path if declared
-            h[File.basename(path, ".exp").downcase] ||= path
-          end
-          h
+          declared = File.read(path)[/\bSCHEMA\s+(\w+)/i, 1]
+          h[declared.downcase] = path if declared
+          h[File.basename(path, ".exp").downcase] ||= path
         end
+        h
+      end
+
+      def schema_index(root_path, manifest: nil, stepmod: nil)
+        return manifest_index(manifest) if manifest
+        return stepmod_index(stepmod) if stepmod
+
+        same_dir_index(root_path)
       end
 
       def same_dir_index(root_path)
@@ -66,19 +100,26 @@ module Expressir
         end
       end
 
+      # Interface names declared by +source+. Remark text is stripped
+      # first: prose like "use from the main schema" must not spawn
+      # phantom dependencies.
       def closure_names(source)
-        source.scan(/\bUSE\s+FROM\s+(\w+)/i).flatten.uniq +
-          source.scan(/\bREFERENCE\s+FROM\s+(\w+)/i).flatten.uniq
+        code = source.gsub(/--[^\n]*/, "").gsub(/\(\*.*?\*\)/m, "")
+        code.scan(/\bUSE\s+FROM\s+(\w+)/i).flatten.uniq +
+          code.scan(/\bREFERENCE\s+FROM\s+(\w+)/i).flatten.uniq
       end
 
-      # manifest:/stepmod: are accepted for the ELF-manifest resolver
-      # contract; the directory-index fallback ignores them until that
-      # resolver lands.
       def root_schema(root_path, manifest: nil, stepmod: nil)
         name = File.read(root_path)[/\bSCHEMA\s+(\w+)/, 1]
-        cp = closure_paths(root_path)
-        repo = Expressir::Express::Parser.from_files(cp, max_processes: 1)
-        [repo.schemas.find { |s| s.id == name }, repo]
+        # skip_references: longform generation and checking run their own
+        # resolution; resolving every reference of a large closure here made
+        # flatten crawl (minutes vs seconds).
+        repo = Expressir::Express::Parser.from_files(
+          closure_paths(root_path, manifest: manifest, stepmod: stepmod),
+          skip_references: true,
+          max_processes: 1,
+        )
+        [repo.schemas.find { |s| s.id&.downcase == name&.downcase }, repo]
       end
     end
   end

data/lib/expressir/express/checker.rb

@@ -307,20 +307,32 @@ module Expressir
 
         Array(type.underlying_type.items).each do |item|
           next if item.id.nil?
-          next if find_type(schema, item.id)
-          next if find_entity(schema, item.id).nil? # unresolved handled elsewhere
+          next if select_item_resolves?(schema, item.id)
 
           note!(:check_select_named_type, :error, schema,
-                "TYPE #{type.id}: select item '#{item.id}' is an entity, " \
-                "not a named type", type)
+                "In the SELECT TYPE #{type.id}, '#{item.id}' does not " \
+                "name an existing TYPE or ENTITY", type)
         end
       end
 
       def find_type(schema, id)
         key = id.safe_downcase
-        return schema.types.find { |t| t.id.safe_downcase == key } if schema
+        schema.types.find { |t| t.id.safe_downcase == key }
+      end
+
+      # ISO 10303-11 rule 258: select_list items are named_types —
+      # entity_ref | type_ref. The item is fine when it names either,
+      # in this schema or any repository schema (interface-visible).
+      def select_item_resolves?(schema, id)
+        return true if find_entity(schema, id)
+        return true if schema.types.to_a.any? { |t| t.id.safe_downcase == id.safe_downcase }
 
-        nil
+        @by_name.each_value.any? do |group|
+          group.any? do |other|
+            other.types.to_a.any? { |t| t.id.safe_downcase == id.safe_downcase } ||
+              other.entities.to_a.any? { |e| e.id.safe_downcase == id.safe_downcase }
+          end
+        end
       end
 
       # eeng declared-kind probe: :type when a TYPE of that name is

data/lib/expressir/express/shtolo.rb

@@ -351,15 +351,22 @@ module Expressir
         end
       end
 
-      # Every identifier a FunctionCall site names, across the
-      # artifact's surviving declarations.
+      # Every identifier a call site names, across the artifact's
+      # surviving declarations: FunctionCall for functions and
+      # ProcedureCall statements for procedures. (A zero-argument
+      # function reference written bare is not represented as a
+      # FunctionCall by the parser and is counted via any SimpleReference
+      # miss — accepted v1 blind spot, see tranche notes.)
       def called_ids(schema)
         called = {}
         each_node(schema) do |node|
-          next unless node.is_a?(Model::Expressions::FunctionCall)
-
-          ref = node.function
-          id = ref.is_a?(String) ? ref : ref&.id
+          id = nil
+          case node
+          when Expressir::Model::Expressions::FunctionCall
+            id = node.function.is_a?(String) ? node.function : node.function&.id
+          when Expressir::Model::Statements::ProcedureCall
+            id = node.procedure.is_a?(String) ? node.procedure : node.procedure&.id
+          end
           called[id.safe_downcase] = true if id
         end
         called
@@ -392,19 +399,28 @@ module Expressir
       def reduce_supertype_expression(expr, visible_ids)
         case expr
         when Model::SupertypeExpressions::OneofSupertypeExpression
-          refs = Array(expr.operands).select do |ref|
-            id = ref.is_a?(String) ? ref : ref.id
-            id.nil? || visible_ids.key?(id.safe_downcase)
+          reduced = expr.operands.filter_map do |operand|
+            reduce_supertype_expression(operand, visible_ids)
           end
-          return nil if refs.empty?
+          return nil if reduced.empty?
 
-          refs.one? ? refs.first : reset_oneof(expr, refs)
+          reduced.one? ? reduced.first : reset_oneof(expr, reduced)
         when Model::SupertypeExpressions::BinarySupertypeExpression
-          left = reduce_supertype_expression(expr.operands[0], visible_ids)
-          right = reduce_supertype_expression(expr.operands[1], visible_ids)
-          return nil if left.nil? && right.nil?
+          left = reduce_supertype_expression(expr.operand1, visible_ids)
+          right = reduce_supertype_expression(expr.operand2, visible_ids)
+          if left.nil?
+            return right
+          end
+          if right.nil?
+            return left
+          end
+
+          rebuild_binary(expr, left, right)
+        when Model::References::SimpleReference
+          id = expr.id
+          return nil if id && !visible_ids.key?(id.safe_downcase)
 
-          left || right
+          expr
         else
           expr
         end
@@ -416,6 +432,13 @@ module Expressir
         copy
       end
 
+      def rebuild_binary(expr, left, right)
+        copy = deep_copy(expr)
+        copy.operand1 = left
+        copy.operand2 = right
+        copy
+      end
+
       def resolve_extensible_enumerations!(schema)
         schema.types.select do |t|
           t.underlying_type.is_a?(Model::DataTypes::Enumeration) && t.underlying_type.extensible

data/lib/expressir/version.rb

@@ -3,6 +3,6 @@ module Expressir
   # autoload it (Ruby autoload only works for module/class constants, not
   # for string constants like `Expressir::VERSION`).
   module Version
-    VERSION = "2.4.12".freeze
+    VERSION = "2.4.13".freeze
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: expressir
 version: !ruby/object:Gem::Version
-  version: 2.4.12
+  version: 2.4.13
 platform: ruby
 authors:
 - Ribose Inc.