pubid 2.0.0.pre.alpha.50 → 2.0.0.pre.alpha.52

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: baaa27f6b48240e456126d1cd19f3a3bfc6a4b548cfa4dd6a4567dd526f0560a
-  data.tar.gz: 70e932649f2d9afd9c18f8eba72dda5aa11842a86a39265ad4fcea0955873f21
+  metadata.gz: 9c83c28edc99ccf1e6167e7f6267cf04aedff8cf15629f2d778648eee0e842fd
+  data.tar.gz: b195d6a1b9cef28f3dcb711e7c5478efe16a99892de4a92899fb0adbc52638eb
 SHA512:
-  metadata.gz: f6179943999d075826cf6716ff536b86bba5c2fadf59f3169f966ce415faaf9e833e2fd1343debcd16fd903d7566ad67502d36cb119f91c4b75d61098b3144a3
-  data.tar.gz: 16dabfaff72921826f3267e21112ac75c29e5151162c38f5323b3cb00fde5bb4dc713a1b17e6df2ab80492ba2f13cffaa4f61564b12cf2100d29fd3a859b4cc6
+  metadata.gz: 8f6557ed875261cad34957e7e954d00e176edd68311594f058c261b25a15e54f70db606964f4652ff5971feacc5c124b4b6885c73ebd7ff33654fdc721d1df24
+  data.tar.gz: b448357f4887dcc7da87b580c0433ce6e358b624e49b23c1c9336e145a0a971c1c592e6eca6b148844d1ff128a9abf666065b649e664ea3af34a42f986b360eb

data/lib/pubid/format_registry.rb

@@ -63,7 +63,10 @@ module Pubid
       transformer = Class.new do
         define_singleton_method(:name) { "Pubid#{format.to_s.capitalize}Transform" }
 
-        define_method(:data_to_model) do |data, _format, _options = {}|
+        # Lutaml calls the transformer on the class (transformer_for
+        # returns the registered object as-is), so the hook is a
+        # singleton method.
+        define_singleton_method(:data_to_model) do |_model, data, _format, _options = {}|
           data
         end
       end

data/lib/pubid/iso/builder.rb

@@ -315,6 +315,10 @@ module Pubid
             value
           end
 
+        when :supplement_version
+          # The RFC 5141 <supplversion> carried on supplement identifiers
+          value.to_s
+
         when :stage
           # Raw stage code from URN parser (e.g., "10.00", "50.00")
           # Convert to type_with_stage format for builder

data/lib/pubid/iso/supplement_identifier.rb

@@ -6,6 +6,11 @@ module Pubid
       attribute :base, Identifier,
                 polymorphic: true
 
+      # The RFC 5141 <supplversion> (the corrected version of the
+      # supplement; published supplements are version 1). Distinct from
+      # the amendment/corrigendum <supplnumber>.
+      attribute :supplement_version, :string
+
       key_value do
         # Serialized key is "base" (matches JIS); the attribute/method stays
         # `base`, which relaton-index's get_id_number depends on.
@@ -13,6 +18,24 @@ module Pubid
           attribute: "_type",
           class_map: Identifier::ISO_TYPE_MAP,
         }
+        map "supplement_version",
+            with: { to: :supplement_version_to_kv, from: :supplement_version_from_kv }
+      end
+
+      def supplement_version_to_kv(model, doc)
+        return unless model.supplement_version
+
+        doc.add_child(
+          Lutaml::KeyValue::DataModel::Element.new(
+            "supplement_version", model.supplement_version.to_s,
+          ),
+        )
+      end
+
+      def supplement_version_from_kv(model, value)
+        return if value.nil? || value.to_s.empty?
+
+        model.supplement_version = value.to_i
       end
 
       # A supplement carries the publisher/copublishers of the document it

data/lib/pubid/iso/urn_generator.rb

@@ -18,23 +18,6 @@ module Pubid
       URN_CONTEXT = Rendering::RenderingContext.urn.freeze
       private_constant :URN_CONTEXT
 
