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

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

data/lib/expressir/p21/validator.rb

@@ -20,13 +20,17 @@ module Expressir
       # 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)
+        typing = Typing.new(schema, short_names: short_names)
         notes = []
         check_file_schema(notes, population, schema)
+        check_sections(notes, population, schema)
         population.instances.each do |id, instance|
           if instance.is_a?(ComplexRecord)
-            check_complex(notes, schema, population, id, instance, short_names)
+            check_complex(notes, schema, population, id, instance,
+                          short_names, typing)
           else
-            check_simple(notes, schema, population, id, instance, short_names)
+            check_simple(notes, schema, population, id, instance,
+                         short_names, typing)
           end
         end
         notes
@@ -49,6 +53,24 @@ module Expressir
                           message: message)
       end
 
+      # Annex E (ISO 10303-21 clause 11.2): each DATA section's schema
+      # contexts must intersect the declared schema list.
+      def check_sections(notes, population, schema)
+        known = ([schema.id] +
+          Array(population.header["FILE_SCHEMA"]).flatten)
+          .filter_map { |name| name.to_s.downcase unless name.to_s.empty? }
+        Array(population.sections).each do |section|
+          next if section.contexts.empty?
+          next if section.contexts.any? do |context|
+            known.include?(context.to_s.downcase)
+          end
+
+          note!(notes, :p21_section_context, :warning, nil,
+                "DATA section '#{section.name}' context(s) " \
+                "#{section.contexts.join(', ')} are not in the schema list")
+        end
+      end
+
       def check_file_schema(notes, population, schema)
         declared = Array(population.header["FILE_SCHEMA"]).flatten.first
         return unless declared && schema.id
@@ -58,7 +80,8 @@ module Expressir
               "FILE_SCHEMA '#{declared}' does not match schema '#{schema.id}'")
       end
 
-      def check_simple(notes, schema, population, id, record, short_names)
+      def check_simple(notes, schema, population, id, record, short_names,
+                       typing)
         entity = find_entity(schema, record.keyword, short_names)
         unless entity
           note!(notes, :p21_unknown_entity, :error, id,
@@ -67,10 +90,11 @@ module Expressir
         end
 
         check_params(notes, schema, population, id, record.params,
-                     mapped_slots(entity))
+                     mapped_slots(entity), typing)
       end
 
-      def check_complex(notes, schema, population, id, complex, short_names)
+      def check_complex(notes, schema, population, id, complex, short_names,
+                        typing)
         pairs = complex.records.filter_map do |record|
           entity = find_entity(schema, record.keyword, short_names)
           unless entity
@@ -84,9 +108,14 @@ module Expressir
         return if pairs.empty?
 
         check_clique(notes, id, pairs.map { |_, entity| entity })
+        typing.issues(complex).each do |message|
+          note!(notes, :check_p21_complex_instantiation, :error, id,
+                "#{id}: #{message}")
+        end
         pairs.each do |record, entity|
           slots = explicit_attributes(entity).map { |attr| [attr, false] }
-          check_params(notes, schema, population, id, record.params, slots)
+          check_params(notes, schema, population, id, record.params, slots,
+                       typing)
         end
       end
 
@@ -120,14 +149,14 @@ module Expressir
         end + explicit_attributes(entity).map { |attr| [attr, false] }
       end
 
-      def check_params(notes, schema, population, id, params, slots)
+      def check_params(notes, schema, population, id, params, slots, typing)
         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?
+          next if value.nil? || value == :unset
 
           if derived_slot
             next if value == :derived
@@ -138,6 +167,11 @@ module Expressir
           end
 
           check_value(notes, schema, population, id, attr, value)
+          slot_type_issues(schema, population, attr&.type, value, typing)
+            .each do |(category, message)|
+            note!(notes, FINDING_IDS.fetch(category), :error, id,
+                  "#{id}: #{message}")
+          end
         end
       end
 
