expressir 2.4.32 → 2.4.33

data/lib/expressir/express/schema_compare.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    # Structural diff of two schemata with a machine-applicable patch
+    # (TODO.eengine/07; eeng --compare/--patch semantics, plugin/p11
+    # compare entry). Declarations match by canonical path
+    # `schema.item`; entity attributes get their own sub-deltas at
+    # `schema.item.attribute` carrying types, optionality and
+    # aggregates inside the signature.
+    #
+    # Interfaces are out of scope: the patch target is a flattened
+    # (longform) schema, which has none.
+    module SchemaCompare
+      # `node` carries the revised declaration for :added and :changed
+      # (nil for :removed) so {SchemaPatch.apply} can rebuild.
+      Delta = Struct.new(:op, :path, :node, keyword_init: true)
+
+      # Resolution artifacts and presentation metadata are not part of
+      # a declaration's structure.
+      SIGNATURE_IGNORE = %w[source include_source remarks remark_items
+                            ref base_path file].freeze
+
+      COLLECTIONS = %i[constants types entities subtype_constraints
+                       functions rules procedures].freeze
+
+      NODE_COLLECTION = {
+        "Expressir::Model::Declarations::Constant" => :constants,
+        "Expressir::Model::Declarations::Type" => :types,
+        "Expressir::Model::Declarations::Entity" => :entities,
+        "Expressir::Model::Declarations::SubtypeConstraint" => :subtype_constraints,
+        "Expressir::Model::Declarations::Function" => :functions,
+        "Expressir::Model::Declarations::Rule" => :rules,
+        "Expressir::Model::Declarations::Procedure" => :procedures,
+      }.freeze
+
+      module_function
+
+      def compare(base, revised)
+        COLLECTIONS.flat_map { |collection| collection_deltas(base, revised, collection) }
+      end
+
+      def collection_deltas(base, revised, collection)
+        base_items = index(base, collection)
+        revised_items = index(revised, collection)
+        deltas = (revised_items.keys - base_items.keys).map do |path|
+          Delta.new(op: :added, path: path, node: revised_items[path])
+        end
+        (base_items.keys - revised_items.keys).each do |path|
+          deltas << Delta.new(op: :removed, path: path, node: nil)
+        end
+        (base_items.keys & revised_items.keys).each do |path|
+          old_item = base_items[path]
+          new_item = revised_items[path]
+          next if signature(old_item) == signature(new_item)
+
+          deltas << Delta.new(op: :changed, path: path, node: new_item)
+          next unless new_item.is_a?(Model::Declarations::Entity)
+
+          deltas.concat(attribute_deltas(old_item, new_item, path))
+        end
+        deltas
+      end
+
+      def attribute_deltas(old_item, new_item, path)
+        old_attrs = index_by_id(Array(old_item.attributes))
+        new_attrs = index_by_id(Array(new_item.attributes))
+        deltas = (new_attrs.keys - old_attrs.keys).map do |name|
+          Delta.new(op: :added, path: "#{path}.#{name}",
+                    node: new_attrs[name])
+        end
+        (old_attrs.keys - new_attrs.keys).each do |name|
+          deltas << Delta.new(op: :removed, path: "#{path}.#{name}", node: nil)
+        end
+        (old_attrs.keys & new_attrs.keys).each do |name|
+          next if signature(old_attrs[name]) == signature(new_attrs[name])
+
+          deltas << Delta.new(op: :changed, path: "#{path}.#{name}",
+                              node: new_attrs[name])
+        end
+        deltas
+      end
+
+      def index_by_id(items)
+        items.filter_map { |item| [item.id&.downcase, item] if item.id }.to_h
+      end
+
+      def index(schema, collection)
+        index_by_id(Array(schema.send(collection)))
+          .transform_keys { |key| "#{schema.id.downcase}.#{key}" }
+      end
+
+      def signature(node)
+        strip(node.to_hash)
+      end
+
+      def strip(value)
+        case value
+        when Hash
+          value.each_with_object({}) do |(key, inner), out|
+            next if SIGNATURE_IGNORE.include?(key.to_s)
+
+            out[key] = strip(inner)
+          end
+        when Array then value.map { |inner| strip(inner) }
+        else value
+        end
+      end
+    end
+
+    # Applies {SchemaCompare} deltas to a schema model, returning the
+    # revised schema. The base schema is deep-copied through the
+    # lutaml-model round trip; the input schema is never mutated.
+    module SchemaPatch
+      module_function
+
+      def apply(base, deltas)
+        revised = base.class.from_hash(base.to_hash)
+        item_deltas, attribute_deltas = deltas.partition do |delta|
+          delta.path.split(".").size == 2
+        end
+        item_deltas.each { |delta| apply_item(revised, delta) }
+        # An item-level :added/:changed node already carries the final
+        # attribute list; its sub-deltas are informational only.
+        replaced_ops = %i[added changed].freeze
+        replaced = item_deltas
+          .select { |delta| replaced_ops.include?(delta.op) }
+          .map(&:path)
+        attribute_deltas
+          .reject { |delta| replaced.include?(delta.path.split(".")[0..1].join(".")) }
+          .each { |delta| apply_attribute(revised, delta) }
+        revised
+      end
+
+      def apply_item(schema, delta)
+        item_key = delta.path.split(".").last.downcase
+        collection = if delta.op == :added
+                       schema.send(SchemaCompare::NODE_COLLECTION.fetch(delta.node.class.name))
+                     else
+                       live_collection(schema, item_key)
+                     end
+        return unless collection
+
+        case delta.op
+        when :added then collection << delta.node
+        when :removed then collection.delete_if { |item| key(item) == item_key }
+        when :changed
+          index = collection.index { |item| key(item) == item_key }
+          return unless index
+
+          collection.delete_at(index)
+          collection.insert(index, delta.node)
+        end
+      end
+
+      def apply_attribute(schema, delta)
+        segments = delta.path.split(".")
+        item = SchemaCompare.index_by_id(all_declarations(schema))[segments[1].downcase]
+        return unless item
+
+        attr_key = segments[2]
+        attrs = Array(item.attributes)
+        case delta.op
+        when :added
+          item.attributes = [*attrs, delta.node]
+        when :removed
+          item.attributes = attrs.reject { |attr| key(attr) == attr_key }
+        when :changed
+          index = attrs.index { |attr| key(attr) == attr_key }
+          return unless index
+
+          item.attributes = attrs
+          item.attributes.delete_at(index)
+          item.attributes.insert(index, delta.node)
+        end
+      end
+
+      def live_collection(schema, item_key)
+        SchemaCompare::COLLECTIONS.map { |name| schema.send(name) }
+          .find do |collection|
+          Array(collection).any? { |item| key(item) == item_key }
+        end
+      end
+
+      def all_declarations(schema)
+        SchemaCompare::COLLECTIONS.flat_map { |name| Array(schema.send(name)) }
+      end
+
+      def key(item)
+        item.id&.downcase
+      end
+    end
+  end
+end

