pubid 2.0.0.pre.alpha.1 → 2.0.0.pre.alpha.3

data/lib/pubid/iso/urn_generator.rb

@@ -4,6 +4,9 @@ module Pubid
   module Iso
     # Generates RFC 5141-bis compliant URNs from ISO identifiers
     #
+    # Components render themselves via `component.render(context: URN_CONTEXT)`;
+    # this class orchestrates them into the URN string structure.
+    #
     # RFC 5141-bis extensions implemented:
     # - Explicit language specification (explicit > implicit)
     # - Extended copublisher syntax (dynamic combinations)
@@ -12,44 +15,39 @@ module Pubid
     # - Supplement chain ordering semantics
     # - Bundled identifier syntax
     class UrnGenerator
+      URN_CONTEXT = Rendering::RenderingContext.urn.freeze
+      private_constant :URN_CONTEXT
+
       # Stage code mapping for RFC 5141-bis typed stages
-      # Maps TypedStage stage_code to URN stage abbreviation
       TYPED_STAGE_MAP = {
-        wd: "WD",          # Working Draft
-        wds: "WDS",        # Working Draft Study
-        cd: "CD",          # Committee Draft
-        cdv: "CDV",        # Committee Draft for Vote
-        dis: "DIS",        # Draft International Standard
-        fdis: "FDIS",      # Final Draft International Standard
-        pdam: "PDAM",      # Proposed Draft Amendment
-        dam: "DAM",        # Draft Amendment
-        fdamd: "FDAM",     # Final Draft Amendment (note: stage_code is fdamd)
-        dcor: "DCOR",      # Draft Corrigendum
-        fdcor: "FDCOR",    # Final Draft Corrigendum
-        cdts: "CDTS",      # Committee Draft Technical Specification
-        dts: "DTS",        # Draft Technical Specification
-        fdts: "FDTS",      # Final Draft Technical Specification
+        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
 
-      # Document type mapping for RFC 5141-bis extended types
       TYPE_CODE_MAP = {
-        dir: "dir",           # Directive
-        dir_sup: "dir-sup",   # Directive Supplement
-        iwa_sup: "iwa-sup",   # IWA Supplement
+        dir: "dir",
+        dir_sup: "dir-sup",
+        iwa_sup: "iwa-sup",
       }.freeze
 
       attr_reader :identifier
 
-      # Initialize URN generator
-      #
-      # @param identifier [Identifier] The ISO identifier to generate URN for
       def initialize(identifier)
         @identifier = identifier
       end
 
-      # Generate complete URN string
-      #
-      # @return [String] The URN in format urn:iso:std:...
       def generate
         if identifier.is_a?(SupplementIdentifier)
           generate_supplement_urn
@@ -60,111 +58,63 @@ module Pubid
 
       protected
 
-      # Generate URN for base identifier (SingleIdentifier)
       def generate_base_urn
         parts = ["urn", "iso", "std"]
-
-        # Publisher (lowercase, hyphen-separated)
         parts << originator_component
-
-        # Type (for non-IS types like TR, TS, Guide)
         type_comp = type_component
         parts << type_comp if type_comp
-
-        # Number
-        parts << identifier.number.value if identifier.number
-
-        # Part (with colon-dash prefix)
+        parts << identifier.number.render(context: URN_CONTEXT) if identifier.number
         part_comp = part_component
         parts << part_comp if part_comp
-
-        # Stage (only for non-published documents)
         stage_comp = stage_component
-        parts << stage_comp if stage_comp
-
-        # Year (for published documents and when edition is present)
+        parts << stage_comp if stage_comp && !identifier.all_parts
         year_comp = year_component
         parts << year_comp if year_comp
-
-        # Edition
         edition_comp = edition_component
         parts << edition_comp if edition_comp
-
-        # Language (RFC 5141-bis: explicit specification)
         lang_comp = language_component
         parts << lang_comp if lang_comp
-
+        parts << "ser" if identifier.all_parts
         parts.join(":")
       end
 
-      # Generate URN for supplement identifier
-      # Handles multi-level supplements by walking up the chain
       def generate_supplement_urn
-        # Walk up supplement chain to collect all supplements
         current = identifier
         supplement_chain = []
 
         while current.is_a?(SupplementIdentifier)
-          supplement_chain.unshift(current) # Add to front (reverse order)
+          supplement_chain.unshift(current)
           current = current.base_identifier
         end
 
-        # Now 'current' is the base document (not a supplement)
         base_id = current
-
-        # Build URN from base identifier
         parts = ["urn", "iso", "std"]
 
         if base_id
           base_gen = self.class.new(base_id)
-
-          # Publisher
           parts << base_gen.originator_component
-
-          # Type (for non-IS types like TR, TS, Guide)
           type_comp = base_gen.type_component
           parts << type_comp if type_comp
-
-          # Number
-          parts << base_id.number.value if base_id.number
-
-          # Part
+          parts << base_id.number.render(context: URN_CONTEXT) if base_id.number
           part_comp = base_gen.part_component
           parts << part_comp if part_comp
 
-          # Collect ALL editions (base + supplements) and add them here
-          # This ensures editions come before all supplement chains
           all_editions = []
-
-          # Base edition first
           edition_comp = base_gen.edition_component
           all_editions << edition_comp if edition_comp
-
-          # Then supplement editions
           supplement_chain.each do |supp|
             if supp.edition&.number
-              all_editions << "ed-#{supp.edition.number}"
+              all_editions << supp.edition.render(context: URN_CONTEXT)
             end
           end
-
-          # Add all editions to parts
           parts.concat(all_editions)
 
-          # Base stage logic:
-          # - Include if base is proposal stage (10.xx) and supplement has different stage
-          # - Don't include if base is approval/publication stage (50.xx, 60.xx)
-          # - Don't include if supplement has same stage as base
           base_stage_comp = base_gen.stage_component
           if base_stage_comp
-            # Check if any supplement has a stage
             supplement_stages = supplement_chain.filter_map do |supp|
-              supp_gen = self.class.new(supp)
-              supp_gen.stage_component
+              self.class.new(supp).stage_component
             end
 
-            # Only include base stage if:
-            # 1. No supplements have a stage, OR
-            # 2. Base is proposal stage (starts with "stage-10.") AND supplements don't duplicate it
             if supplement_stages.empty?
               parts << base_stage_comp
             elsif base_stage_comp.start_with?("stage-10.") && !supplement_stages.include?(base_stage_comp)
@@ -172,127 +122,96 @@ module Pubid
             end
           end
 
-          # Base language (if present)
           if base_id.languages&.any?
-            lang_comp = base_id.languages.map(&:code).join(",")
-            parts << lang_comp
+            parts << language_segment(base_id.languages)
           end
         end
 
-        # Now flatten all supplements in order
         supplement_chain.each do |supp|
           supp_gen = self.class.new(supp)
-
-          # Supplement stage (for draft supplements)
-          # Note: editions are added at base level, not here
           stage_comp = supp_gen.stage_component
           parts << stage_comp if stage_comp
-
-          # Supplement type code (amd, cor, sup)
           suppl_type = supp_gen.supplement_type_component
           parts << suppl_type if suppl_type
 
-          # Year and version (following RFC 5141-bis supplement semantics)
           if supp.date
-            # With date: year:vN
-            parts << supp.date.year.to_s
-
-            # Version with "v" prefix
-            # Amendments/Corrigenda keep iteration, generic Supplements don't
+            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.value}.#{supp.stage_iteration.value}"
+                parts << "v#{supp.number.render(context: URN_CONTEXT)}.#{supp.stage_iteration.render(context: URN_CONTEXT)}"
               else
