expressir 2.4.33 → 2.4.35

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 791c09b1ddc6f0ed583b4608c59ec327b7126c7c5b9d12c3a02acbaf236ae4c6
-  data.tar.gz: edb97cb53754e74511c9c28926ce4d9235afcd42d3d56fb4cd127017bff58590
+  metadata.gz: 2fef762a5f189a2fa5e19af4e03b508ceecb9c51f4f70a805af7b0cfaa955c66
+  data.tar.gz: f4bfae05b286248e59f3bb54c83369c1c1bba957edeb5dc1e9e0aa8e7d0bc147
 SHA512:
-  metadata.gz: ed1e988f03f3e4f5af1f77872495088c87c49a5247b055850b498b235f5fd1693055fb734441ad9d357cd71548a2692b5a17dceacea10fe9d77d21bb580766a4
-  data.tar.gz: f63d8a48e336d00996b90efcc7797877c48a74a049aafcf52ae4e7f417dddbbf189a3d7452fd1daba527d38b17ae8d7a25b054338b64e41efb4ebd484aef669d
+  metadata.gz: 75be497abf1fc565aa7098271d933715ab0e2ccaa2eed76eda589d37fe511cb8b52a2c08ffa537e23011cb847d14c9a9647c99e814473cdb5820577e61b31af1
+  data.tar.gz: 5420b2a0edfd9f4135515c75cf163b68dbb147e6b60fd7900528671862672f3695936884ea919692036c8e09eabb60f85c13cc939c61fdc67c9ec8ad2e1571cd

data/lib/expressir/express/builder.rb

@@ -186,17 +186,29 @@ module Expressir
 
             case item
             when Array
-              item.each do |sub|
-                result << build(sub) unless sub.nil?
-              end
+              item.each { |sub| append_built(result, build(sub)) unless sub.nil? }
             else
-              built = build(item)
-              result << built if built
+              append_built(result, build(item))
             end
           end
           result
         end
 
+        # Builders for list productions (ExplicitAttrBuilder and friends)
+        # return Arrays of nodes. Splice those items into the parent list
+        # rather than nesting them — nested Arrays break every consumer
+        # that expects ModelElements (`x.kind`, tree walks, formatters).
+        def append_built(result, built)
+          case built
+          when nil
+            nil
+          when Array
+            built.each { |b| append_built(result, b) }
+          else
+            result << built
+          end
+        end
+
         # Fast build methods - call registered builder directly without hash wrapping
         # These are optimized for hot paths in expression building
         # NOTE: These assume data is already snake_case (no key conversion needed)

data/lib/expressir/express/builders/entity_decl_builder.rb

@@ -73,17 +73,17 @@ module Expressir
           if entity_body.is_a?(Hash)
             if entity_body[:explicit_attr]
               explicit_attrs = Builder.build_children(entity_body[:explicit_attr])
-              attributes.concat(explicit_attrs)
+              attributes.concat(flatten_items(explicit_attrs))
             end
 
             if entity_body[:derive_clause]
               derived = Builder.build({ derive_clause: entity_body[:derive_clause] })
-              attributes.push(derived) if derived
+              attributes.concat(flatten_items(derived))
             end
 
             if entity_body[:inverse_clause]
               inverse = Builder.build({ inverse_clause: entity_body[:inverse_clause] })
-              attributes.push(inverse) if inverse
+              attributes.concat(flatten_items(inverse))
             end
 
             if entity_body[:unique_clause]
@@ -103,13 +103,25 @@ module Expressir
             supertype_expression: supertype_expression,
             subtype_of: subtype_of,
             attributes: attributes,
-            unique_rules: [unique_rules].flatten,
-            where_rules: [where_rules].flatten,
+            unique_rules: flatten_items(unique_rules),
+            where_rules: flatten_items(where_rules),
           }
           entity_params[:abstract] = true if abstract
 
           Expressir::Model::Declarations::Entity.new(**entity_params)
         end
+
+        private
+
+        # ExplicitAttrBuilder / DeriveClauseBuilder / InverseClauseBuilder
+        # return Arrays (one node per declaration). Call sites must splice
+        # those items into the parent list — nesting them leaves
+        # `entity.attributes` as Array-of-Array, which formatters then
+        # crash on (`undefined method 'kind' for an instance of Array`).
+        # lutaml-model 0.8.107 no longer flattens collection assignments.
+        def flatten_items(value)
+          Array(value).flatten.compact
+        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/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/shtolo.rb

