expressir 2.4.31-aarch64-linux → 2.4.36-aarch64-linux

data/lib/expressir/express/dialect.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Expressir
+  module Express
+    # Edition awareness for ISO 10303-11. The grammar accepts the union
+    # of both editions' text syntax; edition gating is reported by the
+    # Checker so a 1994 consumer sees exactly which declarations use
+    # 2004-only constructs, and a 2004 consumer sees the edition-1
+    # syntax the 2004 edition deprecates (Annex K).
+    module Dialect
+      EDITION_1994 = :"10303-11:1994"
+      EDITION_2004 = :"10303-11:2004"
+      DIALECTS = [EDITION_1994, EDITION_2004].freeze
+      DEFAULT = EDITION_2004
+
+      # The audited change list lives in
+      # spec/fixtures/dialects/iso-10303-11-2004-changes.yaml; every
+      # construct there maps to a note id below.
+      NOTE_IDS = %i[
+        check_dialect_2004_only
+        check_dialect_deprecated
+        check_dialect_mixed
+      ].freeze
+
+      module_function
+
+      def normalize(value)
+        return DEFAULT if value.nil?
+
+        candidate = value.to_s
+        dialect = DIALECTS.find do |entry|
+          entry.to_s == candidate || entry.to_s.end_with?(":#{candidate}")
+        end
+        return dialect if dialect
+
+        raise Expressir::InvalidOptionError.new(
+          "dialect",
+          value,
+          valid_options: DIALECTS.map(&:to_s),
+        )
+      end
+    end
+  end
+end

data/lib/expressir/express/formatters/declarations_formatter.rb

@@ -110,20 +110,15 @@ module Expressir
         end
 
         def format_declarations_entity(node)
-          if node.attributes.nil?
-            explicit_attributes = []
-            derived_attributes = []
-            inverse_attributes = []
-          else
-            explicit_attributes = node.attributes.select do |x|
-              x.kind == Model::Declarations::Attribute::EXPLICIT
-            end
-            derived_attributes = node.attributes.select do |x|
-              x.kind == Model::Declarations::Attribute::DERIVED
-            end
-            inverse_attributes = node.attributes.select do |x|
-              x.kind == Model::Declarations::Attribute::INVERSE
-            end
+          attrs = entity_attribute_items(node)
+          explicit_attributes = attrs.select do |x|
+            x.kind == Model::Declarations::Attribute::EXPLICIT
+          end
+          derived_attributes = attrs.select do |x|
+            x.kind == Model::Declarations::Attribute::DERIVED
+          end
+          inverse_attributes = attrs.select do |x|
+            x.kind == Model::Declarations::Attribute::INVERSE
           end
 
           indent_const = self.class.const_get(:INDENT)
@@ -231,6 +226,18 @@ module Expressir
           ].join("\n")
         end
 
+        # Entity#attributes is the Ruby-parse layout (every attribute kind
+        # in one list). The core path parks derived/inverse in their own
+        # collections instead. Both may also arrive as Array-of-Array when
+        # a builder nested list productions. Normalize to a flat list of
+        # Attribute-like nodes before selecting on `kind`.
+        def entity_attribute_items(node)
+          items = Array(node.attributes)
+          items += Array(node.derived_attributes) if node.respond_to?(:derived_attributes)
+          items += Array(node.inverse_attributes) if node.respond_to?(:inverse_attributes)
+          items.flatten.compact.uniq(&:object_id)
+        end
+
         def format_declarations_function(node)
           indent_char = self.class.const_get(:INDENT_CHAR)
           [

data/lib/expressir/express/formatters/expressions_formatter.rb

@@ -154,7 +154,10 @@ module Expressir
 
         def format_expressions_unary_expression(node)
           needs_parens = node.operand.is_a?(Model::Expressions::BinaryExpression) ||
-            node.operand.is_a?(Model::Expressions::Interval)
+            node.operand.is_a?(Model::Expressions::Interval) ||
+            # Nested unary must stay parenthesized: "- -x" is not a
+            # simple factor, and "--x" opens a comment.
+            node.operand.is_a?(Model::Expressions::UnaryExpression)
 
           [
             case node.operator

data/lib/expressir/express/parser.rb

@@ -56,8 +56,11 @@ module Expressir
       # @raise [Error::SchemaParseFailure] if the schema file fails to parse
       def self.from_file(file, skip_references: nil, include_source: nil,
                          root_path: nil, use_native: nil,
-                         use_core: nil) # rubocop:disable Metrics/AbcSize
-        use_core = Core::NATIVE_AVAILABLE if use_core.nil?
+                         use_core: nil, dialect: nil) # rubocop:disable Metrics/AbcSize
+        Dialect.normalize(dialect)
+        # use_native: false pins the Ruby grammar path; the core path
+        # must not silently take over that request.
+        use_core = Core::NATIVE_AVAILABLE if use_core.nil? && use_native != false
         if use_core && Core::NATIVE_AVAILABLE
           return from_file_core(file, skip_references: skip_references,
                                       include_source: include_source,
@@ -115,7 +118,8 @@ module Expressir
       # @return [Model::Repository] Repository containing all parsed ExpFiles
       def self.from_files(files, skip_references: nil, include_source: nil,
                           root_path: nil, use_native: nil, max_processes: nil,
-                          compiled_set: nil, &progress)
+                          compiled_set: nil, dialect: nil, &progress)
+        Dialect.normalize(dialect)
         set_path = compiled_set || ENV.fetch("EXPRESSIR_COMPILED_SET", nil)
         if set_path && core_set_available?
           repo = from_compiled_set(set_path, files,
@@ -457,7 +461,8 @@ include_source: nil, root_path: nil, use_native: nil, &block)
       # @return [Model::ExpFile] Parsed ExpFile
       # @raise [Error::SchemaParseFailure] if the content fails to parse
       def self.from_exp(content, skip_references: nil, include_source: nil,
-                         use_native: nil, use_streaming: false)
+                         use_native: nil, use_streaming: false, dialect: nil)
+        Dialect.normalize(dialect)
         content = strip_bom(content)
         if use_streaming
           raise Error::StreamingUnsupportedError

data/lib/expressir/express/pretty_formatter.rb

@@ -112,20 +112,15 @@ module Expressir
       # @param node [Model::Declarations::Entity] Entity node
       # @return [String] Formatted entity
       def format_declarations_entity(node)
-        if node.attributes.nil?
-          explicit_attributes = []
-          derived_attributes = []
-          inverse_attributes = []
-        else
-          explicit_attributes = node.attributes.select do |x|
-            x.kind == Model::Declarations::Attribute::EXPLICIT
-          end
-          derived_attributes = node.attributes.select do |x|
-            x.kind == Model::Declarations::Attribute::DERIVED
-          end
-          inverse_attributes = node.attributes.select do |x|
-            x.kind == Model::Declarations::Attribute::INVERSE
-          end
+        attrs = entity_attribute_items(node)
+        explicit_attributes = attrs.select do |x|
+          x.kind == Model::Declarations::Attribute::EXPLICIT
+        end
+        derived_attributes = attrs.select do |x|
+          x.kind == Model::Declarations::Attribute::DERIVED
+        end
+        inverse_attributes = attrs.select do |x|
+          x.kind == Model::Declarations::Attribute::INVERSE
         end
 
         indent_str = " " * @config.indent

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