expressir 2.4.12 → 2.4.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 76901fb66e21e9752a5ba64f7b80c23e92a7fa54fac6df80ba221d46bee358e3
-  data.tar.gz: d02e64ac60b0b670f31f665e3834553e29dfd8abc9f7ff51c22bc33dbafcbe11
+  metadata.gz: ad3043a3dd1ac401e841249e3e081a7b3b6b3c3da99f6a9dbc136a127619ba49
+  data.tar.gz: '085e25b6e9b97d53fc5207aa651b37b080557626c6971b60029b98749ff4db82'
 SHA512:
-  metadata.gz: c6c20c797b67efe96bf149207c2283b6e8ba3054e17feda55630fbccf92d337bdfc3322c0a77408262bf1066a60a30b2f137c5f2d4f5a62f78bcea69f818e567
-  data.tar.gz: 39f8f5f287a3d01df2f84cc3667afc00632de391415f9b6aad21538623f167330de9ea3b8857ebe25490d946113d7a85637b5884625ec445b52d3d4a2663b214
+  metadata.gz: e92cca737def4e8432f30b98162262f83df7d81c719c7a1dd916173f65ff788c1145843e46131bfe7da5ef97e76c00a155215f7c4893befe7748601711438d93
+  data.tar.gz: 88d3f1008222838323a843a1b9a7117bf1b09465fa453de4bfd21868137b16439a680165e527555099ae67884cb8a77c8a2068e92b113f34408444c314482583

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

@@ -97,6 +97,11 @@ module Expressir
           check_where_rules(schema, t, t.where_rules)
         end
         schema.rules.each { |r| check_where_rules(schema, r, r.where_rules) }
+        schema.entities.each do |entity|
+          check_aggregate_bounds(schema, entity)
+          check_attrib_name_fun(schema, entity)
+        end
+        check_string_references(schema)
         check_unresolved_refs(schema)
       end
 
@@ -307,20 +312,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
 
-        nil
+      # 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 }
+
+        @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
@@ -330,6 +347,82 @@ module Expressir
         :type if find_type(schema, id)
       end
 
+      # eeng check-agg-type: a two-bound aggregate whose lower bound
+      # exceeds its upper bound is invalid.
+      def check_aggregate_bounds(schema, entity)
+        entity.attributes.to_a.each do |attr|
+          type = attr.type
+          next unless type.respond_to?(:bound1) && type.respond_to?(:bound2)
+
+          lower = integer_bound(type.bound1)
+          upper = integer_bound(type.bound2)
+          next if lower.nil? || upper.nil?
+          next if lower <= upper
+
+          note!(:check_agg_type, :error, schema,
+                "ENTITY #{entity.id}: aggregate '#{attr.id}' bounds " \
+                "[#{lower}:#{upper}] are inverted", attr)
+        end
+      end
+
+      def integer_bound(bound)
+        return nil unless bound.is_a?(Model::Literals::Integer)
+
+        bound.value.to_i
+      rescue StandardError
+        nil
+      end
+
+      # eeng check-attrib-name-fun: an attribute sharing its name with
+      # a function of the same schema can never be referenced cleanly.
+      def check_attrib_name_fun(schema, entity)
+        funs = schema.functions.to_a.map { |f| f.id.safe_downcase }
+        entity.attributes.to_a.each do |attr|
+          next unless attr.id && funs.include?(attr.id.safe_downcase)
+
+          note!(:check_attrib_name_fun, :warning, schema,
+                "ENTITY #{entity.id}: attribute '#{attr.id}' shadows a " \
+                "function of the same name", attr)
+        end
+      end
+
+      # eeng check-string-no-entity: string literals of the shape
+      # 'SCHEMA.ITEM' whose SCHEMA is known in the repository but whose
+      # ITEM is not declared in it (the TYPEOF idiom).
+      def check_string_references(schema)
+        known = @by_name
+        each_string(schema) do |literal, value|
+          match = /\A(\w+)\.(\w+)\z/.match(value)
+          next unless match
+
+          schema_id = match[1].safe_downcase
+          item_id = match[2].safe_downcase
+          target = known[schema_id]&.find { |s| s.id.safe_downcase == schema_id }
+          next unless target
+          next if Expressir::Express::SelfSchemaReference.declared?(target, item_id)
+
+          note!(:check_string_no_entity, :warning, schema,
+                "string '#{value}' references '#{item_id}' which is not " \
+                "declared in schema '#{target.id}'", literal)
+        end
+      end
+
+      def each_string(node, &)
+        case node
+        when Model::Literals::String then yield node, node.value
+        when Model::ModelElement
+          node.class.attributes.each_key do |attr|
+            next if Model::ModelElement::SKIP_ATTRIBUTES.include?(attr) || attr == :parent
+
+            value = node.public_send(attr)
+            case value
+            when Array then value.each { |item| each_string(item, &) }
+            when Model::ModelElement then each_string(value, &)
+            end
+          end
+        end
+      end
+
       def check_where_rules(schema, owner, rules)
         Array(rules).each do |wr|
           next if wr.id.nil? || wr.id.match?(WHERE_LABEL)

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.14".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.14
 platform: ruby
 authors:
 - Ribose Inc.