expressir 2.4.36-arm-linux → 2.4.38-arm-linux

data/lib/expressir/mapping/refpath.rb

@@ -24,10 +24,16 @@ module Expressir
     #                                          is referenced)
     #   index      := "[" ("i" | DIGITS) "]"
     #   constraint := ["!"] "{" NAME [NAME "."] "=" STRING "}"
+    #   supertype  := "||" NAME "||"          (§5 supertype entity marker)
+    #   tree       := "*" NAME "*"            (§5 relationship tree marker)
     #   MARKER     := "{" | "}" | "[" | "]" | "(" | ")" | ":" | "|" | "!"
     #               | "," | "/" | "*" | "<" | ">" (grouping/annotation;
     #                                               never breaks a
-    #                                               pending link)
+    #                                               pending link; the §5
+    #                                               required-path marker
+    #                                               "<path>" is transparent
+    #                                               — its contents validate
+    #                                               in the running context)
     #
     # Validation (ELF 5006 §8): a running path context tracks the
     # entity a path is "at"; each step must connect to it, attribute
@@ -104,7 +110,7 @@ module Expressir
       EXPRESS_LINK_PATH = /\A<<express:([^,>]+)(?:,[^>]+)?>>\z/
       private_constant :EXPRESS_LINK_PATH
 
-      TOKEN = /<<express:[^,>]+(?:,[^>]+)?>>|->|<-|<=|=>|\*>|<\*|!?\{|[{}\[\]()=:|!,*\/<>]|'(?:''|[^'])*'|\w+(?:\.\w+)?/
+      TOKEN = /<<express:[^,>]+(?:,[^>]+)?>>|->|<-|<=|=>|\*>|<\*|\|\||!?\{|[{}\[\]()=:|!,*\/<>]|'(?:''|[^'])*'|\w+(?:\.\w+)?/
       MARKERS = ["{", "}", "[", "]", "(", ")", ":", "|", "!", ",", "/",
                  "*", "<", ">", "MAPPING_OF", "!{"].freeze
       LINKS = ["->", "<-", "<=", "=>", "*>", "<*"].freeze
@@ -140,13 +146,19 @@ module Expressir
         errors = []
         pending_link = nil
         pending_type_assign = false
-        false
         i = 0
         while i < tokens.length
           token = tokens[i]
           case token
+          when "||"
+            name_token = tokens[i + 1]
+            if name_token&.match?(/\A\w+\z/) && tokens[i + 2] == "||"
+              steps << Step.new(operator: "||", name: name_token)
+              i += 2
+            else
+              errors << "supertype marker '||' without an entity name"
+            end
           when "!{"
-            true
             step, consumed = parse_constraint(tokens[i..], negated: true)
             steps << step
             i += consumed
@@ -182,6 +194,14 @@ module Expressir
             else
               steps << Step.new(operator: "[")
             end
+          when "*"
+            name_token = tokens[i + 1]
+            if name_token&.match?(/\A\w+\z/) && tokens[i + 2] == "*"
+              steps << Step.new(operator: "*", name: name_token)
+              i += 2
+            else
+              steps << Step.new(operator: token)
+            end
           when *MARKERS
             steps << Step.new(operator: token)
           when /\A<<express:/
@@ -302,6 +322,14 @@ module Expressir
           when "*>", "<*"
             issues.concat(select_extension_issues(step, pos, ctx, by_name))
             ctx = step.name&.safe_downcase
+          when "||"
+            issues.concat(supertype_marker_issues(step, pos, ctx, by_name))
+            if step.name
+              seen[step.name.safe_downcase] = true
+              ctx = step.name.safe_downcase
+            end
+          when "*"
+            issues.concat(tree_marker_issues(step, pos, by_name))
           else
             issues.concat(check_step(step, pos, ctx, last_qualified, by_name))
             if step.name
@@ -495,6 +523,39 @@ module Expressir
         end
       end
 