-                parts << "v#{supp.number.value}"
+                parts << "v#{supp.number.render(context: URN_CONTEXT)}"
               end
             end
           else
-            # Without date: N:v1 (number directly, then "v1")
-            if supp.number
-              parts << supp.number.value
-            end
-
-            # Always add "v1" when no date
-            # Amendments/Corrigenda keep iteration, generic Supplements don't
+            parts << supp.number.render(context: URN_CONTEXT) if supp.number
             if supp.stage_iteration && !supp.is_a?(Pubid::Iso::Identifiers::Supplement)
-              parts << "v1.#{supp.stage_iteration.value}"
+              parts << "v1.#{supp.stage_iteration.render(context: URN_CONTEXT)}"
             else
               parts << "v1"
             end
           end
 
-          # Supplement language (RFC 5141-bis: explicit specification)
           if supp.languages&.any?
-            lang_comp = supp.languages.map(&:code).join(",")
-            parts << lang_comp
+            parts << language_segment(supp.languages)
           end
         end
 
+        parts << "ser" if identifier.all_parts
         parts.join(":")
       end
 
-      # Generate originator component (publisher with copublishers)
-      # RFC 5141-bis: supports dynamic copublisher combinations
       def originator_component
-        # For identifiers like IWA that don't render publisher, default to "iso"
         return "iso" unless identifier.publisher
 
         copubs = identifier.copublishers || []
