expressir 2.4.29-aarch64-linux → 2.4.35-aarch64-linux

data/lib/expressir/express/checker.rb

@@ -82,6 +82,13 @@ module Expressir
         blength insert remove
       ].freeze
 
+      USE_ITEM_KINDS = [Model::Declarations::Entity, Model::Declarations::Type].freeze
+      REFERENCE_ITEM_KINDS = [
+        Model::Declarations::Constant, Model::Declarations::Entity,
+        Model::Declarations::Function, Model::Declarations::Procedure,
+        Model::Declarations::Type
+      ].freeze
+
       private
 
       def note!(id, severity, schema, message, node = nil)
@@ -92,6 +99,7 @@ module Expressir
       def check_schema(schema)
         check_duplicates(schema)
         check_interfaces(schema)
+        check_type_resolutions(schema)
         check_self_schema_reference(schema)
         schema.entities.each { |e| check_entity(schema, e) }
         schema.types.each do |t|
@@ -100,9 +108,11 @@ module Expressir
           check_where_rules(schema, t, t.where_rules)
         end
         schema.rules.each { |r| check_where_rules(schema, r, r.where_rules) }
+        check_subtype_constraints(schema)
         schema.entities.each do |entity|
           check_aggregate_bounds(schema, entity)
           check_attrib_name_fun(schema, entity)
+          check_attribute_redeclarations(schema, entity)
         end
         check_string_references(schema)
         check_unresolved_refs(schema)
@@ -184,14 +194,44 @@ module Expressir
           end
 
           resource_names(iface).each do |name|
-            next if foreign_decl?(foreign, name)
+            decl = foreign_declaration(foreign, name)
+            unless decl
+              note!(:check_unresolved_ref, :error, schema,
+                    "interface resource '#{name}' not in schema '#{target}'", iface)
+              next
+            end
 
-            note!(:check_unresolved_ref, :error, schema,
-                  "interface resource '#{name}' not in schema '#{target}'", iface)
+            # eeng resolve-interface: use-from resolves via
+            # find-type/entity, reference-from via the 5-kind or-chain;
+            # anything else is "Resource '~A' not found".
+            next if item_kind_interfacable?(iface.kind, decl)
+
+            note!(:check_interface_kind_restriction, :error, schema,
+                  "interface resource '#{name}' is a #{decl.class.name.split('::').last}: " + "#{iface.kind} resolves #{allowed_kinds(iface.kind)} only", iface)
           end
         end
       end
 
+      def item_kind_interfacable?(kind, decl)
+        (kind == Model::Declarations::Interface::REFERENCE ? REFERENCE_ITEM_KINDS : USE_ITEM_KINDS)
+          .any? { |k| decl.is_a?(k) }
+      end
+
+      def allowed_kinds(kind)
+        (kind == Model::Declarations::Interface::REFERENCE ? REFERENCE_ITEM_KINDS : USE_ITEM_KINDS)
+          .map { |k| k.name.split("::").last }.join(", ")
+      end
+
+      def foreign_declaration(schema, name)
+        key = name.safe_downcase
+        DECL_COLLECTIONS.each do |coll|
+          Array(schema.public_send(coll)).each do |d|
+            return d if d.id&.safe_downcase == key
+          end
+        end
+        nil
+      end
+
       def iface_schema_name(iface)
         iface.schema.is_a?(String) ? iface.schema : iface.schema&.id
       end
@@ -210,6 +250,85 @@ module Expressir
         end
       end
 
