pubid 2.0.0.pre.alpha.4 → 2.0.0.pre.alpha.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd077b48356a46dfb52d7b95e932c29e91e5fe1a7859c1128ddda22d768b4a96
-  data.tar.gz: 4e8059d20bed9297393f54bb894958a6c0ab8d92bef895fcb7528c291b3ff349
+  metadata.gz: 70b24e82967e02c1a0a641c5adc3ad9a77e563f0b7e6f69a59aa4f02971db3d2
+  data.tar.gz: c206002602026012406fa8ebe4339ff6ca0f02db7aa0b00ba49796a034cb697c
 SHA512:
-  metadata.gz: 329f3776c53f4021bfd2d25bd8698fb9c01309a66f56e9334d815aee3fde8ce25b509637f97ffc4ef91f0dfb67d10768a33505a939109a305d34b2e917af8f6c
-  data.tar.gz: 79c43b4e3ca83fe379a588f20490850e6a88757e382f0f9b9fc88d9f31923aff8fd8a5d48670c33a0d0705747820c6b3548260334ebf4e63a09b60dab82ad4ec
+  metadata.gz: f74a26e175164470260014a2d492eadfc2f396b0b56bc9f5848fc79168c1ec1d627380bb64c83126bd0eeb2841da40828e336cf263b785b4c2c1959a712b95c5
+  data.tar.gz: b450a0f2343231dff1174c01cec84fdacda74279134fed4c913a552fcd3c7a82e662e1fba5e52018462c295de1df9ba5c78af5a62a1ebde09974fbcd8270f7d6

data/lib/pubid/identifier.rb

@@ -125,6 +125,84 @@ module Pubid
       date&.year&.to_s
     end
 
+    # Canonicalize the serialized hash so it never carries a defaulted attribute
+    # still at its default (or empty) value. This makes to_hash a pure function
+    # of the identifier's values, independent of how the object was built.
+    #
+    # Motivation: lutaml materializes each attribute's default as an explicit
+    # assignment during deserialization (flipping using_default? to false), so a
+    # naive from_hash(x).to_hash re-emits defaults that parse(x).to_hash omits —
+    # breaking the exact-equality round-trip relaton-index relies on
+    # (from_hash(raw).to_hash == raw). pubid never consults lutaml's unset
+    # tracking and defines no render_default: true, so a defaulted attribute at
+    # its default/empty value carries no meaning and does not belong in the
+    # canonical hash. Dropping it here (rather than repairing from_hash) fixes
+    # the round-trip through every construction path — parse, from_hash, manual.
+    def to_hash(*args)
+      hash = super
+      canonicalize_hash(self, hash) if hash.is_a?(::Hash)
+      hash
+    end
+
+    # Recursively drop attributes holding only their default (or empty) value
+    # from +hash+, the serialization of +model+. Recurses into nested component
+    # / identifier values because lutaml serializes those via its own transform
+    # — bypassing their public to_hash — so a nested defaulted attribute (e.g.
+    # Components::Supplement#has_revision) would otherwise leak into the parent
+    # hash and break the idempotent round-trip.
+    def canonicalize_hash(model, hash)
+      register = model.lutaml_register
+      model.class.attributes(register).each do |name, attr|
+        canonicalize_attr(model, hash, name, attr) unless name == :_type
+      end
+    end
+
+    # Canonicalize a single attribute against its serialized value in +hash+:
+    # drop it when it holds only its default/empty value, else recurse into it.
+    def canonicalize_attr(model, hash, name, attr)
+      key = hash.key?(name.to_s) ? name.to_s : name
+      return unless hash.key?(key)
+
+      value = model.public_send(name)
+      if default_valued?(value, attr, model)
+        hash.delete(key)
+      else
+        canonicalize_nested(value, hash[key])
+      end
+    end
+
+    # True when +value+ is +attr+'s default (or empty), so it can be dropped.
+    def default_valued?(value, attr, model)
+      register = model.lutaml_register
+      attr.default_set?(register, model) &&
+        (Lutaml::Model::Utils.empty?(value) ||
+          value == attr.default(register, model))
+    end
+
+    # Recurse into a nested component / identifier (or a collection of them) so
+    # its own defaulted attributes are canonicalized against its sub-hash.
+    def canonicalize_nested(value, sub)
+      if value.is_a?(Lutaml::Model::Serialize)
+        canonicalize_hash(value, sub) if sub.is_a?(::Hash)
+      elsif value.is_a?(::Array)
+        canonicalize_collection(value, sub)
+      end
+    end
+
+    # Canonicalize each element of a collection against its serialized sub-hash.
+    # Only zip when object and serialized sizes match, so a (never-observed)
+    # length mismatch can't pair an element with the wrong sub-hash — worst case
+    # it leaves that collection untouched.
+    def canonicalize_collection(models, subs)
+      return unless subs.is_a?(::Array) && models.size == subs.size
+
+      models.each_with_index do |model, i|
+        canonicalize_nested(model, subs[i])
+      end
+    end
+    private :canonicalize_hash, :canonicalize_attr, :default_valued?,
+            :canonicalize_nested, :canonicalize_collection
+
     def initialize(attrs = {}, options = {})
       attrs = attrs.dup
       attrs[:_type] ||= self.class.polymorphic_name

