pubid 2.0.0.pre.alpha.51 → 2.0.0.pre.alpha.53

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3536887018197616db633b2dda189aca2cca4fefd5f9c12cdc0fef1bd217e1cc
-  data.tar.gz: a8761e51a146f907c3964f1263fcfe4e86a35cae5f62e005ea8020c4425e59a0
+  metadata.gz: 4013c9f2d03ae3ad7ebdafd0f22176d7c72bca2a584ce7ba5dc1c9734cd539f0
+  data.tar.gz: 6b1b1629bd55bef868ac6a8d094b29e573b5a398210bce5df1b5ff593d2484c2
 SHA512:
-  metadata.gz: 97a946c6087270e564c588ec4d8817fd09ea2b945bcfbb304dd39c346ea8a68e624775c4afa16c93ed0633598458a188e96bdc923651896b1e71e19ac9b55c39
-  data.tar.gz: e38a7dd24f3804a18dcb4ae67186542d509fe9cfad18a5d51a8f34b9ba740d313c0d3a82034f182d699864c90d8835acef255733ffe5410d0c3d318bf5e1b472
+  metadata.gz: f3f4b9358cc7a97ef6bd7e586573fa9fda3af7745f39140b0002a2f1a2322052ee75b49a5183d2b58ae0a948f5e654570b920132fce14a4aa8f8b7f0e02dfd6e
+  data.tar.gz: d5563fa6632491b80a6f9795db6f9b9b8f5906285f58f8f3ee13d7a2514aa1bf750ccdf5bce4a3d6545300121b6cc3ae70913bd34fdd8dfc3b26b9465723758a

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

@@ -34,7 +34,10 @@ module Pubid
       SUPPLEMENT_TYPE_MAP = {
         "amd" => :amd,
         "cor" => :cor,
-        "sup" => :sup,
+        # the generic Supplement type key (:suppl, the human grammar's
+        # own) -- :sup resolves the Directives Supplement row, whose
+        # render needs the supplement_publisher a guide chain never has
+        "sup" => :suppl,
         "add" => :add,
       }.freeze
 
@@ -88,7 +91,12 @@ module Pubid
         type_code = parse_type(parts.first) if parts.first && TYPE_CODE_REVERSE_MAP.key?(parts.first.downcase)
         parts.shift if type_code
 
-        # Parse number
+        # Parse number -- REQUIRED by the RFC 5141 docidentifier rule
+        # (originator [":" type] ":" docnumber); a URN without one
+        # ("urn:iso:std:iso") is not a valid NSS, and building it
+        # silently produced the identity-free "ISO "
+        raise Errors::UrnParseError, "missing docnumber: #{urn}" if parts.empty?
+
         number_part = parts.shift
         number, part, subpart = parse_number_part(number_part)
 
@@ -175,6 +183,7 @@ module Pubid
         while parts.any?
           supp_type = nil
           supp_number = nil
+          supp_version = nil
           supp_year = nil
           supp_stage = nil
 
@@ -203,14 +212,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 +233,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 +255,7 @@ module Pubid
           supplements << {
             type: supp_type,
             number: supp_number,
+            version: supp_version,
             year: supp_year,
             stage: supp_stage,
             languages: supp_languages,
@@ -425,12 +453,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 +491,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/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.51"
+  VERSION = "2.0.0.pre.alpha.53"
 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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pubid
 version: !ruby/object:Gem::Version
-  version: 2.0.0.pre.alpha.51
+  version: 2.0.0.pre.alpha.53
 platform: ruby
 authors:
 - Ribose Inc.
@@ -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