data/lib/expressir/express/shtolo.rb

@@ -295,10 +295,32 @@ module Expressir
         convert_generic_entities!(artifact)
         convert_renamed_attributes!(artifact)
         rewrite_qualified_strings!(artifact)
+        add_provenance_remark!(artifact)
 
         artifact
       end
 
+      # G.1.10: optional embedded provenance remark — if any schema
+      # name is kept in the longform, ALL contributing schemas are
+      # recorded (`schema = <id> [schema_version_id = '<v>'];`, order
+      # insignificant).
+      def add_provenance_remark!(schema)
+        names = closure.values.map(&:id).sort
+        return if names.empty?
+
+        remarks = ["Original 2003 schemas:"] + names.map do |id|
+          contributing = closure.values.find { |s| s.id == id }
+          version = contributing&.version&.id
+          line = "schema = #{id};"
+          line = "schema = #{id} schema_version_id = '#{version}';" if version
+          line
+        end
+        schema.remark_items = [
+          Model::Declarations::RemarkItem.new(id: "provenance", remarks: remarks),
+          *Array(schema.remark_items),
+        ]
+      end
+
       # G.1.9 prune pass: the artifact keeps only what stays visible
       # and reachable. Runs before the stage-2 rewrites so they never
       # see declarations the longform would drop.