-
-        # Collect all publishers in order
         publishers = [identifier.publisher] + copubs
+        publishers.map { |p| p.render(context: URN_CONTEXT) }.join("-")
+      end
 
-        # Convert to lowercase and join with hyphen
-        # Keep original order (not alphabetical) for backward compatibility
-        publishers.map(&:body).map(&:downcase).join("-")
+      def document_type_code
+        klass = identifier.class
+        if klass.respond_to?(:type) && klass.type.is_a?(Hash) && klass.type[:key]
+          klass.type[:key]
+        else
+          identifier.typed_stage&.type_code
+        end
       end
 
-      # Generate type component
-      # RFC 5141-bis: supports extended document types (dir, dir-sup, iwa-sup)
       def type_component
         return nil unless identifier.typed_stage
 
-        type_code = identifier.typed_stage.type_code
-        # International Standard is default (skip it)
+        type_code = document_type_code
         return nil if !type_code || type_code.to_s == "is"
 
-        # Check for extended type codes first (RFC 5141-bis)
         type_code_sym = type_code.to_sym
         extended_type = TYPE_CODE_MAP[type_code_sym]
         return extended_type if extended_type
 
-        # Use urn_type_code override if available (e.g., Recommendation uses 'r')
         urn_override = identifier.urn_type_code
         return urn_override if urn_override
 
-        # Default: use type_code as-is (already a string)
         type_code.to_s
       end
 
-      # Generate part component
       def part_component
         return nil unless identifier.part
 
-        result = "-#{identifier.part.value}"
-        result += "-#{identifier.subpart.value}" if identifier.subpart
+        result = "-#{identifier.part.render(context: URN_CONTEXT)}"
+        result += "-#{identifier.subpart.render(context: URN_CONTEXT)}" if identifier.subpart
         result
       end
 
-      # Generate stage component
-      # RFC 5141-bis: supports typed stage codes (WD, CD, DIS, FDIS, etc.)
       def stage_component
         return nil unless identifier.typed_stage
 
         stage_code = identifier.typed_stage.stage_code
         return nil if !stage_code || stage_code == :published
 
-        # Try combined stage+type code first (e.g., "cdts" for CD+TS)
-        # This handles typed stages where stage_code differs from the full typed stage code
         combined_key = nil
-        if identifier.typed_stage.type_code &&
-            identifier.typed_stage.type_code != "is" &&
-            identifier.typed_stage.type_code.to_s != ""
-          combined_key = :"#{stage_code}#{identifier.typed_stage.type_code}"
+        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)
@@ -302,104 +221,83 @@ module Pubid
                      end
 
         if stage_abbr
-
-          # Add iteration if present (no 'v' prefix for iterations)
           if identifier.stage_iteration
-            return "#{stage_abbr}.#{identifier.stage_iteration.value}"
+            return "#{stage_abbr}.#{identifier.stage_iteration.render(context: URN_CONTEXT)}"
           end
 
           return stage_abbr
         end
 
-        # Fallback: use harmonized stage codes for unmapped stages
-        # This handles stages like PWI, NP, AWI, PRF that don't have typed abbreviations
         harmonized_codes = identifier.typed_stage.harmonized_stages
         return nil unless harmonized_codes&.any?
 
-        # Use first harmonized code from the array
         harmonized_code = harmonized_codes.first
 
-        # Skip published documents (60.00, 60.60) EXCEPT for PRF (Proof) stage
-        # PRF is at 60.00 but should still be included in URNs
         if harmonized_code.start_with?("60.") && stage_code.to_s != "prf"
           return nil
         end
 