+      # ELF 5006 §5 supertype entity marker: `||supertype||` names an
+      # entity that must exist and, when the path has a running
+      # context, be a supertype of (or equal to) that context entity.
+      def supertype_marker_issues(step, pos, ctx, by_name)
+        issues = []
+        entity = step.name
+        check_exists(issues, pos, entity, by_name)
+        return issues if entity.nil?
+
+        decl = by_name[entity.safe_downcase]&.last
+        return issues unless decl.is_a?(Model::Declarations::Entity)
+
+        context_decl = ctx && by_name[ctx]&.last
+        if context_decl.is_a?(Model::Declarations::Entity) &&
+            !entity_reaches?(context_decl, entity.safe_downcase, by_name,
+                             {}.compare_by_identity)
+          issues << Issue.new(step: pos,
+                              message: "'#{entity}' is not a supertype of " \
+                                       "'#{ctx}'")
+        end
+        issues
+      end
+
+      # ELF 5006 §5 relationship tree marker: `*relationship*` names an
+      # entity whose instances may assemble into a tree; the path
+      # between it and the related entities is implied, so only the
+      # entity's existence is checkable.
+      def tree_marker_issues(step, pos, by_name)
+        issues = []
+        check_exists(issues, pos, step.name, by_name)
+        issues
+      end
+
       # ELF 5006 §8 navigation validation with a running context: the
       # attribute must exist on the context entity, and its type must
       # be able to reference the step's target entity.

data/lib/expressir/mapping.rb

@@ -14,6 +14,7 @@ module Expressir
   # the source files.
   module Mapping
     autoload :RefPath, "#{__dir__}/mapping/refpath"
+    autoload :InstanceVerification, "#{__dir__}/mapping/instance_verification"
 
     EXPRESS_LINK = /<<express:([^,>]+)(?:,([^>]+))?>>/
 

data/lib/expressir/p21/builder.rb

@@ -8,8 +8,80 @@ module Expressir
 
       def build(tree)
         header = build_header(tree[:header_section])
-        instances = build_instances(tree[:data_section])
-        Population.new(header: header, instances: instances)
+        instances = {}
+        sections = []
+        data_sections(tree).each do |section|
+          records = build_instances(section)
+          instances.update(records)
+          sections << build_section(section, records.keys)
+        end
+        Population.new(
+          header: header, instances: instances, sections: sections,
+          anchors: build_anchors(tree[:anchor_section]),
+          references: build_references(tree[:reference_section])
+        )
+      end
+
+      # A DATA section capture: hash for a single section, array when
+      # the exchange structure carries several (ISO 10303-21 annex E).
+      def data_sections(tree)
+        sections = tree[:data_section]
+        sections = [sections] unless sections.is_a?(Array)
+        sections.compact.map do |section|
+          # The repeat's own capture nests each section one level deep.
+          inner = section[:data_section]
+          inner.is_a?(Hash) ? inner : section
+        end
+      end
+
+      Section = Struct.new(:name, :contexts, :instance_ids,
+                           keyword_init: true)
+
+      def build_section(section, instance_ids)
+        tag = section[:section_tag]
+        values = tag && parameter_list_values(tag.is_a?(Hash) ? { parameter: tag } : tag)
+        name = values && values.first.is_a?(String) ? values.first : nil
+        contexts = values && values[1].is_a?(Array) ? values[1] : []
+        Section.new(name: name, contexts: contexts, instance_ids: instance_ids)
+      end
+
+      def build_anchors(capture)
+        entries = capture.is_a?(Hash) ? [capture] : Array(capture)
+        unwrap_anchor_entries(entries).filter_map do |entry|
+          next unless entry.is_a?(Hash) && entry[:anchor_label]
+
+          value = entry[:entity_instance_name] ||
+            (entry[:unset] ? :unset : nil)
+          [entry[:anchor_label].to_s,
+           value == :unset ? :unset : "##{value.to_s.delete_prefix('#')}"]
+        end.to_h
+      end
+
+      # Parsanol captures nest one wrapper per repeat/rule level;
+      # collect the leaves that carry the anchor fields.
+      def unwrap_anchor_entries(entries)
+        entries.flat_map do |entry|
+          next [] unless entry.is_a?(Hash)
+
+          inner = entry[:anchor_entry]
+          if inner
+            unwrap_anchor_entries(inner.is_a?(Array) ? inner : [inner])
+          else
+            [entry]
+          end
+        end
+      end
+
+      def build_references(capture)
+        list = capture.nil? ? [] : capture[:instance_list]
+        entries = list.is_a?(Array) ? list : [list]
+        entries.filter_map do |entry|
+          next unless entry.is_a?(Hash) && entry[:external_reference_instance]
+
+          body = entry[:external_reference_instance]
+          ["##{body[:entity_instance_name].to_s.delete_prefix('#')}",
+           body[:external_anchor].to_s]
+        end.to_h
       end
 
       def build_header(section)