-      # Stage code mapping for RFC 5141-bis typed stages
-      TYPED_STAGE_MAP = {
-        wd: "WD",
-        wds: "WDS",
-        cd: "CD",
-        cdv: "CDV",
-        dis: "DIS",
-        fdis: "FDIS",
-        pdam: "PDAM",
-        dam: "DAM",
-        fdamd: "FDAM",
-        dcor: "DCOR",
-        fdcor: "FDCOR",
-        cdts: "CDTS",
-        dts: "DTS",
-        fdts: "FDTS",
-      }.freeze
 
       TYPE_CODE_MAP = {
         dir: "dir",
@@ -134,22 +117,17 @@ module Pubid
           suppl_type = supp_gen.supplement_type_component
           parts << suppl_type if suppl_type
 
-          if supp.date
-            parts << supp.date.render(context: URN_CONTEXT)
-            if supp.number
-              if supp.stage_iteration && !supp.is_a?(Pubid::Iso::Identifiers::Supplement)
-                parts << "v#{supp.number}.#{supp.stage_iteration.render(context: URN_CONTEXT)}"
-              else
-                parts << "v#{supp.number}"
-              end
-            end
+          # RFC 5141 supplement slots in order: number, year (the bis
+          # additive extension -- the legacy wire overloaded the number
+          # slot with the year), then the published version ("when a
+          # supplement is published, it is version 1").
+          parts << supp.number.to_s if supp.number
+          parts << supp.date.render(context: URN_CONTEXT) if supp.date
+          version = supp.supplement_version || 1
+          if supp.stage_iteration && !supp.is_a?(Pubid::Iso::Identifiers::Supplement)
+            parts << "v#{version}.#{supp.stage_iteration.render(context: URN_CONTEXT)}"
           else
-            parts << supp.number.to_s if supp.number
-            if supp.stage_iteration && !supp.is_a?(Pubid::Iso::Identifiers::Supplement)
-              parts << "v1.#{supp.stage_iteration.render(context: URN_CONTEXT)}"
-            else
-              parts << "v1"
-            end
+            parts << "v#{version}"
           end
 
           if supp.languages&.any?
@@ -208,26 +186,10 @@ module Pubid
         stage_code = identifier.typed_stage.stage_code
         return nil if !stage_code || stage_code == :published
 
-        combined_key = nil
-        dtc = document_type_code&.to_s
-        if dtc && dtc != "is" && dtc != ""
-          combined_key = :"#{stage_code}#{dtc}"
-        end
-
-        stage_abbr = if combined_key && TYPED_STAGE_MAP.key?(combined_key)
-                       TYPED_STAGE_MAP[combined_key]
-                     elsif TYPED_STAGE_MAP.key?(stage_code.to_sym)
-                       TYPED_STAGE_MAP[stage_code.to_sym]
-                     end
-
-        if stage_abbr
-          if identifier.stage_iteration
-            return "#{stage_abbr}.#{identifier.stage_iteration.render(context: URN_CONTEXT)}"
-          end
-
-          return stage_abbr
-        end
-
+        # RFC 5141 carries the stage as the harmonized code only
+        # ("stage-XX.XX[.vN]"); the typed abbreviations (CD, DIS, DAM...)
+        # live in the human face. Legacy abbreviation URNs are accepted
+        # on ingestion and re-canonicalized here.
         harmonized_codes = identifier.typed_stage.harmonized_stages
         return nil unless harmonized_codes&.any?
 

data/lib/pubid/iso/urn_parser.rb

@@ -175,6 +175,7 @@ module Pubid
         while parts.any?
           supp_type = nil
           supp_number = nil
+          supp_version = nil
           supp_year = nil
           supp_stage = nil
 
@@ -203,14 +204,19 @@ module Pubid
             end
           end
 
-          # Check for version (v1, v2, etc.) after year or number
+          # Check for version (v1, v2, etc.) after year or number.
+          # Legacy year-overloaded wire ("amd:2007:v2" -- the number rode
+          # the version slot): a v-token with no preceding number carries
+          # the NUMBER. The RFC 5141 additive extension ("amd:1:2007:v2")
+          # keeps the number in its own slot, so a v-token after a number
+          # is the true <supplversion>.
           if parts.first&.start_with?("v")
-            version_str = parts.shift
-            supp_number = version_str.sub("v", "").to_i
-            # Handle version with iteration (v1.2)
-            if supp_number.to_s.include?(".")
-              supp_number, = supp_number.to_s.split(".")
-              supp_number = supp_number.to_i
+            version_str = parts.shift.sub("v", "")
+            value = version_str.split(".").first.to_i
+            if supp_number.nil?
+              supp_number = value
+            else
+              supp_version = value
             end
           end
 
@@ -219,6 +225,19 @@ module Pubid
             supp_year = parts.shift
           end
 
+          # A v-token after the year ("amd:1:2007:v1") would otherwise be
+          # left for the next loop iteration, wrapping a type-less
+          # supplement around the real one and losing the base.
+          if parts.first&.start_with?("v")
+            version_str = parts.shift.sub("v", "")
+            value = version_str.split(".").first.to_i
+            if supp_number.nil?
+              supp_number = value
+            else
+              supp_version = value
+            end
+          end
+
           # Check for language after supplement
           supp_languages = nil
           if parts.first && !parts.first.match(/^\d+$/) && !parts.first.match?(/^(amd|cor|sup|add|v\d+|stage-)/i)
@@ -228,6 +247,7 @@ module Pubid
           supplements << {
             type: supp_type,
             number: supp_number,
+            version: supp_version,
             year: supp_year,
             stage: supp_stage,
             languages: supp_languages,
@@ -425,12 +445,31 @@ module Pubid
           supp_hash = {}
 
           if supp[:stage]
-            typed_stage = Pubid::Iso.locate_stage_by_stage_code(supp[:stage])
+            # A harmonized code resolves through the deliverable type
+            # (like the base stage); a supplement-family abbreviation
+            # resolves by abbr -- the typed-stage code differs from the
+            # abbr ("fdamd" for FDAM), so the stage-code lookup misses.
+            typed_stage =
+              if supp[:stage].to_s.match?(/\A\d\d\.\d\d\z/)
+                # resolve within the supplement's own type family -- the
+                # umbrella lookup prefers the IS family, which would turn
+                # a staged Corrigendum into a plain IS
+                code_str = supp[:stage].to_s
+                type_str = supp[:type]&.to_s
+                candidates = Pubid::Iso.all_typed_stages
+                  .select { |st| st.harmonized_stages&.include?(code_str) }
+                candidates.find { |st| st.type_code.to_s == type_str } ||
+                  candidates.find { |st| st.type_code.to_s == "is" } ||
+                  candidates.first
+              else
+                Pubid::Iso.locate_stage(supp[:stage].to_s.upcase) ||
+                  Pubid::Iso.locate_stage_by_stage_code(supp[:stage])
+              end
             supp_hash[:type_with_stage] = if
 typed_stage
                                             typed_stage.abbr.is_a?(Array) ? typed_stage.abbr.first : typed_stage.abbr
                                           else
-                                            supp[:stage].to_s.upcase
+                                            supp[:type]&.to_s&.upcase
                                           end
           end
 
@@ -444,6 +483,10 @@ typed_stage
             supp_hash[:year] = supp[:year].to_s
           end
 
+          if supp[:version]
+            supp_hash[:supplement_version] = supp[:version].to_s
+          end
+
           if supp[:languages]
             supp_hash[:languages] = supp[:languages].join("/")
           end

data/lib/pubid/nist/parser.rb

@@ -139,10 +139,6 @@ module Pubid
       # Single letter: any letter not followed by excluded keywords
       rule(:number_suffix) do
         (str("U") >> lower_letter) |
-          # n+UPPERCASE annex suffix (e.g., 1nA, 85nB — the BH/HR/NCSTAR/SP
-          # annex designations, pubid#555). Before the general letter branch,
-          # which would consume the lone "n" and strand the capital letter.
-          (str("n") >> upper_letter) |
           # An "r" directly followed by a digit is the revision marker (pubid#170),
           # not a suffix — leave it for the second_number/edition rules.
           # The guard sits before the letter so it tests the suffix start itself.

data/lib/pubid/parsers/urn.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Parsers
+    # The :urn format's parse side. The Lutaml FormatRegistry mirror
+    # exposes it as Identifier.from_urn — the surface relaton-bib calls.
+    # It had a renderer but no parser, so every from_urn raised
+    # InvalidFormatError (metanorma-pdfa#108). Detects the flavor from
+    # the URN namespace and delegates to the flavor's UrnParser.
+    module Urn
+      module_function
+
+      def call(string)
+        Pubid.parse_urn(string)
+      end
+    end
+  end
+end

data/lib/pubid/version.rb

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

data/lib/pubid.rb

@@ -216,12 +216,14 @@ module Pubid
   require "pubid/renderers/urn"
   require "pubid/parsers/base"
   require "pubid/parsers/mr_string"
+  require "pubid/parsers/urn"
 
   # Initialize global format registry
   Identifier.format_registry = FormatRegistry.new
   Identifier.format_registry.register(:human, renderer: Renderers::HumanReadable)
   Identifier.format_registry.register(:mr_string, renderer: Renderers::MrString)
-  Identifier.format_registry.register(:urn, renderer: Renderers::Urn)
+  Identifier.format_registry.register(:urn, renderer: Renderers::Urn,
+                                       parser: Parsers::Urn)
 
   # Unified parse entry point with auto-detection
   #
@@ -267,21 +269,32 @@ module Pubid
         parse_by_prefix(string)
       end
     when :urn
-      eager_load_flavors!
-      flavor = detect_flavor_from_urn(string)
-      flavor_module = Registry.get(flavor)
-      unless flavor_module
-        raise ArgumentError,
-              "Unknown flavor in URN: #{flavor}"
-      end
-
-      urn_parser = flavor_module.const_get(:UrnParser)
-      urn_parser.parse(string)
+      parse_urn(string)
     else
       parse_by_prefix(string)
     end
   end
 
+  # Parse an identifier URN, detecting the flavor from the URN namespace
+  # and delegating to the flavor's UrnParser. This is also the :urn
+  # format's parse side (Parsers::Urn), which the Lutaml FormatRegistry
+  # mirror exposes as Identifier.from_urn.
+  #
+  # @param string [String] the URN
+  # @return [Identifier] the parsed identifier
+  def self.parse_urn(string)
+    eager_load_flavors!
+    flavor = detect_flavor_from_urn(string)
+    flavor_module = Registry.get(flavor)
+    unless flavor_module
+      raise ArgumentError,
+            "Unknown flavor in URN: #{flavor}"
+    end
+
+    urn_parser = flavor_module.const_get(:UrnParser)
+    urn_parser.parse(string)
+  end
+
   # Build an identifier from its serialized hash, without naming its flavor —
   # the hash counterpart of {parse}.
   #

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pubid
 version: !ruby/object:Gem::Version
-  version: 2.0.0.pre.alpha.50
+  version: 2.0.0.pre.alpha.52
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-22 00:00:00.000000000 Z
+date: 2026-10-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lutaml-model
@@ -939,6 +939,7 @@ files:
 - lib/pubid/parser/grammar.rb
 - lib/pubid/parsers/base.rb
 - lib/pubid/parsers/mr_string.rb
+- lib/pubid/parsers/urn.rb
 - lib/pubid/pg.rb
 - lib/pubid/plateau.rb
 - lib/pubid/plateau/builder.rb