+      # eeng check-p11 context checks (kernel/check.lisp:160-201,
+      # 299-336, 337-395): constant/local/parameter/return types must
+      # resolve to a TYPE or ENTITY visible in the schema (find-type/
+      # entity semantics - constants, functions, procedures do NOT
+      # satisfy them). Note ids are the eeng ones.
+      def check_type_resolutions(schema)
+        schema.constants.each do |constant|
+          check_type_ref(schema, Array(constant.type), :check_constant_type, constant.id, constant)
+        end
+
+        schema.functions.each do |function|
+          Array(function.parameters).each do |param|
+            check_type_ref(schema, Array(param.type), :check_parameter_type, param.id, param)
+          end
+          check_type_ref(schema, Array(function.return_type),
+                         :check_function_return_type, function.id, function)
+          Array(function.variables).each do |variable|
+            check_type_ref(schema, Array(variable.type), :check_local_type, variable.id, variable)
+          end
+        end
+
+        schema.procedures.each do |procedure|
+          Array(procedure.parameters).each do |param|
+            check_type_ref(schema, Array(param.type), :check_parameter_type, param.id, param)
+          end
+          Array(procedure.variables).each do |variable|
+            check_type_ref(schema, Array(variable.type), :check_local_type, variable.id, variable)
+          end
+        end
+
+        schema.rules.each do |rule|
+          Array(rule.applies_to).each do |entity_ref|
+            # parameter-rule: the FOR entities resolve via
+            # find-type/entity too (kernel/check.lisp:311-322)
+            check_entity_ref(schema, Array(entity_ref), :check_parameter_type, rule.id, rule)
+          end
+          Array(rule.variables).each do |variable|
+            check_type_ref(schema, Array(variable.type), :check_local_type, variable.id, variable)
+          end
+        end
+      end
+
+      def check_type_ref(schema, nodes, note_id, name, node)
+        nodes.each do |type|
+          next unless type.is_a?(Model::References::SimpleReference)
+          next if type.id.nil? || builtin?(type.id)
+          next if resolves_to_type_or_entity?(schema, type.id)
+
+          note!(note_id, :error, schema,
+                "type '#{type.id}' of '#{name}' does not resolve to a type or entity", node || type)
+        end
+      end
+
+      def check_entity_ref(schema, nodes, note_id, name, node)
+        nodes.each do |ref|
+          next unless ref.is_a?(Model::References::SimpleReference)
+          next if ref.id.nil?
+          next if resolves_to_type_or_entity?(schema, ref.id)
+
+          note!(note_id, :error, schema,
+                "entity '#{ref.id}' of '#{name}' does not resolve to a type or entity", node || ref)
+        end
+      end
+
+      def resolves_to_type_or_entity?(schema, name)
+        key = name.safe_downcase
+        schema.children.any? do |child|
+          next false unless child.id&.safe_downcase == key
+
+          child.is_a?(Model::Declarations::Type) || child.is_a?(Model::Declarations::Entity) ||
+            (child.is_a?(Model::Declarations::InterfacedItem) && interface_item_type_or_entity?(child))
+        end
+      end
+
+      def interface_item_type_or_entity?(item)
+        base = item.base_item
+        base.is_a?(Model::Declarations::Type) || base.is_a?(Model::Declarations::Entity)
+      end
+
       def check_entity(schema, entity)
         Array(entity.subtype_of).each do |ref|
           id = ref.is_a?(String) ? ref : ref.id
@@ -282,6 +401,75 @@ module Expressir
 
       # eeng check-supertype-ref: every entity named in the SUPERTYPE
       # expression must resolve to an entity of this schema.
+      # eeng check-p11 subtype_constraint (kernel/check.lisp:426) only
+      # checks the supertype expression; the note id matches the entity
+      # supertype path (kernel/check.lisp:523).
+      def explicit_attributes(entity)
+        Array(entity.attributes)
+          .select { |attr| attr.instance_of?(Model::Declarations::Attribute) }
+      end
+
+      def check_subtype_constraints(schema)
+        schema.subtype_constraints.each do |constraint|
+          expr = constraint.supertype_expression
+          next unless expr
+
+          each_reference(expr) do |ref|
+            id = ref.id
+            next if id.nil?
+            # Names outside this schema's scope (foreign entities of a
+            # single-file parse) cannot be verified here.
+            next unless resolves_to_type_or_entity?(schema, id)
+            next if find_entity(schema, id)
+
+            note!(:check_supertype_ref, :error, schema,
+                  "SUBTYPE_CONSTRAINT #{constraint.id}: supertype " \
+                  "'#{id}' is not an entity", constraint)
+          end
+        end
+      end
+
+      # A `SELF\<supertype>.<attr>` redeclaration must name a supertype
+      # in the inheritance closure carrying that attribute (ISO
+      # 10303-11:2004, 9.2.2.3). eeng kernel/check.lisp:255 leaves this
+      # as a TODO comment, so this check has no eeng note id.
+      def check_attribute_redeclarations(schema, entity)
+        explicit_attributes(entity).each do |attr|
+          tag = attr.supertype_attribute
+          next unless tag.is_a?(Model::References::AttributeReference)
+
+          sup_id = tag.ref&.entity&.id
+          attr_id = tag.attribute&.id
+          if sup_id.nil?
+            note!(:check_attribute_redeclaration, :error, schema,
+                  "ENTITY #{entity.id}: redeclaration of '#{attr.id}' " \
+                  "names no supertype", attr)
+            next
+          end
+
+          supertype = entity.supertype_closure
+            .find { |st| st.id&.safe_downcase == sup_id.safe_downcase }
+          if supertype.nil?
+            # The named supertype may be foreign (USE FROM) and thus
+            # outside the closure of a single-file parse; only flag it
+            # when it resolves in this scope yet is not a supertype.
+            if find_entity(schema, sup_id)
+              note!(:check_attribute_redeclaration, :error, schema,
+                    "ENTITY #{entity.id}: redeclaration '#{attr.id}' names " \
+                    "'#{sup_id}', which is not a supertype", attr)
+            end
+            next
+          end
+
+          next if explicit_attributes(supertype)
+            .any? { |candidate| candidate.id&.safe_downcase == attr_id&.safe_downcase }
+
+          note!(:check_attribute_redeclaration, :error, schema,
+                "ENTITY #{entity.id}: redeclaration '#{attr.id}': supertype " \
+                "'#{sup_id}' has no attribute '#{attr_id}'", attr)
+        end
+      end
+
       def check_supertype_refs(schema, entity)
         expr = entity.supertype_expression
         return unless expr