@@ -23,6 +95,8 @@ module Expressir
         list = section[:instance_list]
         entries = list.is_a?(Array) ? list : [list]
         entries.each_with_object({}) do |entry, hash|
+          next unless entry.is_a?(Hash)
+
           if (complex = entry[:complex_entity_instance])
             hash[instance_id(complex)] = build_complex(complex)
           elsif (simple = entry[:simple_entity_instance])
@@ -72,6 +146,8 @@ module Expressir
           parameter_list_values(param[:parameter_list])
         elsif param[:entity_instance_name]
           "##{param[:entity_instance_name].to_s.delete_prefix('#')}"
+        elsif param[:constant_reference]
+          param[:constant_reference].to_s
         elsif param[:number_literal]
           text = param[:number_literal].to_s
           text.match?(/[.Ee]/) ? text.to_f : text.to_i

data/lib/expressir/p21/dataset_manifest.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Expressir
+  module P21
+    # A dataset manifest (TODO.instance/03): binds Part 21 files to a
+    # schema and a library release, so validation is reproducible.
+    class DatasetManifest < Lutaml::Model::Serializable
+      attribute :schema, :string
+      attribute :release, :string
+      attribute :files, :string, collection: true
+      attribute :short_names, :hash
+
+      key_value do
+        map "schema", to: :schema
+        map "release", to: :release
+        map "files", to: :files
+        map "short_names", to: :short_names
+      end
+
+      class << self
+        def from_file(path)
+          manifest = from_yaml(File.read(path))
+          manifest.base_dir = File.dirname(File.expand_path(path))
+          manifest
+        end
+      end
+
+      attr_accessor :base_dir
+
+      # The validator's short-name contract is downcased keys
+      # (ISO 10303-21 12.3).
+      def short_name_map
+        (short_names || {}).transform_keys(&:downcase)
+      end
+
+      def file_paths
+        Array(files).map { |file| File.expand_path(file, base_dir || ".") }
+      end
+
+      def schema_path
+        File.expand_path(schema, base_dir || ".")
+      end
+    end
+  end
+end

data/lib/expressir/p21/diff.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Expressir
+  module P21
+    # Instance-level comparison of two populations (TODO.instance/03):
+    # the population sibling of SchemaCompare. Instances are keyed by
+    # their #id; a change is a keyword or parameter digest difference.
+    module Diff
+      Digest = Struct.new(:keyword, :params, keyword_init: true) do
+        def to_s
+          "#{keyword}(#{params.join(', ')})"
+        end
+      end
+
+      module_function
+
+      def diff(base, revised)
+        added = (revised.instances.keys - base.instances.keys).sort
+        removed = (base.instances.keys - revised.instances.keys).sort
+        changed = (base.instances.keys & revised.instances.keys)
+          .reject do |id|
+            digest(base.instances[id]).to_s == digest(revised.instances[id]).to_s
+          end.sort
+        { added: added, removed: removed, changed: changed }
+      end
+
+      def digest(record)
+        if record.is_a?(ComplexRecord)
+          Digest.new(keyword: "__complex__",
+                     params: record.records.map do |part|
+                       Digest.new(keyword: part.keyword,
+                                  params: part.params)
+                     end)
+        else
+          Digest.new(keyword: record.keyword, params: record.params)
+        end
+      end
+    end
+  end
+end

data/lib/expressir/p21/grammar.rb

@@ -23,6 +23,12 @@ module Expressir
       rule(:ws1) { (match[" \t\r\n"] | comment).repeat(1) }
       rule(:keyword) { match["!"].maybe >> match["A-Za-z0-9_"].repeat(1) }
       rule(:entity_instance_name) { str("#") >> match["0-9"].repeat(1) }
+      rule(:constant_reference) do
+        str("#") >> match["A-Za-z_"] >> match["A-Za-z0-9_"].repeat
+      end
+      rule(:external_anchor) do
+        str("<") >> (str(">").absent? >> any).repeat >> str(">")
+      end
 
       rule(:string_literal) do
         # ISO 10303-21: doubled quotes are escaped quotes
@@ -55,6 +61,8 @@ module Expressir
         typed_parameter.as(:typed_parameter) |
           list_parameter.as(:parameter_list) |
           entity_instance_name.as(:entity_instance_name) |
