expressir 2.4.13 → 2.4.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e3cf38ff1a09f95805cc5a6dc8c074832e47eeb8ceb7e62c79f503d521d775ac
-  data.tar.gz: a308605c1d7c97d33f766d08e8262e6e2039104ff7362e36a0fa5bd8e3839ccf
+  metadata.gz: 714b13d808744a329002460e108fdb35f4a8fcf0d3095517cd241d411bce215e
+  data.tar.gz: 8cf66567212cc463ab351cd6e0cbb70ee63ec11ae2c0b31036cd3d0aff264384
 SHA512:
-  metadata.gz: 4c97b4d258e50604fba0bdc0365c3f8272d6944dc225755e6408c6b585324b917448134352a4ffb4da445ca21ef910858283931abef43625d0b4138c90ecf694
-  data.tar.gz: d268fd6aef2e11bdafe5f81845931e91742dcd33ff48f3a2f6bb0076a6f9bad440045609a501b81fcc2130fef6dcd565d972ebc6634861d0341f9efa2649b5b5
+  metadata.gz: 1c13e1c4cdb0a551e86e2d557c6df01fc2a1b36e1ff536cd4afc6a2255c922d0bcb8252debdc600479514963b38b8482d41de118fb55933472ed173cca77e2aa
+  data.tar.gz: 3f4107ac13feea2a5fdc9d5659312e44af1c7288d957132a119fb1799df396f709ed5c9d82c970669ceda5e64238506abe412a4850c310b4e173f347c67cc31d

data/lib/expressir/commands/parity_inputs.rb

@@ -1,4 +1,5 @@
 require "find"
+require "thor"
 
 module Expressir
   module Commands
@@ -42,8 +43,9 @@ module Expressir
           end
         end
         unless missing.empty?
-          warn "expressir: schema(s) not found: #{missing.uniq.join(', ')}" \
-               "#{resolver_hint(manifest, stepmod)}"
+          raise Thor::Error,
+                "expressir: schema(s) not found: #{missing.uniq.join(', ')}" \
+                "#{resolver_hint(manifest, stepmod)}"
         end
         seen.values.compact.uniq
       end
@@ -90,14 +92,37 @@ module Expressir
         return manifest_index(manifest) if manifest
         return stepmod_index(stepmod) if stepmod
 
-        same_dir_index(root_path)
+        # Default: the file's own directory plus, when the root sits
+        # inside a STEPmod checkout, its enclosing `schemas/` tree —
+        # the layout wg12-step modules live in.
+        index = same_dir_index(root_path)
+        ancestor = ancestor_schemas_dir(root_path)
+        index.update(stepmod_index(File.dirname(ancestor))) if ancestor
+        index
+      end
+
+      # Nearest ancestor directory NAMED `schemas`, or nil.
+      def ancestor_schemas_dir(root_path)
+        dir = File.dirname(File.expand_path(root_path))
+        until dir == "/"
+          return dir if File.basename(dir) == "schemas"
+
+          dir = File.dirname(dir)
+        end
+        nil
       end
 
       def same_dir_index(root_path)
         dir = File.dirname(File.expand_path(root_path))
-        Dir.glob(File.join(dir, "*.exp")).to_h do |p|
-          [File.basename(p, ".exp").downcase, p]
+        h = {}
+        Dir.glob(File.join(dir, "*.exp")).each do |path|
+          # index by DECLARED schema name first (a file named arm.exp
+          # may declare schema m_arm), basename as fallback
+          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
 
       # Interface names declared by +source+. Remark text is stripped

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
 
@@ -285,7 +290,7 @@ module Expressir
         end
       end
 
-      def each_reference(node, &)
+      def each_reference(node, &block)
         case node
         when Model::References::SimpleReference then yield node
         when Model::ModelElement
@@ -294,8 +299,8 @@ module Expressir
 
             value = node.public_send(attr)
             case value
-            when Array then value.each { |item| each_reference(item, &) }
-            when Model::ModelElement then each_reference(value, &)
+            when Array then value.each { |item| each_reference(item, &block) }
+            when Model::ModelElement then each_reference(value, &block)
             end
           end
         end
@@ -342,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, &block)
+        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, &block) }
+            when Model::ModelElement then each_string(value, &block)
+            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,13 +351,17 @@ module Expressir
         end
       end
 
-      # 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.)
+      # Every identifier a call site or reference names, across the
+      # artifact's surviving declarations: FunctionCall for functions,
+      # ProcedureCall statements for procedures, and ANY SimpleReference
+      # naming a schema function/procedure — a zero-argument function
+      # used bare (`v < limit_value`) parses as a plain reference, not
+      # a FunctionCall, and dropping it would leave the longform with a
+      # dangling call. Over-retaining is safe: prune only decides what
+      # may be dropped.
       def called_ids(schema)
+        invocable = (schema.functions.to_a + schema.procedures.to_a)
+          .map { |d| d.id.safe_downcase }
         called = {}
         each_node(schema) do |node|
           id = nil
@@ -366,8 +370,10 @@ module Expressir
             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
+          when Model::References::SimpleReference
+            id = node.id
           end
-          called[id.safe_downcase] = true if id
+          called[id.safe_downcase] = true if id && invocable.include?(id.safe_downcase)
         end
         called
       end

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.13".freeze
+    VERSION = "2.4.15".freeze
   end
 end

metadata

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