@@ -147,6 +181,9 @@ module Expressir
           return unless value.match?(/\A#\d+\z/)
 
           return if population.instances.key?(value)
+          # An id bound in the REFERENCE section names an external
+          # instance (ISO 10303-21 clause 10); resolution is remote.
+          return if population.references.key?(value)
 
           note!(notes, :p21_unknown_reference, :error, id,
                 "#{id}: reference #{value} has no instance")
@@ -208,6 +245,380 @@ module Expressir
         underlying = declaration&.underlying_type
         underlying.is_a?(Model::DataTypes::Enumeration) ? Array(underlying.items) : nil
       end
+
+      # ---- TODO.instance/01: value/type conformance ----
+      # ISO 10303-11 ch.8 domains over the clause-12 slots. Every
+      # finding carries its clause: simple types 8.1.x, aggregation
+      # types 8.2.x, named types 8.4.x, attribute domains 9.2.1,
+      # complex instantiation 9.2.5/9.2.5.2, domain rules 9.2.2.2.
+
+      FINDING_IDS = {
+        domain: :check_p21_value_domain,
+        aggregate: :check_p21_aggregate,
+        reference: :check_p21_reference_type,
+        select: :check_p21_select_arm,
+        complex: :check_p21_complex_instantiation,
+      }.freeze
+      MAX_TYPE_DEPTH = 16
+      PRIMITIVE_DOMAINS = {
+        Model::DataTypes::Integer => ["INTEGER", "an unquoted integer (8.1.3)"],
+        Model::DataTypes::Real => ["REAL", "a number (8.1.2)"],
+        Model::DataTypes::Number => ["NUMBER", "a number (8.1.1)"],
+        Model::DataTypes::String => ["STRING", "a single-quoted string (8.1.6)"],
+        Model::DataTypes::Binary => ["BINARY", "a binary literal (8.1.7)"],
+        Model::DataTypes::Boolean => ["BOOLEAN", ".T. or .F. (8.1.5)"],
+        Model::DataTypes::Logical => ["LOGICAL", ".T., .F. or .U. (8.1.4)"],
+      }.freeze
+      private_constant :FINDING_IDS, :MAX_TYPE_DEPTH, :PRIMITIVE_DOMAINS
+
+      def slot_type_issues(schema, population, type, value, typing, depth = 0,
+                           seen = {}.compare_by_identity)
+        return [] unless type.is_a?(Model::ModelElement)
+        return [] if depth >= MAX_TYPE_DEPTH
+        if value.is_a?(TypedValue)
+          return typed_value_issues(schema, population, type, value, typing,
+                                    depth, seen)
+        end
+
+        case type
+        when Model::Declarations::Type
+          defined_type_issues(schema, population, type, value, typing,
+                              depth, seen)
+        when Model::Declarations::Entity
+          reference_issues(schema, population, value, type, typing)
+        when Model::References::SimpleReference
+          reference_slot_issues(schema, population, type, value, typing,
+                                depth, seen)
+        when Model::DataTypes::List, Model::DataTypes::Array,
+             Model::DataTypes::Set, Model::DataTypes::Bag
+          aggregate_issues(schema, population, type, value, typing, depth, seen)
+        when Model::DataTypes::Select
+          select_issues(schema, population, type, value, typing, depth, seen)
+        when Model::DataTypes::Enumeration
+          [] # 8.4.1 membership is checked by check_value
+        else
+          primitive_issues(type, value)
+        end
+      end
+
+      def reference_slot_issues(schema, population, type, value, typing,
+                                depth, seen)
+        declaration = find_type(schema, type.id.to_s)
+        if declaration.is_a?(Model::Declarations::Type)
+          return defined_type_issues(schema, population, declaration, value,
+                                     typing, depth, seen)
+        end
+
+        entity = find_entity(schema, type.id.to_s)
+        return [] unless entity
+
+        reference_issues(schema, population, value, entity, typing)
+      end
+
+      def defined_type_issues(schema, population, declaration, value, typing,
+                              depth, seen)
+        return [] if seen.include?(declaration)
+
+        seen[declaration] = true
+        domain_rule_issues(schema, value, declaration) +
+          slot_type_issues(schema, population, declaration.underlying_type,
+                           value, typing, depth + 1, seen)
+      end
+
+      def domain_rule_issues(schema, value, declaration)
+        self_value = domain_value(value, declaration)
+        return [] if self_value.nil?
+
+        Array(declaration.where_rules).filter_map do |rule|
+          next unless rule.expression
+
+          env = Eval::Environment.new(schema: schema).define("self", self_value)
+          result = Eval::Expression.evaluate(rule.expression, env)
+          next unless logical_false?(result)
+
+          [:domain,
+           "value violates domain rule '#{rule.id}' of " \
+           "TYPE '#{declaration.id}' (9.2.2.2)"]
+        rescue StandardError
+          next # an unevaluable domain rule is not a finding here
+        end
+      end
+
+      def domain_value(value, declaration)
+        case value
+        when Integer, Float then value
+        when String then reference?(value) ? nil : value
+        when Enumeration
+          Eval::Values::Enumeration.new(type: declaration.id, item: value.name)
+        when Binary then Eval::Values::Binary.new(bits: value.hex)
+        end
+      end
+
+      def logical_false?(result)
+        return true if [false, Eval::Values::LOGICAL_FALSE].include?(result)
+        return result.value == Eval::Values::LOGICAL_FALSE if result.is_a?(Eval::Values::Logical)
+
+        false
+      end
+
+      def primitive_issues(type, value)
+        domain, expectation = PRIMITIVE_DOMAINS[type.class]
+        return [] unless domain
+
+        ok = case type
+             when Model::DataTypes::Integer then value.is_a?(Integer)
+             when Model::DataTypes::Real, Model::DataTypes::Number
+               value.is_a?(Numeric)
+             when Model::DataTypes::String
+               value.is_a?(String) && !reference?(value)
+             when Model::DataTypes::Binary then value.is_a?(Binary)
+             when Model::DataTypes::Boolean, Model::DataTypes::Logical
+               logical_literal?(value)
+             end
+        return [] if ok
+
+        [[:domain, "#{domain} slot requires #{expectation}"]]
+      end
+
+      def logical_literal?(value)
+        return true if [true, false].include?(value)
+
+        value.is_a?(Enumeration) && %w[T F U].include?(value.name.to_s.upcase)
+      end
+
+      def reference_issues(_schema, population, value, entity, typing)
+        return [] unless reference?(value)
+
+        target = population.instances[value]
+        return [] unless target
+
+        conformed = typing.of(target)
+        return [] if conformed.any? do |candidate|
+          candidate.id&.safe_downcase == entity.id&.safe_downcase
+        end
+
+        [[:reference,
+          "reference #{value} conforms to " \
+          "#{conformed.filter_map(&:id).join(', ')} but '#{entity.id}' is " \
+          "required (9.2.1)"]]
+      end
+
+      def typed_value_issues(schema, population, _type, value, typing, depth,
+                             seen)
+        entity = find_entity(schema, value.keyword)
+        if entity
+          return reference_issues(schema, population, value.value, entity,
+                                  typing)
+        end
+
+        declaration = find_type(schema, value.keyword)
+        return [] unless declaration.is_a?(Model::Declarations::Type)
+
+        underlying = declaration.underlying_type
+        inner = value.value
+        if inner.is_a?(Array) && inner.size == 1 && !aggregate?(underlying)
+          inner = inner.first
+        end
+        slot_type_issues(schema, population, underlying, inner, typing,
+                         depth + 1, seen)
+      end
+
+      def aggregate?(type)
+        type.is_a?(Model::DataTypes::List) || type.is_a?(Model::DataTypes::Array) ||
+          type.is_a?(Model::DataTypes::Set) || type.is_a?(Model::DataTypes::Bag)
+      end
+
+      def aggregate_issues(schema, population, type, value, typing, depth,
+                           seen)
+        unless value.is_a?(Array)
+          return [[:domain, "#{aggregate_name(type)} attribute requires an " + "aggregate value (#{aggregate_section(type)})"]]
+        end
+
+        aggregate_bound_issues(type, value) +
+          aggregate_unique_issues(type, value) +
+          aggregate_element_issues(schema, population, type, value, typing,
+                                   depth, seen)
+      end
+
+      def aggregate_bound_issues(type, value)
+        lower, upper = aggregate_bounds(type)
+        issues = []
+        if lower && value.size < lower
+          issues << [:aggregate, "#{aggregate_name(type)} has #{value.size} " + "element(s), below the bound #{lower} " + "(#{aggregate_section(type)})"]
+        end
+        if upper && value.size > upper
+          issues << [:aggregate, "#{aggregate_name(type)} has #{value.size} " + "element(s), above the bound #{upper} " + "(#{aggregate_section(type)})"]
+        end
+        issues
+      end
+
+      def aggregate_bounds(type)
+        [bound_value(type.bound1), bound_value(type.bound2)]
+      end
+
+      def bound_value(bound)
+        return nil unless bound.is_a?(Model::Literals::Integer)
+
+        bound.value.to_i
+      end
+
+      def aggregate_unique_issues(type, value)
+        return [] unless type.is_a?(Model::DataTypes::Set)
+
+        keys = value.map { |element| p21_value_key(element) }
+        return [] if keys.uniq.size == keys.size
+
+        [[:aggregate, "SET has duplicate elements (8.2.4)"]]
+      end
+
+      def aggregate_element_issues(schema, population, type, value, typing,
+                                   depth, _seen)
+        issues = []
+        value.each_with_index do |element, index|
+          unset = element.nil? || element == :unset
+          if unset
+            next unless type.is_a?(Model::DataTypes::Array) && !type.optional
+
+            issues << [:aggregate, "ARRAY element #{index} is unset but the array is not OPTIONAL (8.2.1)"]
+            next
+          end
+
+          # Sibling elements re-walk the same types with different
+          # values: only the walk along one nesting path shares `seen`.
+          slot_type_issues(schema, population, type.base_type, element,
+                           typing, depth + 1, {}.compare_by_identity)
+            .each do |(category, message)|
+            issues << [category, "element #{index}: #{message}"]
+          end
+        end
+        issues
+      end
+
+      def select_issues(schema, population, type, value, typing, depth, seen)
+        arms = select_arms(schema, type, seen)
+        return [] if arms.empty?
+
+        select_arm_issues(schema, population, value, arms, typing, depth, seen)
+      end
+
+      # Leaf domains of a SELECT: item entities, item defined types, and
+      # nested selects, plus the BASED_ON chain (8.4.2).
+      def select_arms(schema, type, seen)
+        return [] if seen.include?(type)
+
+        seen[type] = true
+        arms = []
+        Array(type.items).each do |item|
+          next unless item.respond_to?(:id) && item.id
+
+          declaration = find_type(schema, item.id.to_s)
+          if declaration.is_a?(Model::Declarations::Type)
+            underlying = declaration.underlying_type
+            if underlying.is_a?(Model::DataTypes::Select)
+              arms.concat(select_arms(schema, underlying, seen))
+            else
+              arms << [:type, declaration]
+            end
+            next
+          end
+
+          entity = find_entity(schema, item.id.to_s)
+          arms << [:entity, entity] if entity
+        end
+        base = based_on_select(schema, type)
+        arms.concat(select_arms(schema, base, seen)) if base
+        arms
+      end
+
+      def based_on_select(schema, type)
+        based = type.based_on
+        return nil unless based.respond_to?(:id) && based.id
+
+        declaration = find_type(schema, based.id.to_s)
+        return nil unless declaration.is_a?(Model::Declarations::Type)
+
+        underlying = declaration.underlying_type
+        underlying.is_a?(Model::DataTypes::Select) ? underlying : nil
+      end
+
+      def select_arm_issues(schema, population, value, arms, typing, depth,
+                            seen)
+        if reference?(value)
+          target = population.instances[value]
+          return [] unless target
+
+          conformed = typing.of(target)
+          ok = arms.any? do |(kind, node)|
+            kind == :entity &&
+              conformed.any? do |candidate|
+                candidate.id&.safe_downcase == node.id&.safe_downcase
+              end
+          end
+          return [] if ok
+
+          return [[:select, "reference #{value} fits no arm of the SELECT (8.4.2)"]]
+        end
+
+        if value.is_a?(TypedValue)
+          ok = arms.any? do |(_kind, node)|
+            node.id&.safe_downcase == value.keyword&.downcase
+          end
+          return [] if ok
+
+          return [[:select, "typed value '#{value.keyword}' fits no arm of the SELECT (8.4.2)"]]
+        end
+
+        return [] if value.is_a?(Enumeration) # 8.4.1 membership via check_value
+
+        literal_ok = arms.any? do |(kind, node)|
+          kind == :type && slot_type_issues(
+            schema, population, node.underlying_type, value, typing,
+            depth + 1, seen
+          ).empty?
+        end
+        return [] if literal_ok
+
+        [[:select, "value #{p21_display(value)} fits no arm of the SELECT (8.4.2)"]]
+      end
+
+      def reference?(value)
+        value.is_a?(String) && value.match?(/\A#\d+\z/)
+      end
+
+      def p21_value_key(value)
+        case value
+        when Enumeration then [:enum, value.name&.downcase]
+        when Binary then [:binary, value.hex]
+        when Array then [:list, *value.map { |element| p21_value_key(element) }]
+        else [:value, value]
+        end
+      end
+
+      def p21_display(value)
+        case value
+        when Enumeration then ".#{value.name}."
+        when Binary then "%#{value.hex}"
+        else value.to_s
+        end
+      end
+
+      def aggregate_name(type)
+        case type
+        when Model::DataTypes::List then "LIST"
+        when Model::DataTypes::Array then "ARRAY"
+        when Model::DataTypes::Set then "SET"
+        else "BAG"
+        end
+      end
+
+      def aggregate_section(type)
+        case type
+        when Model::DataTypes::List then "8.2.2"
+        when Model::DataTypes::Array then "8.2.1"
+        when Model::DataTypes::Set then "8.2.4"
+        else "8.2.3"
+        end
+      end
     end
   end
 end