data/lib/expressir/express.rb

@@ -43,6 +43,8 @@ module Expressir
     autoload :SchemaPlainSourceFormatter,
              "#{__dir__}/express/schema_plain_source_formatter"
     autoload :SchemaSourceFormatter, "#{__dir__}/express/schema_source_formatter"
+    autoload :SchemaCompare, "#{__dir__}/express/schema_compare"
+    autoload :SchemaPatch, "#{__dir__}/express/schema_compare"
     autoload :ScopeResolver, "#{__dir__}/express/scope_resolver"
     autoload :LazyRepository, "#{__dir__}/express/lazy_repository"
     autoload :SmrlXml, "#{__dir__}/express/smrl_xml"

data/lib/expressir/model/declarations/entity.rb

@@ -56,6 +56,138 @@ module Expressir
             *remark_items,
           ]
         end
+
+        # eeng compute-inheritance: the full supertype closure, nearest
+        # supertype first, cycle-safe. Cross-schema supertypes resolve
+        # through the enclosing repository.
+        # @return [Array<Entity>]
+        def supertype_closure
+          closure = []
+          visited = { id&.safe_downcase => true }
+          queue = Array(subtype_of).map { |ref| ref.respond_to?(:id) ? ref.id : ref }
+          while (name = queue.shift)
+            key = name&.safe_downcase
+            next if key.nil? || visited.key?(key)
+
+            supertype = find_supertype_entity(key)
+            next unless supertype
+
+            visited[key] = true
+            closure << supertype
+            queue.concat(Array(supertype.subtype_of).map do |ref|
+              ref.respond_to?(:id) ? ref.id : ref
+            end)
+          end
+          closure
+        end
+
+        # Explicit attributes inherited from the supertype closure,
+        # nearest supertype first, skipping ids this entity (or a
+        # nearer ancestor) redeclares.
+        # @return [Array<ExplicitAttribute>]
+        def inherited_explicit_attributes
+          claimed = explicit_only(Array(attributes)).filter_map(&:id).map(&:safe_downcase)
+          closure = supertype_closure
+          closure.flat_map do |supertype|
+            explicit_only(Array(supertype.attributes)).filter_map do |attr|
+              next nil unless attr.id
+
+              key = attr.id.safe_downcase
+              next nil if claimed.include?(key)
+
+              claimed << key
+              attr
+            end
+          end
+        end
+
+        # Derived attributes accumulated from the supertype closure.
+        # @return [Array<DerivedAttribute>]
+        def inherited_derived_attributes
+          closure = supertype_closure
+          seen = {}
+          closure.flat_map do |supertype|
+            derived_attribute_items(supertype).filter_map do |attr|
+              next nil unless attr.id
+
+              key = attr.id.safe_downcase
+              next nil if seen.key?(key)
+
+              seen[key] = true
+              attr
+            end
+          end
+        end
+
+        # Inverse attributes accumulated from the supertype closure.
+        # @return [Array<InverseAttribute>]
+        def inherited_inverse_attributes
+          closure = supertype_closure
+          seen = {}
+          closure.flat_map do |supertype|
+            inverse_attribute_items(supertype).filter_map do |attr|
+              next nil unless attr.id
+
+              key = attr.id.safe_downcase
+              next nil if seen.key?(key)
+
+              seen[key] = true
+              attr
+            end
+          end
+        end
+
+        # All explicit attributes: own + inherited (eeng
+        # explicit-attrs materialization).
+        # @return [Array<ExplicitAttribute>]
+        def all_explicit_attributes
+          [*explicit_only(Array(attributes)), *inherited_explicit_attributes]
+        end
+
+        private
+
+        # Entity#attributes carries every attribute kind; the explicit
+        # kind is Expressir::Model::Declarations::Attribute.
+        # DerivedAttribute/InverseAttribute subclass Attribute, so the
+        # explicit kind is the exact base class.
+        def explicit_only(attrs)
+          attrs.select { |a| a.instance_of?(Expressir::Model::Declarations::Attribute) }
+        end
+
+        # The Ruby parse path parks every attribute kind in `attributes`
+        # (typed by class); the core path fills derived_attributes/
+        # inverse_attributes instead. Both layouts resolve to the same
+        # items here.
+        def derived_attribute_items(entity)
+          own = Array(entity.derived_attributes)
+          return own if own.any?
+
+          Array(entity.attributes).grep(Expressir::Model::Declarations::DerivedAttribute)
+        end
+
+        def inverse_attribute_items(entity)
+          own = Array(entity.inverse_attributes)
+          return own if own.any?
+
+          Array(entity.attributes).grep(Expressir::Model::Declarations::InverseAttribute)
+        end
+
+        def find_supertype_entity(key)
+          container = parent
+          container = container.parent while container &&
+              !container.is_a?(Model::Repository) &&
+              !container.is_a?(Model::ExpFile)
+          return nil unless container.respond_to?(:schemas)
+
+          container.schemas.each do |foreign|
+            next unless foreign.respond_to?(:entities)
+
+            foreign.entities.each do |candidate|
+              return candidate if candidate.id&.safe_downcase == key
+            end
+          end
+          nil
+        end
       end
     end
   end

