expressir 2.4.43-arm-linux → 2.4.45-arm-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a74e2934aa91f697a2afab5936c93e0076c99943c2db2e6a96815c04320b43a
-  data.tar.gz: f7bcc4bd73d8cba5691e777666757d36ac925d9ec7c877ab929921ed9f249047
+  metadata.gz: e09c5c927c878e232059b301e116b126589dd35e4ab72bbce563577a9d82b576
+  data.tar.gz: f16d568d6767b6ecb2648717108278b7012bd8f367b6bcc9e081d26b8d484457
 SHA512:
-  metadata.gz: e3a82ccfc4da4faddf86f670d5da291575c38946b8b321651de46d331dd759428ed88691205f0ff64e20c74ef12458d206b55e13b62db5b676172f15aefd3e47
-  data.tar.gz: '0628dd39af53af1cce52dfb58ad4cd31cce7947ddadd3cf62d8b04ace16f904084dc8947cd631c9fe3451cc746effcad7e9cd99a42e0a4b5b458493895e3d0ff'
+  metadata.gz: 82bc5464f43c819eede4751832c8947d5a22a36f8466aec0a2db0170d7115ea7af7c17214e01b961b0bc63d318cdea82626b687ae3a3f40e497f69488e231f4e
+  data.tar.gz: f6361a1d666f0fbff3964f35917fa2a44c1b07e5b26ac717778f69f12c94f552d5c72d411280ccbab148176ea08d1ee29ed9dcf3863a2ac9f8a7a465a9c8e79c

data/.github/workflows/gemspec-floor.yml