-        # Format as stage-XX.XX
-        stage_part = "stage-#{harmonized_code}"
+        stage_part = if stage_code.to_s == "prf" && identifier.stage_iteration
+                       "stage-draft"
+                     else
+                       "stage-#{harmonized_code}"
+                     end
 
-        # For base identifiers (not supplements), include iteration in stage code
-        # For supplements, iteration goes in the version part (v1.2)
         if identifier.stage_iteration && !identifier.is_a?(SupplementIdentifier)
-          stage_part += ".v#{identifier.stage_iteration.value}"
+          stage_part += ".v#{identifier.stage_iteration.render(context: URN_CONTEXT)}"
         end
 
         stage_part
       end
 
-      # Generate edition component
       def edition_component
         return nil unless identifier.edition&.number
 
-        "ed-#{identifier.edition.number}"
+        identifier.edition.render(context: URN_CONTEXT)
       end
 
-      # Generate year component
       def year_component
-        return nil unless identifier.date&.year
-
-        # ISO base identifiers (SingleIdentifier) use undated URN format (no year)
-        # Supplements include their own year in the supplement section
+        return nil unless identifier.date&.present?
         return nil if identifier.is_a?(Pubid::Iso::SingleIdentifier)
 
-        identifier.date.year.to_s
+        identifier.date.render(context: URN_CONTEXT)
       end
 
-      # Generate language component
-      # RFC 5141-bis: explicit specification guidance (explicit > implicit)
-      # URN spec: all values in lowercase
       def language_component
         return nil unless identifier.languages&.any?
 
-        identifier.languages.map(&:code).map(&:downcase).join(",")
+        language_segment(identifier.languages)
+      end
+
+      def language_segment(languages)
+        languages.map { |l| l.render(context: URN_CONTEXT) }.join(",")
       end
 
-      # Generate supplement type component
       def supplement_type_component
         return nil unless identifier.typed_stage
 
         urn_override = identifier.urn_supplement_type
         return urn_override if urn_override
 
-        identifier.typed_stage.type_code.to_s
+        document_type_code.to_s
       end
 
-      # Generate supplement year/version components
-      # Returns array of parts to be joined with ":"
       def supplement_year_version_components
         parts = []
 
         if identifier.date
-          # With year: year:version
-          parts << identifier.date.year.to_s
-
-          # Version number with "v" prefix
+          parts << identifier.date.render(context: URN_CONTEXT)
           if identifier.number
             parts << if identifier.stage_iteration
-                       "v#{identifier.number.value}.#{identifier.stage_iteration.value}"
+                       "v#{identifier.number.render(context: URN_CONTEXT)}.#{identifier.stage_iteration.render(context: URN_CONTEXT)}"
                      else
-                       "v#{identifier.number.value}"
+                       "v#{identifier.number.render(context: URN_CONTEXT)}"
                      end
           end
         else
-          # Without year: number directly or "v1"
-          if identifier.number
-            parts << identifier.number.value
-          end
-
-          # Version with iteration if present
+          parts << identifier.number.render(context: URN_CONTEXT) if identifier.number
           parts << if identifier.stage_iteration
-                     "v1.#{identifier.stage_iteration.value}"
+                     "v1.#{identifier.stage_iteration.render(context: URN_CONTEXT)}"
                    else
                      "v1"
                    end

data/lib/pubid/iso/urn_parser.rb

@@ -71,6 +71,15 @@ module Pubid
 
         parts = urn.sub("urn:iso:std:", "").split(":")
 
+        # Series suffix: a trailing "ser" marks an all-parts identifier. Strip
+        # it before component parsing so it is not misread as a language or
+        # supplement token (which previously rendered as "(SER)").
+        all_parts = false
+        if parts.last == "ser"
+          parts.pop
+          all_parts = true
+        end
+
         # Parse publisher(s) - first part
         publishers = parse_publisher(parts.shift)
 
@@ -212,7 +221,8 @@ module Pubid
 
         # Build the identifier hash
         build_identifier(publishers, number, part, subpart, type_code, stage_code, stage_iteration,
-                         harmonized_stage_code, stage_from_abbr, year, edition, languages, supplements)
+                         harmonized_stage_code, stage_from_abbr, year, edition, languages, supplements,
+                         all_parts)
       end
 
       private