data/lib/expressir/model/declarations/schema.rb

@@ -127,6 +127,19 @@ module Expressir
           @formatted_hyperlinked_adoc ||= Expressir::Express::AdocSourceFormatter.format(self)
         end
 
+        USE_ITEM_KINDS = [
+          Expressir::Model::Declarations::Entity,
+          Expressir::Model::Declarations::Type,
+        ].freeze
+
+        REFERENCE_ITEM_KINDS = [
+          Expressir::Model::Declarations::Constant,
+          Expressir::Model::Declarations::Entity,
+          Expressir::Model::Declarations::Function,
+          Expressir::Model::Declarations::Procedure,
+          Expressir::Model::Declarations::Type,
+        ].freeze
+
         private
 
         # @param [String] id
@@ -142,6 +155,7 @@ module Expressir
         end
 
         # @return [Array<InterfacedItem>]
+
         def interfaced_items
           return [] unless parent
 
@@ -151,6 +165,11 @@ module Expressir
           end.compact
         end
 
+        # ISO 10303-11 implicit interfacing: USE exposes entities and
+        # types only; REFERENCE has no implicit interfacing. Listed
+        # items follow eeng resolve-interface: use-from resolves via
+        # find-type/entity, reference-from via the 5-kind or-chain.
+
         # Direct items of one interface plus the items visible through
         # the foreign schema's own USE interfaces (transitive USE
         # visibility, eeng :use-only → :use-from recursion).
@@ -171,16 +190,23 @@ module Expressir
           end
 
           own = if interface.items.empty?
-                  safe_children.map do |base_item|
-                    create_interfaced_item(base_item.id, base_item)
+                  if interface.kind == Interface::REFERENCE
+                    []
+                  else
+                    safe_children.filter_map do |base_item|
+                      next nil unless USE_ITEM_KINDS.any? { |k| base_item.is_a?(k) }
+
+                      create_interfaced_item(base_item.id, base_item)
+                    end
                   end
                 else
                   interface.items.filter_map do |item|
                     base_item = children_by_id[item.ref.id.safe_downcase]
-                    if base_item
-                      create_interfaced_item(item.id || base_item.id,
-                                             base_item)
-                    end
+                    next nil unless base_item
+                    next nil unless item_kind_interfacable?(interface.kind, base_item)
+
+                    create_interfaced_item(item.id || base_item.id,
+                                           base_item)
                   end
                 end
 
@@ -197,6 +223,11 @@ module Expressir
           end.flatten
         end
 
+        def item_kind_interfacable?(kind, node)
+          kinds = kind == Interface::REFERENCE ? REFERENCE_ITEM_KINDS : USE_ITEM_KINDS
+          kinds.any? { |k| node.is_a?(k) }
+        end
+
         # Find a foreign schema by name: same file first, then the
         # enclosing repository (expressir's compiled/batch repository).
         def foreign_schema(name)