data/lib/pubid/oiml/builder.rb

@@ -78,13 +78,14 @@ module Pubid
 
       def build_supplement(parsed_hash)
         marker = parsed_hash[:trailing_marker].to_s if parsed_hash[:trailing_marker]
+        plus_marker = parsed_hash[:plus_marker].to_s if parsed_hash[:plus_marker]
 
         # Determine supplement type. The trailing word ("Amendment"/"Errata")
         # selects the class; the concrete class then carries the word via
         # #supplement_type, so only the `trailing` flag needs storing.
         supplement_class = if parsed_hash[:annex_letter] || parsed_hash[:annex_marker]
                              Identifiers::Annex
-                           elsif marker == "Errata"
+                           elsif marker == "Errata" || plus_marker == "Errata"
                              Identifiers::Errata
                            else
                              Identifiers::Amendment
@@ -92,6 +93,7 @@ module Pubid
 
         supplement = supplement_class.new
         supplement.trailing = true if marker
+        supplement.joined = true if plus_marker
 
         # Recursively parse base identifier
         if parsed_hash[:base_identifier]

data/lib/pubid/oiml/parser.rb

@@ -19,7 +19,8 @@ module Pubid
       # Main identifier pattern - check supplements first
       rule(:identifier) do
         amendment_identifier | amendment_short | annex_letter_identifier |
-          annex_identifier | trailing_supplement_identifier | base_identifier
+          annex_identifier | plus_supplement_identifier |
+          trailing_supplement_identifier | base_identifier
       end
 
       # Publisher - always "OIML"
@@ -172,6 +173,18 @@ module Pubid
           language_portion.maybe.as(:language)
       end
 
+      # Plus-joined supplement - "BASE:YEAR+Supplement:YEAR" form where both
+      # the base and the supplement carry their own year. Used for amendments
+      # and errata to dated bases (e.g. "OIML B 10:2011+Amendment:2012").
+      # Annexes already encode the year-on-base intent via their own model.
+      rule(:plus_supplement_identifier) do
+        base_without_language.as(:base_identifier) >>
+          str("+") >>
+          (str("Amendment") | str("Errata")).as(:plus_marker) >>
+          (colon >> year_digits.as(:year)).maybe >>
+          language_portion.maybe.as(:language)
+      end
+
       # Annex identifier - "BASE Annexes Edition YYYY" / "BASE Annexes:YYYY" /
       # "BASE:YYYY Annexes" (year on the base, no annex year).
       rule(:annex_identifier) do

data/lib/pubid/oiml/renderer.rb

@@ -84,6 +84,16 @@ module Pubid
       def render_supplement(id)
         format = effective_format(id)
 
+        # Plus-joined: "BASE+Amendment:YEAR" / "BASE+Errata:YEAR" with both
+        # the base and the supplement carrying their own year.
+        if id.joined
+          base_str = strip_language(id.base_identifier.to_s)
+          result = "#{base_str}+#{id.supplement_type}"
+          result += ":#{id.year}" if id.year
+          result += " (#{id.language})" if id.language
+          return result
+        end
+
         # Trailing-word shorthand: "BASE Amendment" / "BASE Errata" with the
         # publication year kept on the base identifier. The word comes from the
         # concrete supplement class.

data/lib/pubid/oiml/supplement_identifier.rb

@@ -13,6 +13,9 @@ module Pubid
       # "Amendment (YYYY) to BASE" prose form. The word itself comes from the
       # concrete class (#supplement_type), so only this flag is stored.
       attribute :trailing, :boolean, default: false
+      # True for the plus-joined form ("OIML B 10:2011+Amendment:2012") where
+      # both the base and the supplement carry their own year, joined by "+".
+      attribute :joined, :boolean, default: false
       attribute :parsed_format, :string, default: -> {
         "short"
       } # Track supplement's parsed format
@@ -25,6 +28,7 @@ module Pubid
             with: { to: :base_identifier_to_kv, from: :base_identifier_from_kv }
         map "year", to: :year
         map "trailing", to: :trailing
+        map "joined", to: :joined
       end
 
       def base_identifier_to_kv(model, doc)

data/lib/pubid/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pubid
-  VERSION = "2.0.0.pre.alpha.4"
+  VERSION = "2.0.0.pre.alpha.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pubid
 version: !ruby/object:Gem::Version
-  version: 2.0.0.pre.alpha.4
+  version: 2.0.0.pre.alpha.5
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-07-03 00:00:00.000000000 Z
+date: 2026-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model