+          constant_reference.as(:constant_reference) |
+          external_anchor.as(:external_anchor) |
           number_literal.as(:number_literal) |
           enumeration.as(:enumeration) |
           binary_literal.as(:binary_literal) |
@@ -81,25 +89,59 @@ module Expressir
           str("=") >> ws? >> subsuper_record.as(:subsuper_record) >>
           str(";") >> ws?).as(:complex_entity_instance)
       end
-      rule(:entity_instance) { complex_entity_instance | simple_entity_instance }
+      rule(:external_reference_instance) do
+        (entity_instance_name.as(:entity_instance_name) >> ws? >>
+          str("=") >> ws? >> external_anchor.as(:external_anchor) >>
+          str(";") >> ws?).as(:external_reference_instance)
+      end
+      rule(:entity_instance) do
+        complex_entity_instance | simple_entity_instance |
+          external_reference_instance
+      end
 
       rule(:header_entity) do
         simple_record.as(:simple_record) >> str(";") >> ws?
       end
+      # ISO 10303-21:2016 clause 14: two signature lines open the
+      # header of a signed exchange structure.
+      rule(:signature_lines) { (str("..") >> ws?).repeat }
       rule(:header_section) do
-        str("HEADER;") >> ws? >> header_entity.repeat(1).as(:header_entity) >>
+        str("HEADER;") >> ws? >> signature_lines >>
+          header_entity.repeat(1).as(:header_entity) >>
           str("ENDSEC;") >> ws?
       end
       rule(:data_section) do
-        str("DATA;") >> ws? >>
-          (str("(") >> ws? >> parameter >> str(");") >> ws?).maybe >>
+        (str("DATA") >> ws? >>
+          parameter_list.as(:section_tag).maybe >> str(";") >> ws? >>
           entity_instance.repeat.as(:instance_list) >>
-          str("ENDSEC;") >> ws?
+          str("ENDSEC;") >> ws?).as(:data_section)
+      end
+      # ISO 10303-21:2016 clause 9: the anchor section binds labels to
+      # local instances (a promissory anchor binds the unset value).
+      rule(:anchor_entry) do
+        ((str("<") >> str(">").absent? >>
+           match["A-Za-z0-9_./:#?=&%-"].repeat.as(:anchor_label) >>
+           str(">") >> ws? >> str("=") >> ws? >>
+           (entity_instance_name.as(:entity_instance_name) |
+            unset.as(:unset))) >> str(";") >> ws?).as(:anchor_entry)
+      end
+      rule(:anchor_section) do
+        (str("ANCHOR;") >> ws? >> anchor_entry.repeat.as(:anchor_entry) >>
+          str("ENDSEC;") >> ws?).as(:anchor_section)
+      end
+      # ISO 10303-21:2016 clause 10: the reference section binds a
+      # local instance name to an external anchor.
+      rule(:reference_section) do
+        (str("REFERENCE;") >> ws? >>
+          entity_instance.repeat.as(:instance_list) >>
+          str("ENDSEC;") >> ws?).as(:reference_section)
       end
       rule(:exchange_structure) do
         ws? >> str("ISO-10303-21;") >> ws? >>
           header_section.as(:header_section) >>
-          data_section.as(:data_section) >>
+          anchor_section.maybe >>
+          reference_section.maybe >>
+          data_section.repeat(1).as(:data_section) >>
           str("END-ISO-10303-21;") >> ws?
       end
     end