data/lib/expressir/p21/builder.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Expressir
+  module P21
+    # Turns a {Grammar} capture tree into a {Population}.
+    module Builder
+      module_function
+
+      def build(tree)
+        header = build_header(tree[:header_section])
+        instances = build_instances(tree[:data_section])
+        Population.new(header: header, instances: instances)
+      end
+
+      def build_header(section)
+        Array(section[:header_entity]).each_with_object({}) do |entry, hash|
+          record = entry[:simple_record]
+          hash[record_keyword(record)] = record_params(record)
+        end
+      end
+
+      def build_instances(section)
+        list = section[:instance_list]
+        entries = list.is_a?(Array) ? list : [list]
+        entries.each_with_object({}) do |entry, hash|
+          if (complex = entry[:complex_entity_instance])
+            hash[instance_id(complex)] = build_complex(complex)
+          elsif (simple = entry[:simple_entity_instance])
+            record = simple[:simple_record]
+            hash[instance_id(simple)] = Record.new(record_keyword(record),
+                                                   record_params(record))
+          end
+        end
+      end
+
+      def instance_id(body)
+        "##{body[:entity_instance_name].to_s.delete_prefix('#')}"
+      end
+
+      def build_complex(body)
+        subs = body[:subsuper_record]
+        subs = [subs] unless subs.is_a?(Array)
+        records = subs.map do |sub|
+          record = sub[:simple_record]
+          Record.new(record_keyword(record), record_params(record))
+        end
+        ComplexRecord.new(records)
+      end
+
+      def record_keyword(record)
+        record[:keyword].to_s.delete_prefix("!")
+      end
+
+      # A parameter_list capture is a hash when there is a single parameter
+      # and an array of {parameter: ...} entries otherwise.
+      def parameter_list_values(capture)
+        return [] if capture.nil?
+
+        entries = capture.is_a?(Array) ? capture : [capture]
+        entries.map { |entry| build_value(entry[:parameter]) }
+      end
+
+      def record_params(record)
+        parameter_list_values(record[:parameter_list])
+      end
+
+      def build_value(param)
+        if (typed = param[:typed_parameter])
+          TypedValue.new(typed[:keyword].to_s.delete_prefix("!"),
+                         parameter_list_values(typed[:parameter_list]))
+        elsif param[:parameter_list]
+          parameter_list_values(param[:parameter_list])
+        elsif param[:entity_instance_name]
+          "##{param[:entity_instance_name].to_s.delete_prefix('#')}"
+        elsif param[:number_literal]
+          text = param[:number_literal].to_s
+          text.match?(/[.Ee]/) ? text.to_f : text.to_i
+        elsif param[:enumeration]
+          Enumeration.new(param[:enumeration].to_s.delete_prefix(".").delete_suffix("."))
+        elsif param[:binary_literal]
+          Binary.new(param[:binary_literal].to_s.delete_prefix('"').delete_suffix('"'))
+        elsif param[:string_literal]
+          param[:string_literal].to_s[1..-2].gsub("''", "'")
+        elsif param[:unset]
+          :unset
+        elsif param[:derived]
+          :derived
+        end
+      end
+    end
+  end
+end