@@ -130,16 +130,20 @@ module Expressir
           schema.interfaces.each do |iface|
             next unless iface.kind == Model::Declarations::Interface::REFERENCE
 
+            iface_schema = iface.schema.is_a?(String) ? iface.schema : iface.schema&.id
+            target = closure[iface_schema&.safe_downcase]
             iface.items.each do |item|
               original = original_name(item, schema)
-              next unless closure[original]&.entities&.find { |e| e.id == original }
+              next unless target&.entities&.find do |e|
+                e.id.safe_downcase == original.safe_downcase
+              end
 
               @reference_entities << original.safe_downcase
             end
           end
         end
 
-        declarations << build_dependent_rule if @reference_entities.any?
+        declarations.concat(build_dependent_declarations) if @reference_entities.any?
 
         Model::Declarations::Schema.new(
           id: @longform_name,
@@ -166,7 +170,18 @@ module Expressir
       # OWN schema's id, and the global map redirects the bare name so
       # declarations from third schemas resolve to the first occurrence.
       def plan_ids(schemas)
-        seen_first = {}      # downcase id => owning schema (first occurrence)
+        # G.NM.1: EVERY clashing declaration is prefixed (the annex
+        # example munges farming_dot_dog AND pet_shows_dot_dog), so the
+        # clash set is computed over the whole population first.
+        counts = Hash.new(0)
+        schemas.each do |schema|
+          all_decls(schema).each do |decl|
+            next unless decl.respond_to?(:id) && decl.id
+
+            counts[decl.id.safe_downcase] += 1
+          end
+        end
+
         global = {}          # downcase id => munged final
         own_by_schema = {}   # schema => {downcase id => final id}
         schemas.each do |schema|
@@ -175,14 +190,11 @@ module Expressir
             next unless decl.respond_to?(:id) && decl.id
 
             key = decl.id.safe_downcase
-            if seen_first.key?(key)
-              final = "#{schema.id.safe_downcase}_dot_#{decl.id}"
-              own[key] = final
-              global[key] = final
-            else
-              seen_first[key] = schema
-              own[key] = decl.id
-            end
+            own[key] = if counts[key] > 1
+                         global[key] = "#{schema.id.safe_downcase}_dot_#{decl.id}"
+                       else
+                         decl.id
+                       end
           end
           own_by_schema[schema] = own
         end
@@ -253,11 +265,20 @@ module Expressir
         current == current.upcase ? new.upcase : new
       end
 
-      # G.1.6: parse-templates keep the annex rule/function verbatim.
-      def build_dependent_rule
+      # G.1.6: parse-templates keep the annex rule/function verbatim;
+      # the pair is emitted together (the rule's WHERE calls the
+      # function, and the prune pass would drop an uncalled function).
+      def build_dependent_declarations
+        snippet = parse_schema_snippet(dependent_template_src)
+        rule = snippet.schemas.first.rules.first
+        fn = snippet.schemas.first.functions.first
+        [rule, fn].compact
+      end
+
+      def dependent_template_src
         list = @reference_entities.map(&:upcase).join(", ")
         union = @reference_entities.join("+")
-        src = <<~EXP
+        <<~EXP
           SCHEMA __dependent__;
           RULE #{DEPENDENT_RULE_NAME} FOR (#{list});
           LOCAL
@@ -270,9 +291,62 @@ module Expressir
           WHERE
             wr1: dependently_instantiated(all_instances, set_of_input_types, previous_in_chain);
           END_RULE;
+
+          FUNCTION dependently_instantiated(
+              set_of_input_instances : SET OF GENERIC:igen;
+              set_of_input_types      : SET OF STRING;
+              previous_in_chain       : LIST OF GENERIC:cgen): BOOLEAN;
+          LOCAL
+            number_of_input_instances : INTEGER;
+            number_of_referring_instances : INTEGER;
+            bag_of_referring_instances : BAG OF GENERIC:igen := [];
+            dependently_instantiated_flag : BOOLEAN;
+            previous_in_chain_plus : LIST OF GENERIC:cgen := [];
+            result : BOOLEAN := true;
+            set_of_types : SET OF STRING := [];
+          END_LOCAL;
+          IF EXISTS(set_of_input_instances) THEN
+            number_of_input_instances := SIZEOF(set_of_input_instances);
+            set_of_input_types := set_of_input_types + 'GENERIC';
+            REPEAT i := 1 TO number_of_input_instances;
+              bag_of_referring_instances := USEDIN(set_of_input_instances[i], '');
+              IF EXISTS(bag_of_referring_instances) THEN
+                number_of_referring_instances := SIZEOF(bag_of_referring_instances);
+                dependently_instantiated_flag := false;
+                REPEAT j := 1 TO number_of_referring_instances;
+                  set_of_types := TYPEOF(bag_of_referring_instances[j]);
+                  IF set_of_types <= set_of_input_types THEN
+                    IF NOT (bag_of_referring_instances[j] IN previous_in_chain) THEN
+                      previous_in_chain_plus := previous_in_chain +
+                                                set_of_input_instances[i];
+                      IF dependently_instantiated([bag_of_referring_instances[j]],
+                                                  set_of_input_types,
+                                                  previous_in_chain_plus) THEN
+                        dependently_instantiated_flag := true;
+                        ESCAPE;
+                      ELSE
+                        SKIP;
+                      END_IF;
+                    END_IF;
+                  ELSE
+                    dependently_instantiated_flag := true;
+                    ESCAPE;
+                  END_IF;
+                END_REPEAT;
+                IF NOT dependently_instantiated_flag THEN
+                  RETURN(false);
+                END_IF;
+              ELSE
+                RETURN(false);
+              END_IF;
+            END_REPEAT;
+          ELSE
+            RETURN(false);
+          END_IF;
+          RETURN(true);
+          END_FUNCTION;
           END_SCHEMA;
         EXP
-        parse_schema_snippet(src).schemas.first.rules.first
       end
 
       def parse_schema_snippet(src)
@@ -499,57 +573,95 @@ module Expressir
         end
       end
 
+      # G.2.2/G.2.4: every extensible/extending select becomes a
+      # non-extensible select whose items are the full domain in
+      # longform scope. Chains fold in dependency order (a node whose
+      # own BASED_ON is still pending is deferred), so an extending
+      # type that is itself extensible resolves against its base's
+      # folded domain.
+      # G.2.2/G.2.4: every extensible/extending select becomes a
+      # non-extensible select whose items are the full domain in
+      # longform scope. Chains fold in dependency order (a node whose
+      # own BASED_ON is still pending is deferred), so an extending
+      # type that is itself extensible resolves against its base's
+      # folded domain.
       def resolve_extensible_selects!(schema)
-        schema.types.select do |t|
-          t.underlying_type.is_a?(Model::DataTypes::Select) && t.underlying_type.extensible
-        end.each do |base|
-          sel = base.underlying_type
-
-          # all-extenders for GENERIC_ENTITY selects (WG12 requirement,
-          # #32): the extenders are the entity types themselves — fold in
-          # every entity the artifact carries, so the longform select is
-          # complete against the closure. Flags stay as declared: the
-          # extensible/generic-entity markers are part of the shortform's
-          # semantics and are not expressir's to drop.
-          if sel.generic_entity
-            sel.items = schema.entities.map do |e|
-              Model::References::SimpleReference.new(id: e.id)
-            end
-            next
-          end
+        select_types = schema.types.select do |ty|
+          ty.underlying_type.is_a?(Model::DataTypes::Select)
+        end
+        select_types.select { |ty| sel_pending?(ty) }.each do |base|
+          fold_select_node(schema, select_types, base)
+        end
+      end
 
-          extensions = schema.types.select do |t|
-            t.underlying_type.is_a?(Model::DataTypes::Select) &&
-              !t.underlying_type.extensible &&
-              t.underlying_type.based_on&.id&.safe_downcase == base.id.safe_downcase
+      def sel_pending?(select_type)
+        sel = select_type.underlying_type
+        sel.extensible || sel.based_on
+      end
+
+      def fold_select_node(schema, select_types, base_type)
+        sel = base_type.underlying_type
+        return unless sel_pending?(base_type)
+
+        # all-extenders for GENERIC_ENTITY selects (WG12 requirement,
+        # #32): the extenders are the entity types themselves — fold in
+        # every entity the artifact carries, so the longform select is
+        # complete against the closure. Flags stay as declared: the
+        # extensible/generic-entity markers are part of the shortform's
+        # semantics and are not expressir's to drop.
+        if sel.generic_entity && !sel.based_on
+          sel.items = schema.entities.map do |e|
+            Model::References::SimpleReference.new(id: e.id)
           end
-          merged_items = sel.items +
-            extensions.flat_map { |x| x.underlying_type.items }
-          seen_ids = {}
-          uniq = merged_items.select do |item|
-            key = item.id.safe_downcase
-            next false if seen_ids.key?(key) || key.empty?
-
-            seen_ids[key] = true
+          return
+        end
+
+        own_items = Array(sel.items)
+        inherited = []
+        if sel.based_on
+          base_ty = select_types.find do |ty|
+            ty.id&.safe_downcase == sel.based_on&.id&.safe_downcase
           end
-          sel.items = uniq
-          sel.extensible = false
-          sel.based_on = nil
+          fold_select_node(schema, select_types, base_ty) if base_ty && sel_pending?(base_ty)
+          inherited = base_ty ? Array(base_ty.underlying_type.items) : []
+        end
 
-          extensions.each do |ext|
-            keep = ext.underlying_type.items.map { |i| i.id.upcase }
-            exclusions = uniq.reject { |i| keep.include?(i.id.upcase) }
-            base_ref = "#{@longform_name.upcase}.#{base.id.upcase}"
-            ext.underlying_type = Model::DataTypes::Select.new(
-              items: sel.items.map { |i| Model::References::SimpleReference.new(id: i.id) },
+        extenders = select_types.select do |ty|
+          !ty.equal?(base_type) &&
+            ty.underlying_type.based_on&.id&.safe_downcase == base_type.id&.safe_downcase
+        end
+
+        merged = inherited + own_items +
+          extenders.flat_map { |ty| Array(ty.underlying_type.items) }
+        seen = {}
+        uniq = merged.select do |item|
+          key = item.id.safe_downcase
+          next false if key.empty? || seen.key?(key)
+
+          seen[key] = true
+        end
+        sel.items = uniq
+        sel.extensible = false
+        sel.based_on = nil
+
+        extenders.each do |ty|
+          ext_sel = ty.underlying_type
+          keep = Array(ext_sel.items).map { |i| i.id.upcase }
+          base_ref = "#{@longform_name.upcase}.#{base_type.id.upcase}"
+          ty.underlying_type = Model::DataTypes::Select.new(
+            items: uniq.map { |i| Model::References::SimpleReference.new(id: i.id) },
+          )
+          ext_sel_items = ty.underlying_type.items
+          exclusions = uniq.reject { |i| keep.include?(i.id.upcase) }
+          ty.where_rules = exclusions.each_with_index.map do |item, i|
+            Model::Declarations::WhereRule.new(
+              id: "wr#{i + 1}",
+              expression: parse_expression(
+                "NOT ('#{base_ref}.#{item.id.upcase}' IN TYPEOF(SELF));",
+              ),
             )
-            ext.where_rules = exclusions.each_with_index.map do |item, i|
-              Model::Declarations::WhereRule.new(
-                id: "wr#{i + 1}",
-                expression: parse_expression("NOT ('#{base_ref}.#{item.id.upcase}' IN TYPEOF(SELF));"),
-              )
-            end
           end
+          ext_sel_items
         end
       end
 
@@ -565,10 +677,7 @@ module Expressir
             entity.supertype_expression =
               entity.supertype_expression ? combine_andor(entity.supertype_expression, expr) : expr
           end
-          if entity.abstract
-            # G.2.6: abstract entity ⇒ ABSTRACT SUPERTYPE (formatter
-            # renders from abstract + supertype status).
-          end
+          entity.abstract = true if sc.abstract
           next if Array(sc.total_over).empty?
 
           rule_name = "total_over_#{sc.id}"

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.33".freeze
+    VERSION = "2.4.35".freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: expressir
 version: !ruby/object:Gem::Version
-  version: 2.4.33
+  version: 2.4.35
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-15 00:00:00.000000000 Z
+date: 2026-10-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rb_sys