data/lib/expressir/p21/json.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Expressir
+  module P21
+    # JSON interchange for populations (TODO.instance/03). Values are
+    # tagged so the round trip is value-identical: references stay
+    # references, enumerations and binaries stay typed, and `$`/`*`
+    # survive as their Part 21 meanings.
+    module Json
+      module_function
+
+      def to_value(population)
+        {
+          "header" => population.header,
+          "instances" => population.instances.to_h do |id, record|
+            [id, record_value(record)]
+          end,
+          "sections" => population.sections.map do |section|
+            { "name" => section.name, "contexts" => section.contexts,
+              "instance_ids" => section.instance_ids }
+          end,
+          "anchors" => population.anchors.to_h do |label, value|
+            [label, anchor_value(value)]
+          end,
+          "references" => population.references,
+        }
+      end
+
+      def population(value)
+        instances = value.fetch("instances").to_h do |id, record|
+          [id, record_from(record)]
+        end
+        sections = value.fetch("sections").map do |section|
+          Builder::Section.new(name: section["name"],
+                               contexts: section["contexts"],
+                               instance_ids: section["instance_ids"])
+        end
+        anchors = value.fetch("anchors").to_h do |label, anchor|
+          [label, anchor == "unset" ? :unset : anchor]
+        end
+        Population.new(
+          header: value.fetch("header"),
+          instances: instances,
+          sections: sections,
+          anchors: anchors,
+          references: value.fetch("references"),
+        )
+      end
+
+      def record_value(record)
+        if record.is_a?(ComplexRecord)
+          { "complex" => record.records.map { |part| simple_value(part) } }
+        else
+          simple_value(record)
+        end
+      end
+
+      def simple_value(record)
+        { "keyword" => record.keyword,
+          "params" => value_params(record.params) }
+      end
+
+      def value_params(params)
+        params.map { |value| value_value(value) }
+      end
+
+      def value_value(value)
+        case value
+        when Array then value.map { |item| value_value(item) }
+        when TypedValue
+          { "typed" => { "keyword" => value.keyword,
+                         "value" => value_value(value.value) } }
+        when Enumeration then { "enum" => value.name }
+        when Binary then { "binary" => value.hex }
+        when :unset then { "unset" => true }
+        when :derived then { "derived" => true }
+        when String
+          value.match?(/\A#\d+\z/) ? { "ref" => value } : value
+        else value
+        end
+      end
+
+      def record_from(value)
+        if (complex = value["complex"])
+          ComplexRecord.new(complex.map { |part| simple_from(part) })
+        else
+          simple_from(value)
+        end
+      end
+
+      def simple_from(value)
+        Record.new(value.fetch("keyword"), params_from(value.fetch("params")))
+      end
+
+      def params_from(params)
+        params.map { |value| value_from(value) }
+      end
+
+      def value_from(value)
+        case value
+        when Array then value.map { |item| value_from(item) }
+        when Hash
+          if (typed = value["typed"])
+            TypedValue.new(typed.fetch("keyword"),
+                           params_from(Array(typed.fetch("value"))))
+          elsif (enum = value["enum"])
+            Enumeration.new(enum)
+          elsif (binary = value["binary"])
+            Binary.new(binary)
+          elsif value["unset"]
+            :unset
+          elsif value["derived"]
+            :derived
+          elsif (ref = value["ref"])
+            ref
+          else
+            value
+          end
+        else value
+        end
+      end
+
+      def anchor_value(value)
+        value == :unset ? "unset" : value
+      end
+    end
+  end
+end

data/lib/expressir/p21/population.rb

@@ -12,11 +12,15 @@ module Expressir
     # Expressir::P21::ComplexRecord, :unset, :derived, or nested
     # Arrays for lists.
     class Population
-      attr_reader :header, :instances
+      attr_reader :header, :instances, :sections, :anchors, :references
 
-      def initialize(header: {}, instances: {})
+      def initialize(header: {}, instances: {}, sections: [], anchors: {},
+                     references: {})
         @header = header
         @instances = instances
+        @sections = sections
+        @anchors = anchors
+        @references = references
       end
     end
 

data/lib/expressir/p21/receipt.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "json"
+require "digest"
+
+module Expressir
+  module P21
+    # A validation receipt (TODO.instance/03): the deterministic,
+    # citable record binding a dataset to a schema edition and a
+    # validator run. Same manifest + same files → byte-identical
+    # receipt.
+    module Receipt
+      module_function
+
+      def build(manifest, results)
+        files = results.keys.sort.map do |path|
+          {
+            "path" => path,
+            "digest" => Digest::SHA256.hexdigest(File.read(path)),
+            "notes" => results[path].map do |note|
+              {
+                "id" => note.id.to_s,
+                "severity" => note.severity.to_s,
+                "instance" => note.instance,
+                "message" => note.message,
+              }
+            end,
+          }
+        end
+        report = {
+          "release" => manifest.release.to_s,
+          "schema" => manifest.schema.to_s,
+          "validator" => "expressir #{Expressir::VERSION}",
+          "files" => files,
+          "summary" => {
+            "files" => files.size,
+            "errors" => files.sum { |file| file["notes"].count { |n| n["severity"] == "error" } },
+            "warnings" => files.sum { |file| file["notes"].count { |n| n["severity"] == "warning" } },
+          },
+        }
+        JSON.generate(report)
+      end
+    end
+  end
+end