data/lib/expressir/express/core.rb

@@ -7,6 +7,7 @@ module Expressir
     # Ruby bridge to the expressir-core Rust crate (parse + model
     # extraction). Available when the native extension is built;
     # callers fall back to the pure-Ruby parser otherwise.
+    #
     module Core
       NATIVE_AVAILABLE = begin
         require "expressir/expressir_core"

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/grammar/parser.rb

@@ -27,6 +27,28 @@ module Expressir
         # Files above this use parse_fresh which has no packrat cache
         LARGE_FILE_THRESHOLD = 1024 * 1024 # 1 MB
 
+        # Whitespace rides the engine's injected trivia (parsanol-ruby
+        # #180's source-preserving mode, 1.3.82+): each unit records
+        # verbatim under :space and attaches to the next Named capture.
+        # Remarks stay OUT of the skip rule — they are product data,
+        # captured by the tailRemark/embeddedRemark rules and attached
+        # by RemarkScanner; tail remarks attach backward, the engine's
+        # next-capture channel is the wrong direction for them.
+        rule(:trivia) { match[" \r\n\t\f"].repeat(1) }
+        # exempt (parsanol#195, shipped 1.3.89): token rules whose bodies
+        # manage their own internals — injection before a char-class tail
+        # repetition absorbs the following token across whitespace
+        # ("RULE r FOR" parsed as one simpleId). simpleId additionally
+        # matches as a single quantified Re, which needs no exemption;
+        # the two mechanisms agree and stay for defense in depth.
+        # The whitespace/remark rules manage their own trivia end to end
+        # (they ARE the trivia surface for remarks); injection around
+        # them breaks consecutive remark lines on the Ruby engine
+        # ("-- X\n--\nSCHEMA ..." failed - the #487 windows follow-up,
+        # parsanol-ruby#195 family).
+        skip(:trivia, whitespace: :space,
+                      exempt: %i[simpleId digits spaces space embeddedRemark tailRemark])
+
         # Get cached parser instance (thread-safe)
         # Reusing the parser avoids the overhead of reinitializing all rule definitions
         def self.cached_parser
@@ -604,7 +626,13 @@ module Expressir
           (unaryOp >> simpleFactorExpression).as(:simpleFactorUnaryExpression)
         end
         rule(:simpleId) do
-          anyKeyword.absent? >> cts((match["a-zA-Z_"] >> match["a-zA-Z0-9_"].repeat).as(:str)).as(:simpleId)
+          # One quantified Re, not lead >> tail-repeat: under skip
+          # injection the DSL interleaves trivia before the tail
+          # repetition, so a two-atom ident would absorb the following
+          # whitespace-separated identifier ("RULE r FOR (e)" parses
+          # "r FOR" as one simpleId). A quantified Re consumes the
+          # whole identifier in a single step — parsanol GH-69.
+          anyKeyword.absent? >> cts(match("[a-zA-Z_][a-zA-Z0-9_]*").as(:str)).as(:simpleId)
         end
         rule(:simpleStringLiteral) do
           cts((str("'") >> (str("'").absent? >> any).repeat >> str("'")).as(:str)).as(:simpleStringLiteral)

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