data/lib/expressir/p21/grammar.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "parsanol"
+
+module Expressir
+  module P21
+    # ISO 10303-21 exchange-structure grammar (TODO.eengine/06 step 1).
+    # Parses the HEADER section and the DATA section's instance list
+    # into a capture tree; {Expressir::P21::PopulationBuilder} turns
+    # the tree into a {Expressir::P21::Population}.
+    #
+    # Reference: ISO 10303-21 exchange structure grammar
+    # (`~/src/mn/iso-10303-detached-docs/sources/iso-10303-21*/`);
+    # scope ladder in TODO.eengine/06 — the supported subset is the
+    # header FILE_* entities plus simple/complex data instances with
+    # lists, typed parameters, references, enumerations, binaries,
+    # strings, unset ($) and derived (*).
+    class Grammar < Parsanol::Parser
+      root(:exchange_structure)
+
+      rule(:comment) { str("/*") >> (str("*/").absent? >> any).repeat >> str("*/") }
+      rule(:ws?) { (match[" \t\r\n"] | comment).repeat }
+      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(:string_literal) do
+        # ISO 10303-21: doubled quotes are escaped quotes
+        str("'") >> ((str("'").absent? >> any) | str("''")).repeat >> str("'")
+      end
+      rule(:binary_literal) { str('"') >> match["0-9A-Fa-f"].repeat >> str('"') }
+      rule(:enumeration) { str(".") >> match["A-Za-z0-9_"].repeat(1) >> str(".") }
+      rule(:unset) { str("$") }
+      rule(:derived) { str("*") }
+
+      rule(:parameter_list) do
+        str("(") >> ws? >>
+          (parameter.as(:parameter) >>
+            (str(",") >> ws? >> parameter.as(:parameter)).repeat).maybe >>
+          str(")") >> ws?
+      end
+
+      rule(:typed_parameter) do
+        keyword.as(:keyword) >> ws? >> parameter_list.as(:parameter_list)
+      end
+      rule(:list_parameter) { parameter_list }
+
+      rule(:number_literal) do
+        match["+-"].maybe >> match["0-9"].repeat(1) >>
+          (str(".") >> match["0-9"].repeat(1)).maybe >>
+          (match["Ee"] >> match["+-"].maybe >> match["0-9"].repeat(1)).maybe
+      end
+
+      rule(:parameter) do
+        typed_parameter.as(:typed_parameter) |
+          list_parameter.as(:parameter_list) |
+          entity_instance_name.as(:entity_instance_name) |
+          number_literal.as(:number_literal) |
+          enumeration.as(:enumeration) |
+          binary_literal.as(:binary_literal) |
+          string_literal.as(:string_literal) |
+          unset.as(:unset) | derived.as(:derived)
+      end
+
+      rule(:simple_record) do
+        keyword.as(:keyword) >> ws? >> parameter_list.as(:parameter_list)
+      end
+
+      rule(:subsuper_record) do
+        str("(") >> ws? >> simple_record.as(:simple_record).repeat(1) >>
+          str(")") >> ws?
+      end
+
+      rule(:simple_entity_instance) do
+        (entity_instance_name.as(:entity_instance_name) >> ws? >>
+          str("=") >> ws? >> simple_record.as(:simple_record) >>
+          str(";") >> ws?).as(:simple_entity_instance)
+      end
+      rule(:complex_entity_instance) do
+        (entity_instance_name.as(:entity_instance_name) >> ws? >>
+          str("=") >> ws? >> subsuper_record.as(:subsuper_record) >>
+          str(";") >> ws?).as(:complex_entity_instance)
+      end
+      rule(:entity_instance) { complex_entity_instance | simple_entity_instance }
+
+      rule(:header_entity) do
+        simple_record.as(:simple_record) >> str(";") >> ws?
+      end
+      rule(:header_section) do
+        str("HEADER;") >> ws? >> header_entity.repeat(1).as(:header_entity) >>
+          str("ENDSEC;") >> ws?
+      end
+      rule(:data_section) do
+        str("DATA;") >> ws? >>
+          (str("(") >> ws? >> parameter >> str(");") >> ws?).maybe >>
+          entity_instance.repeat.as(:instance_list) >>
+          str("ENDSEC;") >> ws?
+      end
+      rule(:exchange_structure) do
+        ws? >> str("ISO-10303-21;") >> ws? >>
+          header_section.as(:header_section) >>
+          data_section.as(:data_section) >>
+          str("END-ISO-10303-21;") >> ws?
+      end
+    end
+  end
+end

data/lib/expressir/p21/parser.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Expressir
+  module P21
+    # Facade: parse an ISO 10303-21 exchange structure into a
+    # {Population} (TODO.eengine/06 step 1).
+    module Parser
+      module_function
+
+      def parse(source)
+        tree = Grammar.new.parse(source)
+        Builder.build(tree)
+      end
+    end
+  end
+end