pubid 2.0.0.alpha.10 → 2.0.0.pre.alpha.1

data/lib/pubid/iso/urn_generator.rb

@@ -4,9 +4,6 @@ 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)
@@ -15,39 +12,44 @@ 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",
-        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",
+        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
       }.freeze
 
+      # Document type mapping for RFC 5141-bis extended types
       TYPE_CODE_MAP = {
-        dir: "dir",
-        dir_sup: "dir-sup",
-        iwa_sup: "iwa-sup",
+        dir: "dir",           # Directive
+        dir_sup: "dir-sup",   # Directive Supplement
+        iwa_sup: "iwa-sup",   # IWA Supplement
       }.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
@@ -58,63 +60,111 @@ 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
-        parts << identifier.number.render(context: URN_CONTEXT) if identifier.number
+
+        # Number
+        parts << identifier.number.value if identifier.number
+
+        # Part (with colon-dash prefix)
         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 && !identifier.all_parts
+        parts << stage_comp if stage_comp
+
+        # Year (for published documents and when edition is present)
         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)
-          current = current.base
+          supplement_chain.unshift(current) # Add to front (reverse order)
+          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
-          parts << base_id.number.render(context: URN_CONTEXT) if base_id.number
+
+          # Number
+          parts << base_id.number.value if base_id.number
+
+          # Part
           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 << supp.edition.render(context: URN_CONTEXT)
+              all_editions << "ed-#{supp.edition.number}"
             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|
-              self.class.new(supp).stage_component
+              supp_gen = self.class.new(supp)
+              supp_gen.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)
@@ -122,96 +172,127 @@ module Pubid
             end
           end
 
+          # Base language (if present)
           if base_id.languages&.any?
-            parts << language_segment(base_id.languages)
+            lang_comp = base_id.languages.map(&:code).join(",")
+            parts << lang_comp
           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
-            parts << supp.date.render(context: URN_CONTEXT)
+            # With date: year:vN
+            parts << supp.date.year.to_s
+
+            # Version with "v" prefix
+            # Amendments/Corrigenda keep iteration, generic Supplements don't
             if supp.number
               if supp.stage_iteration && !supp.is_a?(Pubid::Iso::Identifiers::Supplement)
-                parts << "v#{supp.number.render(context: URN_CONTEXT)}.#{supp.stage_iteration.render(context: URN_CONTEXT)}"
+                parts << "v#{supp.number.value}.#{supp.stage_iteration.value}"
               else
-                parts << "v#{supp.number.render(context: URN_CONTEXT)}"
+                parts << "v#{supp.number.value}"
               end
             end
           else
-            parts << supp.number.render(context: URN_CONTEXT) if supp.number
+            # 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
             if supp.stage_iteration && !supp.is_a?(Pubid::Iso::Identifiers::Supplement)
-              parts << "v1.#{supp.stage_iteration.render(context: URN_CONTEXT)}"
+              parts << "v1.#{supp.stage_iteration.value}"
             else
               parts << "v1"
             end
           end
 
+          # Supplement language (RFC 5141-bis: explicit specification)
           if supp.languages&.any?
-            parts << language_segment(supp.languages)
+            lang_comp = supp.languages.map(&:code).join(",")
+            parts << lang_comp
           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
 
-      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
+        # Convert to lowercase and join with hyphen
+        # Keep original order (not alphabetical) for backward compatibility
+        publishers.map(&:body).map(&:downcase).join("-")
       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 = document_type_code
+        type_code = identifier.typed_stage.type_code
+        # International Standard is default (skip it)
         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.render(context: URN_CONTEXT)}"
-        result += "-#{identifier.subpart.render(context: URN_CONTEXT)}" if identifier.subpart
+        result = "-#{identifier.part.value}"
+        result += "-#{identifier.subpart.value}" 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
-        dtc = document_type_code&.to_s
-        if dtc && dtc != "is" && dtc != ""
-          combined_key = :"#{stage_code}#{dtc}"
+        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}"
         end
 
         stage_abbr = if combined_key && TYPED_STAGE_MAP.key?(combined_key)
@@ -221,86 +302,104 @@ 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.render(context: URN_CONTEXT)}"
+            return "#{stage_abbr}.#{identifier.stage_iteration.value}"
           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
 
-        stage_part = if stage_code.to_s == "prf" && identifier.stage_iteration
-                       "stage-draft"
-                     else
-                       "stage-#{harmonized_code}"
-                     end
+        # Format as stage-XX.XX
+        stage_part = "stage-#{harmonized_code}"
 
