expressir 2.4.32 → 2.4.33

data/lib/expressir/p21/population.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Expressir
+  module P21
+    # A parsed ISO 10303-21 exchange structure (TODO.eengine/06).
+    # `header`   — Hash: keyword => parameters (Array of values).
+    # `instances`— Hash: "#id" => Record.
+    #
+    # Values: String (string literal), Integer (reference id, keyed as
+    # "#id" in instances), Expressir::P21::Enumeration,
+    # Expressir::P21::Binary, Expressir::P21::TypedValue,
+    # Expressir::P21::ComplexRecord, :unset, :derived, or nested
+    # Arrays for lists.
+    class Population
+      attr_reader :header, :instances
+
+      def initialize(header: {}, instances: {})
+        @header = header
+        @instances = instances
+      end
+    end
+
+    # A data-section instance: `#12 = KEYWORD(param, ...) ;`
+    Record = Struct.new(:keyword, :params)
+
+    # `#21 = (A(...) B(...))` — complex entity instance.
+    ComplexRecord = Struct.new(:records)
+
+    TypedValue = Struct.new(:keyword, :value)
+
+    Enumeration = Struct.new(:name)
+
+    Binary = Struct.new(:hex)
+  end
+end

data/lib/expressir/p21/validator.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+module Expressir
+  module P21
+    # Validates a {Population} against a loaded schema
+    # (TODO.eengine/06 step 2). Single-schema scope: instance keywords
+    # must be declared in the given schema; USE/REFERENCE visibility is
+    # a later ladder step.
+    #
+    # Mapping follows ISO 10303-21 clause 12: derived attributes are
+    # not mapped (a supertype attribute redeclared as DERIVED keeps its
+    # slot, valued `*`), inverse attributes are not mapped, and the
+    # value order is supertype attributes first.
+    module Validator
+      Note = Struct.new(:id, :severity, :instance, :message, keyword_init: true)
+
+      module_function
+
+      # `short_names` maps exchange-structure short names (ISO 10303-21,
+      # clause 12.3) to schema entity names, e.g. {"CPT" => "cartesian_point"}.
+      def validate(population, schema, short_names: nil)
+        short_names = short_names&.transform_keys(&:downcase)
+        notes = []
+        check_file_schema(notes, population, schema)
+        population.instances.each do |id, instance|
+          if instance.is_a?(ComplexRecord)
+            check_complex(notes, schema, population, id, instance, short_names)
+          else
+            check_simple(notes, schema, population, id, instance, short_names)
+          end
+        end
+        notes
+      end
+
+      def errors(notes)
+        notes.select { |note| note.severity == :error }
+      end
+
+      def warnings(notes)
+        notes.select { |note| note.severity == :warning }
+      end
+
+      def valid?(notes)
+        errors(notes).empty?
+      end
+
+      def note!(notes, id, severity, instance, message)
+        notes << Note.new(id: id, severity: severity, instance: instance,
+                          message: message)
+      end
+
+      def check_file_schema(notes, population, schema)
+        declared = Array(population.header["FILE_SCHEMA"]).flatten.first
+        return unless declared && schema.id
+        return if declared.downcase == schema.id.downcase
+
+        note!(notes, :p21_schema_mismatch, :warning, nil,
+              "FILE_SCHEMA '#{declared}' does not match schema '#{schema.id}'")
+      end
+
+      def check_simple(notes, schema, population, id, record, short_names)
+        entity = find_entity(schema, record.keyword, short_names)
+        unless entity
+          note!(notes, :p21_unknown_entity, :error, id,
+                "#{record.keyword} is not declared in schema '#{schema.id}'")
+          return
+        end
+
+        check_params(notes, schema, population, id, record.params,
+                     mapped_slots(entity))
+      end
+
+      def check_complex(notes, schema, population, id, complex, short_names)
+        pairs = complex.records.filter_map do |record|
+          entity = find_entity(schema, record.keyword, short_names)
+          unless entity
+            note!(notes, :p21_unknown_entity, :error, id,
+                  "#{record.keyword} is not declared in schema '#{schema.id}'")
+            next nil
+          end
+
+          [record, entity]
+        end
+        return if pairs.empty?
+
+        check_clique(notes, id, pairs.map { |_, entity| entity })
+        pairs.each do |record, entity|
+          slots = explicit_attributes(entity).map { |attr| [attr, false] }
+          check_params(notes, schema, population, id, record.params, slots)
+        end
+      end
+
+      # A complex instance's records must form a valid supertype graph
+      # path: they share at least one common supertype.
+      def check_clique(notes, id, entities)
+        common = closure_keys(entities.first)
+        entities.drop(1).each { |entity| common &= closure_keys(entity) }
+        return unless common.empty?
+
+        note!(notes, :p21_complex_clique, :error, id,
+              "#{id}: complex records share no common supertype")
+      end
+
+      def closure_keys(entity)
+        keys = entity.supertype_closure.filter_map { |e| e.id&.downcase }
+        keys << entity.id&.downcase
+      end
+
+      # Part 21 value order: supertype attributes first; an attribute
+      # redeclared as DERIVED in the entity keeps its inherited slot,
+      # valued `*` (12.2.6).
+      def mapped_slots(entity)
+        own_derived_keys = own_derived_attributes(entity)
+          .filter_map { |attr| attr.id&.downcase }
+        inherited = entity.supertype_closure.flat_map do |supertype|
+          explicit_attributes(supertype)
+        end
+        inherited.map do |attr|
+          [attr, own_derived_keys.include?(attr.id&.downcase)]
+        end + explicit_attributes(entity).map { |attr| [attr, false] }
+      end
+
+      def check_params(notes, schema, population, id, params, slots)
+        if params.size != slots.size
+          note!(notes, :p21_arity_mismatch, :error, id,
+                "#{id}: #{params.size} values for #{slots.size} mapped attributes")
+        end
+
+        slots.zip(params).each do |(attr, derived_slot), value|
+          next if value.nil?
+
+          if derived_slot
+            next if value == :derived
+
+            note!(notes, :p21_derived_slot, :error, id,
+                  "#{id}: attribute '#{attr.id}' redeclared DERIVED must be '*'")
+            next
+          end
+
+          check_value(notes, schema, population, id, attr, value)
+        end
+      end
+
+      def check_value(notes, schema, population, id, attr, value)
+        case value
+        when String
+          return unless value.match?(/\A#\d+\z/)
+
+          return if population.instances.key?(value)
+
+          note!(notes, :p21_unknown_reference, :error, id,
+                "#{id}: reference #{value} has no instance")
+        when :derived
+          note!(notes, :p21_derived_value, :error, id,
+                "#{id}: '*' outside a derived slot")
+        when TypedValue
+          return if find_entity(schema, value.keyword) || find_type(schema, value.keyword)
+
+          note!(notes, :p21_unknown_typed_keyword, :error, id,
+                "#{id}: typed parameter '#{value.keyword}' does not resolve")
+        when Enumeration
+          items = enumeration_items(schema, attr)
+          return unless items
+
+          names = items.filter_map { |item| item.id&.downcase }
+          return if names.include?(value.name.downcase)
+
+          note!(notes, :p21_enum_value, :error, id,
+                "#{id}: .#{value.name}. is not in attribute '#{attr.id}' enumeration")
+        when Array
+          value.each { |item| check_value(notes, schema, population, id, attr, item) }
+        end
+      end
+
+      def explicit_attributes(entity)
+        Array(entity.attributes)
+          .select { |attr| attr.instance_of?(Model::Declarations::Attribute) }
+      end
+
+      def own_derived_attributes(entity)
+        Array(entity.attributes)
+          .select { |attr| attr.instance_of?(Model::Declarations::DerivedAttribute) }
+      end
+
+      def find_entity(schema, keyword, short_names = nil)
+        key = keyword.downcase
+        Array(schema.entities).find { |entity| entity.id&.downcase == key } ||
+          resolve_short_name(schema, key, short_names)
+      end
+
+      def resolve_short_name(schema, key, short_names)
+        return nil unless short_names.is_a?(Hash) && short_names[key]
+
+        find_entity(schema, short_names[key], nil)
+      end
+
+      def find_type(schema, keyword)
+        Array(schema.types).find { |type| type.id&.downcase == keyword.downcase }
+      end
+
+      def enumeration_items(schema, attr)
+        type = attr&.type
+        return Array(type.items) if type.is_a?(Model::DataTypes::Enumeration)
+
+        return nil unless type.is_a?(Model::References::SimpleReference)
+
+        declaration = find_type(schema, type.id.to_s)
+        underlying = declaration&.underlying_type
+        underlying.is_a?(Model::DataTypes::Enumeration) ? Array(underlying.items) : nil
+      end
+    end
+  end
+end

data/lib/expressir/p21.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Expressir
+  # ISO 10303-21 exchange-structure support (TODO.eengine/06).
+  module P21
+    autoload :Population, "#{__dir__}/p21/population"
+    autoload :Record, "#{__dir__}/p21/population"
+    autoload :ComplexRecord, "#{__dir__}/p21/population"
+    autoload :TypedValue, "#{__dir__}/p21/population"
+    autoload :Enumeration, "#{__dir__}/p21/population"
+    autoload :Binary, "#{__dir__}/p21/population"
+    autoload :Grammar, "#{__dir__}/p21/grammar"
+    autoload :Builder, "#{__dir__}/p21/builder"
+    autoload :Validator, "#{__dir__}/p21/validator"
+    autoload :Parser, "#{__dir__}/p21/parser"
+  end
+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.32".freeze
+    VERSION = "2.4.33".freeze
   end
 end

data/lib/expressir.rb

@@ -30,6 +30,7 @@ module Expressir
 
   autoload :Version, "#{__dir__}/expressir/version"
   autoload :Mapping, "#{__dir__}/expressir/mapping"
+  autoload :P21, "#{__dir__}/expressir/p21"
 
   # Error classes — autoload the same errors.rb file from each name.
   # The first reference triggers the load; the file defines all 21 classes.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: expressir
 version: !ruby/object:Gem::Version
-  version: 2.4.32
+  version: 2.4.33
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-14 00:00:00.000000000 Z
+date: 2026-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys
@@ -303,6 +303,16 @@ files:
 - TODO.bugs/29-validate-ascii-god-class.md
 - TODO.bugs/30-unicode-map-extraction.md
 - TODO.bugs/README.md
+- TODO.eengine/00-overview.md
+- TODO.eengine/01-resolution-diagnostics.md
+- TODO.eengine/02-check-catalog-completion.md
+- TODO.eengine/03-entity-computations.md
+- TODO.eengine/04-shtolo-rule-audit.md
+- TODO.eengine/05-shtolo-longform-flatten.md
+- TODO.eengine/06-population-p21.md
+- TODO.eengine/07-schema-compare-patch.md
+- TODO.eengine/08-official-corpus-gate.md
+- TODO.eengine/09-mim-mapping-parser.md
 - TODO.max-perf/01-restore-ci-green.md
 - TODO.max-perf/02-streaming-parse-path.md
 - TODO.max-perf/03-cli-parallel-opt-in.md
@@ -552,6 +562,7 @@ files:
 - lib/expressir/express/remark_scanner.rb
 - lib/expressir/express/resolve_references_model_visitor.rb
 - lib/expressir/express/schema_block_scanner.rb
+- lib/expressir/express/schema_compare.rb
 - lib/expressir/express/schema_head_formatter.rb
 - lib/expressir/express/schema_plain_source_formatter.rb
 - lib/expressir/express/schema_source_formatter.rb
@@ -664,6 +675,12 @@ files:
 - lib/expressir/model/supertype_expressions.rb
 - lib/expressir/model/supertype_expressions/binary_supertype_expression.rb
 - lib/expressir/model/supertype_expressions/oneof_supertype_expression.rb
+- lib/expressir/p21.rb
+- lib/expressir/p21/builder.rb
+- lib/expressir/p21/grammar.rb
+- lib/expressir/p21/parser.rb
+- lib/expressir/p21/population.rb
+- lib/expressir/p21/validator.rb
 - lib/expressir/package.rb
 - lib/expressir/package/builder.rb
 - lib/expressir/package/metadata.rb