expressir 2.4.37-arm-linux → 2.4.38-arm-linux

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

data/lib/expressir/p21/typing.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module Expressir
+  module P21
+    # ISO 10303-11 9.2.5 instance typing: which entities a Part 21
+    # instance conforms to. A simple record conforms to its keyword
+    # entity plus that entity's supertype closure; a complex record
+    # conforms to the union of its records' closures. ONEOF
+    # exclusivity (9.2.5.2) is reported per complex record.
+    class Typing
+      Result = Struct.new(:entities, :issues, keyword_init: true)
+
+      def initialize(schema, short_names: nil)
+        @schema = schema
+        @short_names = short_names&.transform_keys(&:downcase)
+        @results = {}.compare_by_identity
+      end
+
+      def of(record)
+        result(record).entities
+      end
+
+      def issues(record)
+        result(record).issues
+      end
+
+      def result(record)
+        @results[record] ||= compute(record)
+      end
+
+      private
+
+      def compute(record)
+        parts = record.is_a?(ComplexRecord) ? record.records : [record]
+        entities = []
+        leaves = []
+        issues = []
+        seen_leaves = {}
+        parts.each do |part|
+          entity = Validator.find_entity(@schema, part.keyword, @short_names)
+          if entity.nil?
+            issues << "keyword '#{part.keyword}' is not declared in " \
+                      "schema '#{@schema.id}'"
+            next
+          end
+
+          key = entity.id&.safe_downcase
+          if seen_leaves[key]
+            issues << "complex instance instantiates '#{entity.id}' " \
+                      "twice (9.2.5)"
+          end
+          seen_leaves[key] = true
+          leaves << entity
+          entities.push(entity, *entity.supertype_closure)
+        end
+        issues.concat(oneof_issues(leaves))
+        entities.uniq! { |entity| entity.id&.safe_downcase }
+        Result.new(entities: entities, issues: issues)
+      end
+
+      def oneof_issues(leaves)
+        leaves.combination(2).filter_map do |left, right|
+          next unless shared_oneof_group?(left, right)
+
+          "complex instance combines '#{left.id}' and '#{right.id}' " \
+            "in one ONEOF group (9.2.5.2)"
+        end
+      end
+
+      def shared_oneof_group?(left, right)
+        oneof_groups(left).any? do |group|
+          group.include?(left.id&.safe_downcase) &&
+            group.include?(right.id&.safe_downcase)
+        end
+      end
+
+      # ONEOF groups constraining an entity: its own supertype
+      # expression, every supertype's expression, and the ONEOF
+      # subtype constraints applied to any of them (9.7).
+      def oneof_groups(entity)
+        @oneof_groups ||= {}
+        key = entity.id&.safe_downcase
+        @oneof_groups[key] ||= begin
+          groups = []
+          [entity, *entity.supertype_closure].each do |supertype|
+            expression = supertype.supertype_expression
+            groups << oneof_members(expression) if oneof?(expression)
+            subtype_constraint_groups(supertype, groups)
+          end
+          groups
+        end
+      end
+
+      def subtype_constraint_groups(supertype, groups)
+        Array(@schema.subtype_constraints).each do |constraint|
+          next unless constraint.applies_to&.id&.safe_downcase == supertype.id&.safe_downcase
+
+          expression = constraint.supertype_expression
+          groups << oneof_members(expression) if oneof?(expression)
+        end
+      end
+
+      def oneof?(expression)
+        expression.is_a?(Model::SupertypeExpressions::OneofSupertypeExpression)
+      end
+
+      def oneof_members(expression)
+        Array(expression.operands).filter_map do |operand|
+          next unless operand.respond_to?(:id) && operand.id
+
+          operand.id.safe_downcase
+        end
+      end
+    end
+  end
+end