expressir 2.4.18 → 2.4.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 71c43838ba6c2853f84bfa1faca26760abe4919d35b98895ef224866bd49da62
-  data.tar.gz: 715a55be95f4ead656b98e0df59ccf06c2036eb532d6990a8ea036ee5f0f78c4
+  metadata.gz: e6cda48af3f6a3d844c896622b39a79c31631c9b164f5f727d2841d85decb1ec
+  data.tar.gz: 375c96471483ed06f43272785520d5f6c763687a03f104dd1d5049636c010948
 SHA512:
-  metadata.gz: dac93ad5688fc8e2d3814fd6933b352ea35d78b89f157e99f30114ddafb07b53aaeb80aaa45fd63540a9ee400ac1aacc3724800446f868472499d9d4cf501629
-  data.tar.gz: 12cd7ef87afa0510215d0c1315e68ba5bbaed5a910255ebfa40e18b328b25f87ef3a24f93ce1073a798ce0e748e6344861f05900f863377ed801d9f1f66e7bab
+  metadata.gz: f64857ddcef1a8bd7896ee1c5c8ed6050ba263e2ab8aa2df2bc8a02e98f3e55c8cf2e6b186760dbda9a37e513882292fe3569eb5ded9eee471978e3ef4580a9e
+  data.tar.gz: 8e6f94bc7c441f0fd1394c7cff8d512e20247c5f07291b2d969bdfcdef1af5cadf6230b4b2512cc273ca08d9de3ef906e4762fad6cbbcaa273f3667429355dea

data/lib/expressir/mapping/refpath.rb

@@ -15,6 +15,10 @@ module Expressir
     #   link       := "->" | "<-" | "<=" | "=>" | "=" NAME
     #                                            (relation to the previous node)
     #   node       := NAME ["." ATTRIBUTE]
+    #               | LINK                    (<<express:SCHEMA.ITEM,ITEM>>,
+    #                                          #460: a link may stand
+    #                                          wherever a declaration
+    #                                          is referenced)
     #   index      := "[" ("i" | DIGITS) "]"
     #   MARKER     := "{" | "}" | "[" | "]" | "(" | ")" | ":" | "|" | "!"
     #               | "," | "/" | "*"           (grouping/annotation; no
@@ -42,6 +46,8 @@ module Expressir
         attribute :attribute, :string
         attribute :index, :string
         attribute :literal, :string
+        # annotated EXPRESS link form: <<express:SCHEMA.ITEM,ITEM>>
+        attribute :link, :string
 
         key_value do
           map "operator", to: :operator
@@ -49,6 +55,7 @@ module Expressir
           map "attribute", to: :attribute
           map "index", to: :index
           map "literal", to: :literal
+          map "link", to: :link
         end
       end
 
@@ -62,9 +69,12 @@ module Expressir
         end
       end
 
-      TOKEN = /->|<-|<=|=>|[{}\[\]()=:|!,*\/]|'(?:''|[^'])*'|\w+(?:\.\w+)?/
+      EXPRESS_LINK_PATH = /\A<<express:([^,>]+)(?:,[^>]+)?>>\z/
+      private_constant :EXPRESS_LINK_PATH
+
+      TOKEN = /<<express:[^,>]+(?:,[^>]+)?>>|->|<-|<=|=>|[{}\[\]()=:|!,*\/]|'(?:''|[^'])*'|\w+(?:\.\w+)?/
       MARKERS = ["{", "}", "[", "]", "(", ")", ":", "|", "!", ",", "/",
-                 "*"].freeze
+                 "*", "MAPPING_OF"].freeze
       LINKS = ["->", "<-", "<=", "=>"].freeze
       DECLARATION_COLLECTIONS = %i[types entities].freeze
       private_constant :TOKEN, :MARKERS, :LINKS, :DECLARATION_COLLECTIONS
@@ -109,19 +119,17 @@ module Expressir
             end
           when *MARKERS
             steps << Step.new(operator: token)
+          when /\A<<express:/
+            steps << Step.new(operator: pending_link, link: token)
+            pending_link = nil
+            pending_type_assign = false
           else
             name, _, attribute = token.partition(".")
-            if name.casecmp("MAPPING_OF").zero? && tokens[i + 1] == "("
-              # notation wrapper: /MAPPING_OF(X)/ refers to X; the
-              # wrapper itself carries no node semantics
-              steps << Step.new(operator: token)
-            else
-              operator = pending_link || ("=" if pending_type_assign)
-              steps << Step.new(operator: operator, name: name,
-                                attribute: attribute.empty? ? nil : attribute)
-              pending_link = nil
-              pending_type_assign = false
-            end
+            operator = pending_link || ("=" if pending_type_assign)
+            steps << Step.new(operator: operator, name: name,
+                              attribute: attribute.empty? ? nil : attribute)
+            pending_link = nil
+            pending_type_assign = false
           end
           i += 1
         end
@@ -153,34 +161,66 @@ module Expressir
         by_name = name_index(repository)
         issues = []
         prev = nil
+        last_qualified = nil
         path.steps.each_with_index do |step, pos|
-          if MARKERS.include?(step.operator)
-            prev = nil
-            next
-          end
+          # markers never break the running link, mirroring parse
+          next if MARKERS.include?(step.operator)
 