+        # 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.render(context: URN_CONTEXT)}"
+          stage_part += ".v#{identifier.stage_iteration.value}"
         end
 
         stage_part
       end
 
+      # Generate edition component
       def edition_component
         return nil unless identifier.edition&.number
 
-        identifier.edition.render(context: URN_CONTEXT)
+        "ed-#{identifier.edition.number}"
       end
 
+      # Generate year component
       def year_component
-        return nil unless identifier.date&.present?
-        # Undated references (e.g. ISO 16634:--) drop the year slot in the URN,
-        # matching the date-less identifier's URN form (per issue #138).
-        return nil if identifier.date&.undated?
+        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 if identifier.is_a?(Pubid::Iso::SingleIdentifier)
 
-        identifier.date.render(context: URN_CONTEXT)
+        identifier.date.year.to_s
       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?
 
-        language_segment(identifier.languages)
-      end
-
-      def language_segment(languages)
-        languages.map { |l| l.render(context: URN_CONTEXT) }.join(",")
+        identifier.languages.map(&:code).map(&:downcase).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
 
-        document_type_code.to_s
+        identifier.typed_stage.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
-          parts << identifier.date.render(context: URN_CONTEXT)
+          # With year: year:version
+          parts << identifier.date.year.to_s
+
+          # Version number with "v" prefix
           if identifier.number
             parts << if identifier.stage_iteration
-                       "v#{identifier.number.render(context: URN_CONTEXT)}.#{identifier.stage_iteration.render(context: URN_CONTEXT)}"
+                       "v#{identifier.number.value}.#{identifier.stage_iteration.value}"
                      else
-                       "v#{identifier.number.render(context: URN_CONTEXT)}"
+                       "v#{identifier.number.value}"
                      end
           end
         else
-          parts << identifier.number.render(context: URN_CONTEXT) if identifier.number
+          # Without year: number directly or "v1"
+          if identifier.number
+            parts << identifier.number.value
+          end
+
+          # Version with iteration if present
           parts << if identifier.stage_iteration
-                     "v1.#{identifier.stage_iteration.render(context: URN_CONTEXT)}"
+                     "v1.#{identifier.stage_iteration.value}"
                    else
                      "v1"
                    end

data/lib/pubid/iso/urn_parser.rb

@@ -71,15 +71,6 @@ 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)
 
@@ -221,8 +212,7 @@ 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,
-                         all_parts)
+                         harmonized_stage_code, stage_from_abbr, year, edition, languages, supplements)
       end
 
       private
@@ -231,7 +221,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.all_typed_stages.select do |ts|
+        candidates = Pubid::Iso::Scheme.instance.all_typed_stages.select do |ts|
           ts.type_code.to_s == "is" && ts.harmonized_stages&.include?(harmonized_code)
         end
 
@@ -312,8 +302,7 @@ 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,
-                         all_parts = false)
+                         harmonized_stage_code, stage_from_abbr, year, edition, languages, supplements)
         # Start with base document hash
         base_hash = {
           publisher: publishers.first,
@@ -336,11 +325,6 @@ 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
@@ -353,9 +337,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 = Pubid::Iso.locate_stage(abbr_str) if abbr_str
+            typed_stage = Scheme.locate_typed_stage_by_abbr(abbr_str) if abbr_str
             # If no exact match, fall back to stage_code lookup
-            typed_stage ||= Pubid::Iso.locate_stage_by_stage_code(stage_from_abbr)
+            typed_stage ||= Scheme.locate_typed_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
@@ -365,12 +349,12 @@ module Pubid
             end
 
             # Fall back to any typed stage if IS not found or type_code is specified
-            typed_stage ||= Pubid::Iso.locate_stage_by_harmonized_code(stage_code.to_s)
+            typed_stage ||= Scheme.locate_typed_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 = Pubid::Iso.all_typed_stages.detect do |ts|
+              dis_stage = Scheme.instance.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
@@ -400,7 +384,7 @@ module Pubid
           supp_hash = {}
 
           if supp[:stage]
-            typed_stage = Pubid::Iso.locate_stage_by_stage_code(supp[:stage])
+            typed_stage = Scheme.locate_typed_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
@@ -425,16 +409,13 @@ typed_stage
 
           # Wrap current identifier with supplement
           base_hash = {
-            base: base_hash,
+            base_identifier: base_hash,
             **supp_hash,
           }
         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
+        builder = Pubid::Iso::Builder.new(Pubid::Iso::Scheme.new)
         builder.build(base_hash)
       end
     end