@@ -221,7 +231,7 @@ module Pubid
       # Used when URN doesn't specify a type code (defaults to IS)
       # Prefers the most specific (non-published) stage
       def scheme_is_typed_stage_by_harmonized(harmonized_code)
-        candidates = Pubid::Iso::Scheme.instance.all_typed_stages.select do |ts|
+        candidates = Pubid::Iso.all_typed_stages.select do |ts|
           ts.type_code.to_s == "is" && ts.harmonized_stages&.include?(harmonized_code)
         end
 
@@ -302,7 +312,8 @@ module Pubid
 
       # Build identifier from parsed components
       def build_identifier(publishers, number, part, subpart, type_code, stage_code, stage_iteration,
-                         harmonized_stage_code, stage_from_abbr, year, edition, languages, supplements)
+                         harmonized_stage_code, stage_from_abbr, year, edition, languages, supplements,
+                         all_parts = false)
         # Start with base document hash
         base_hash = {
           publisher: publishers.first,
@@ -325,6 +336,11 @@ module Pubid
         # Add type_with_stage if type_code is present
         if type_code && type_code != :is
           base_hash[:type_with_stage] = type_code.to_s.upcase
+          # Pin the document class to the explicit URN type token. The stage
+          # block below may overwrite :type_with_stage with the stage's abbr
+          # (e.g. "WDA" for 90.93, which only exists as an IS-typed stage), so
+          # the builder needs this hint to keep e.g. TR a TechnicalReport.
+          base_hash[:document_type] = type_code.to_s.upcase
         end
 
         # Add stage if present
@@ -337,9 +353,9 @@ module Pubid
             # The stage_from_abbr is the value from TYPED_STAGE_REVERSE_MAP
             # We need to find the reverse to get the original abbreviation
             abbr_str = TYPED_STAGE_REVERSE_MAP.key(stage_from_abbr)
-            typed_stage = Scheme.locate_typed_stage_by_abbr(abbr_str) if abbr_str
+            typed_stage = Pubid::Iso.locate_stage(abbr_str) if abbr_str
             # If no exact match, fall back to stage_code lookup
-            typed_stage ||= Scheme.locate_typed_stage_by_stage_code(stage_from_abbr)
+            typed_stage ||= Pubid::Iso.locate_stage_by_stage_code(stage_from_abbr)
           else
             # Stage came from a harmonized code (e.g., stage-20.20)
             # Look up by harmonized stage code
@@ -349,12 +365,12 @@ module Pubid
             end
 
             # Fall back to any typed stage if IS not found or type_code is specified
-            typed_stage ||= Scheme.locate_typed_stage_by_harmonized_code(stage_code.to_s)
+            typed_stage ||= Pubid::Iso.locate_stage_by_harmonized_code(stage_code.to_s)
 
             # Special handling for stage "40.00": prefer DIS over FCD when parsing from URN
             # This is because FCD is a legacy stage that maps to DIS in URN format
             if stage_code.to_s == "40.00" && typed_stage && typed_stage.stage_code.to_s == "fcd"
-              dis_stage = Scheme.instance.all_typed_stages.detect do |ts|
+              dis_stage = Pubid::Iso.all_typed_stages.detect do |ts|
                 ts.stage_code.to_s == "dis" && ts.harmonized_stages&.include?("40.00")
               end
               typed_stage = dis_stage if dis_stage
@@ -384,7 +400,7 @@ module Pubid
           supp_hash = {}
 
           if supp[:stage]
-            typed_stage = Scheme.locate_typed_stage_by_stage_code(supp[:stage])
+            typed_stage = Pubid::Iso.locate_stage_by_stage_code(supp[:stage])
             supp_hash[:type_with_stage] = if
 typed_stage
                                             typed_stage.abbr.is_a?(Array) ? typed_stage.abbr.first : typed_stage.abbr
@@ -414,8 +430,11 @@ typed_stage
           }
         end
 
+        # all_parts belongs on the outermost identifier (after any supplement wrapping)
+        base_hash[:all_parts] = true if all_parts
+
         # Build the final identifier
-        builder = Pubid::Iso::Builder.new(Pubid::Iso::Scheme.new)
+        builder = Pubid::Iso::Builder.new
         builder.build(base_hash)
       end
     end