-          issues.concat(check_step(step, pos, prev, by_name))
-          prev = step if step.name
+          if step.link
+            issues.concat(check_link_step(step, pos, repository))
+          else
+            issues.concat(check_step(step, pos, prev, last_qualified, by_name))
+          end
+          prev = step if step.name || step.link
+          last_qualified = step if step.name && step.attribute
         end
         issues
       end
 
+      EXPRESS_BUILTINS = %w[NUMBER INTEGER REAL STRING BOOLEAN LOGICAL
+                            BINARY].freeze
+      private_constant :EXPRESS_BUILTINS
+
       def name_index(repository)
+        index = EXPRESS_BUILTINS.to_h { |b| [b.downcase, [nil, nil]] }
         repository.schemas.flat_map do |schema|
           DECLARATION_COLLECTIONS.flat_map do |coll|
             Array(schema.public_send(coll))
               .select { |d| d.respond_to?(:id) && d.id }
               .map { |d| [d.id.safe_downcase, [schema, d]] }
           end
-        end.to_h
+        end.each { |pair| index[pair[0]] = pair[1] }
+        index
+      end
+
+      # Annotated EXPRESS link node: <<express:SCHEMA.ITEM,ITEM>>
+      # (item part optional) resolves against the repository (#460).
+      def check_link_step(step, pos, repository)
+        parts = step.link.match(EXPRESS_LINK_PATH)
+        return [Issue.new(step: pos, message: "malformed link '#{step.link}'")] unless parts
+
+        schema_id, item_id = parts[1].split(".", 2).compact
+        schema = repository.schemas
+          .find { |s| s.id&.safe_downcase == schema_id&.safe_downcase }
+        unless schema
+          return [Issue.new(step: pos,
+                            message: "unknown schema '#{schema_id}' in #{step.link}")]
+        end
+
+        return [] if item_id.nil?
+        return [] if Expressir::Mapping.item_declared?(schema, item_id)
+
+        [Issue.new(step: pos,
+                   message: "schema '#{schema_id}' does not declare " \
+                            "'#{item_id}' (#{step.link})")]
       end
 
-      def check_step(step, pos, prev, by_name)
+      def check_step(step, pos, prev, last_qualified, by_name)
         found = by_name[step.name&.safe_downcase]
         return [Issue.new(step: pos, message: "unknown type '#{step.name}'")] unless found
 
         issues = attribute_issues(step, pos, found[1], by_name)
-        issues.concat(link_issues(step, pos, prev, by_name))
+        issues.concat(link_issues(step, pos, prev, last_qualified, by_name))
         issues
       end
 
@@ -239,7 +279,7 @@ module Expressir
                             "aggregate but carries [#{step.index}]")]
       end
 
-      def link_issues(step, pos, prev, by_name)
+      def link_issues(step, pos, prev, last_qualified, by_name)
         return [] unless LINKS.include?(step.operator)
         unless prev && step.name
           return [Issue.new(step: pos,
@@ -247,20 +287,39 @@ module Expressir
         end
 
         case step.operator
-        when "->", "<-" then attribute_link_issues(step, pos, prev)
+        when "->", "<-"
+          attribute_link_issues(step, pos, prev, last_qualified)
         when "<=" then subtype_link_issues(step, pos, prev, by_name)
         when "=>" then supertype_link_issues(step, pos, prev, by_name)
         end
       end
 
-      def attribute_link_issues(_step, pos, prev)
-        unless prev.attribute
-          return [Issue.new(step: pos,
-                            message: "'->' requires an attribute-qualified " \
-                                     "node before it, got '#{prev.name}'")]
+      # `->`: the attribute-qualified node precedes the operator;
+      # `<-`: it follows (the entity before <- is referenced BY the
+      # attribute after it). An aggregate dereference `[i]` keeps the
+      # running attribute owner qualified for the next link
+      # (`attr -> list_type[i] -> element_type`).
+      def attribute_link_issues(step, pos, prev, last_qualified)
+        if step.operator == "->"
+          qualified = if prev&.attribute
+                        prev
+                      else
+                        (prev&.index ? last_qualified : nil)
+                      end
+          unless qualified&.attribute
+            return [Issue.new(step: pos,
+                              message: "'->' requires an attribute-qualified " \
+                                       "node before it, got '#{prev&.name}'")]
+          end
+
+          return []
         end
 
-        []
+        return [] if step.attribute
+
+        [Issue.new(step: pos,
+                   message: "'<-' requires an attribute-qualified node " \
+                            "after it, got '#{step.name}'")]
       end
 
       # `a <= b`: a is a subtype of b.

data/lib/expressir/mapping.rb

@@ -136,8 +136,16 @@ module Expressir
     def values(document)
       document.ae.to_a.flat_map do |element|
         [element.entity, element.aimelt] +
-          element.aa.to_a.flat_map { |aa| [aa.attribute, aa.aimelt] }
-      end.compact
+          element.aa.to_a.flat_map do |aa|
+            [aa.attribute, aa.aimelt, aa.assertion_to]
+          end
+      end.compact + subtype_constraint_values(document)
+    end
+
+    # Every declaration reference in the sc entries (#460): the
+    # constraint name and the entity it constrains.
+    def subtype_constraint_values(document)
+      document.sc.to_a.flat_map { |sc| [sc.constraint, sc.entity] }.compact
     end
 
     # Every reference path in the document as [location, content]

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.18".freeze
+    VERSION = "2.4.20".freeze
   end
 end

metadata

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