@@ -0,0 +1,61 @@
+# Floor guard: every released expressir must LOAD under the OLDEST
+# lutaml-model its own gemspec admits. v2.4.4/v2.4.5 shipped `map ...,
+# serialize: false` while declaring `lutaml-model ~> 0.8.0` — the
+# keyword first exists in 0.8.43 — so any bundle resolving that pair
+# died at class-load time (issue #566). This job pins lutaml-model to
+# the exact gemspec floor and loads the model classes against it.
+name: gemspec-floor
+
+on:
+  push:
+    branches: [ master, main ]
+  pull_request:
+
+jobs:
+  floor:
+    runs-on: ubuntu-latest
+    name: lutaml-model at the gemspec floor
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.3'
+
+      - name: Extract the lutaml-model floor from the gemspec
+        id: floor
+        run: |
+          floor=$(ruby -e '
+            spec = Gem::Specification.load(Dir["*.gemspec"].first)
+            dep = spec.dependencies.find { |d| d.name == "lutaml-model" }
+            candidates = dep.requirement.requirements
+              .select { |op, _| [">=", "~>"].include?(op) }
+              .map { |_, v| v.version }
+            abort "no lutaml-model floor in the gemspec" if candidates.empty?
+            puts candidates.min
+          ')
+          echo "floor=$floor" >> "$GITHUB_OUTPUT"
+          echo "lutaml-model floor: $floor"
+
+      - name: Pin lutaml-model exactly at the floor
+        run: |
+          cat >> Gemfile <<'GEMFILE'
+
+          gem "lutaml-model", "= ${{ steps.floor.outputs.floor }}"
+          GEMFILE
+          bundle install
+
+      - name: Load the model classes under the floor
+        run: |
+          bundle exec ruby -e '
+            require "lutaml/model"
+            resolved = Gem.loaded_specs["lutaml-model"].version.to_s
+            abort "resolved #{resolved}, expected ${{ steps.floor.outputs.floor }}" unless resolved == "${{ steps.floor.outputs.floor }}"
+            require "expressir"
+            require "expressir/model/model_element"
+            require "expressir/model"
+            puts "model classes load under lutaml-model #{resolved}"
+          '
+
+      - name: Model specs under the floor
+        run: bundle exec rspec spec/expressir/model

data/lib/expressir/coverage.rb

@@ -465,9 +465,11 @@ module Expressir
         elsif entity_class == "Expressir::Model::Declarations::Type" && type_subtype_skips.any?
           entity_subtype = get_type_subtype(entity)
           type_subtype_skips.include?(entity_subtype)
-        # Check FUNCTION:INNER exclusions
-        elsif entity_class == "Expressir::Model::Declarations::Function" && function_subtype_skips.include?("INNER")
-          inner_function?(entity)
+        # Check FUNCTION:INNER exclusions — the whole inner-function
+        # subtree is excluded, its parameters and nested declarations
+        # included, not only the function entity itself
+        elsif function_subtype_skips.include?("INNER") && within_inner_function?(entity)
+          true
         else
           false
         end
@@ -506,5 +508,19 @@ module Expressir
         parent.is_a?(Expressir::Model::Declarations::Rule) ||
         parent.is_a?(Expressir::Model::Declarations::Procedure)
     end
+
+    # Check if an entity is an inner function or a declaration belonging to one
+    # (its parameters, nested types, nested functions, ...)
+    # @param entity [Expressir::Model::ModelElement] The entity to check
+    # @return [Boolean] True if the entity or any of its ancestors is an inner function
+    def self.within_inner_function?(entity)
+      current = entity
+      while current
+        return true if current.is_a?(Model::Declarations::Function) && inner_function?(current)
+
+        current = current.respond_to?(:parent) ? current.parent : nil
+      end
+      false
+    end
   end
 end

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

@@ -245,7 +245,9 @@ module Expressir
               "FUNCTION",
               " ",
               node.id,
-              *if node.parameters&.length&.positive?
+              # nil parameters = the source had no parentheses;
+              # [] = an explicit `f()` — the parens are written back
+              *if node.parameters
                  parameter_indent = indent_char * "FUNCTION #{node.id}(".length
                  [
                    "(",
@@ -371,7 +373,9 @@ module Expressir
               "PROCEDURE",
               " ",
               node.id,
-              *if node.parameters&.length&.positive?
+              # see format_declarations_function: nil = no parens,
+              # [] = explicit `p()`
+              *if node.parameters
                  parameter_indent = indent_char * "PROCEDURE #{node.id}(".length
                  [
                    "(",

data/lib/expressir/express/remark_attacher.rb

@@ -889,6 +889,20 @@ module Expressir
           end
         end
 
+        # A prefixed intermediate segment (wr:WR1.ip:IP2.__note) splits
+        # wrong under the generic prefix-normalized walk below, so the
+        # segment-aware resolution handles that class: resolve the
+        # longest owned prefix (honoring the wr:/ip:/ur: prefixes
+        # find() strips) and attach the first unresolved segment as the
+        # remark item id on that node — `<rule>.wr:WR1.__note` lands a
+        # `__note` item on WR1 (#562), not a `wr` item on the rule.
+        segments = path.split(".")
+        if segments.length > 2 &&
+            segments[0..-2].any? { |segment| segment.include?(":") } && (owned = resolve_longest_owned_prefix(model, path, schema_ids))
+          parent, item_id = owned
+          return create_item_at_parent(parent, item_id)
+        end
+
         clean_path = normalize_path(path)
         parts = clean_path.split(".")
         return nil if parts.length < 2
@@ -921,6 +935,41 @@ module Expressir
         "#{path_part}.#{item_suffix}"
       end
 
+      # Walks the tag's segments from a schema root, honoring the
+      # prefix forms find() strips (wr:WR1, ip:IP1, ur:UR1), and
+      # returns [node, first_unresolved_segment] for the deepest node
+      # the model owns. Nil when nothing resolves.
+      def resolve_longest_owned_prefix(model, path, schema_ids)
+        candidate_paths = [path]
+        schema_ids.each do |schema_id|
+          candidate_paths << "#{schema_id}.#{path}"
+        end
+
+        candidate_paths.each do |candidate|
+          segments = candidate.split(".")
+          next if segments.empty?
+
+          owned_path = segments.first
+          node = safe_find(model, owned_path)
+          next unless node
+
+          segments[1..].each_with_index do |segment, index|
+            stepped = safe_find(model, "#{owned_path}.#{segment}")
+            # a lazily created remark item is never a path owner
+            stepped = nil if stepped.is_a?(Model::Declarations::RemarkItem)
+            if stepped.nil?
+              return [node, segment] if index.positive?
+
+              break
+            end
+            owned_path = "#{owned_path}.#{segment}"
+            node = stepped
+          end
+        end
+
+        nil
+      end
+
       def create_item_at_parent(parent, item_id)
         # Strip "wr:" prefix convention (e.g. "wr:IP1" → "IP1")
         ip_id = extract_ip_id(item_id)

data/lib/expressir/p28/xsd.rb

@@ -372,6 +372,16 @@ module Expressir
       # 7.6.3: one accessor element per mapped attribute; OPTIONAL
       # attributes are minOccurs="0"; aggregates carry their
       # occurrence bounds.
+      #
+      # Entity-typed accessors carry the REF form (exp:Entity —
+      # content-free, the ref/href IDREF attributes): a P21
+      # entity-valued position holds a reference (#N), never inline
+      # content, and the full validated form stays on the GLOBAL
+      # entity element (substitutionGroup exp:Entity). Typing the
+      # accessor with the entity's own complexType demanded that
+      # content inside by-reference occurrences — `<Widget ref="id2"/>`
+      # could not validate (#565, exposed by leptris 1.9.383 fixing
+      # the empty-instance bypass #1860).
       def accessor_node(doc, schema, prefix, attribute, inline, config = nil,
                         scope = nil)
         type = attribute.type
@@ -383,11 +393,14 @@ module Expressir
         node.set_attributes("minOccurs" => "0") if optional
         case kind
         when :entity
-          target = entity_id_of(schema, type)
-          node.set_attributes("type" => "#{prefix}:#{mapped(target, config, :entity)}")
+          # exp:Entity is abstract — an element cannot use it as its
+          # type directly (libxml2 rejects the schema); the concrete
+          # ref form is an anonymous empty extension carrying the
+          # base's ref/href attributes.
+          node.add_child(ref_form_node(doc, inline, prefix))
         when :entity_aggregate
           node.add_child(aggregate_content_node(doc, schema, prefix, type,
-                                                config))
+                                                config, inline: inline))
         when :aggregate
           node.add_child(inline_list_node(doc, schema, type, inline))
         when :select
@@ -415,24 +428,41 @@ module Expressir
       # Aggregates of entity base: the accessor wraps unqualified
       # component elements typed by the component entity (9.2.6.1
       # worked example shape).
-      def aggregate_content_node(doc, schema, prefix, aggregate, config = nil)
+      def aggregate_content_node(doc, schema, prefix, aggregate, config = nil,
+                                 inline: false)
         base = aggregate.base_type
         target = entity_id_of(schema, base)
         name = mapped(target, config, :entity)
         content = doc.create_element("xs:complexType")
         sequence = doc.create_element("xs:sequence")
         component = doc.create_element("xs:element")
+        # Aggregate members hold REFERENCES to entity instances
+        # (P21 #N ids), so the component element carries the
+        # content-free ref form (exp:Entity) — the full validated
+        # form stays on the global entity element (#565).
         component.set_attributes(
           "name" => name,
-          "type" => "#{prefix}:#{name}",
           "minOccurs" => "0",
           "maxOccurs" => "unbounded",
         )
+        component.add_child(ref_form_node(doc, inline, prefix))
         sequence.add_child(component)
         content.add_child(sequence)
         content
       end
 
+      # The concrete ref form: an anonymous empty extension of
+      # exp:Entity — content-free, carrying the base's ref/href
+      # attributes. Entity-valued positions in a P21 instance hold
+      # references (#N ids), never inline content (#565).
+      def ref_form_node(doc, inline, prefix)
+        content = doc.create_element("xs:complexContent")
+        extension = doc.create_element("xs:extension")
+        extension.set_attributes("base" => exp_name("Entity", inline, prefix))
+        content.add_child(extension)
+        content
+      end
+
       # 7.8: the context-schema specific uos element — in the
       # exp:uos substitution group, extending the exp:uos carrier,
       # with a repeating choice over the exp:Entity substitution

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.43".freeze
+    VERSION = "2.4.45".freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: expressir
 version: !ruby/object:Gem::Version
-  version: 2.4.43
+  version: 2.4.45
 platform: arm-linux
 authors:
 - Ribose Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2026-10-25 00:00:00.000000000 Z
+date: 2026-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -227,6 +227,7 @@ files:
 - ".github/workflows/codeql.yml"
 - ".github/workflows/conformance.yml"
 - ".github/workflows/docs.yml"
+- ".github/workflows/gemspec-floor.yml"
 - ".github/workflows/links.yml"
 - ".github/workflows/native-gems.yml"
 - ".github/workflows/performance-release.yml"