pubid 2.0.0.pre.alpha.2 → 2.0.0.pre.alpha.3

data/lib/pubid/iso/parser.rb

@@ -9,10 +9,19 @@ module Pubid
 
       DASH_CHARS = ["-", "‑", "‐"].freeze
 
+      # Supplement identifier type keys (kept as a hard-coded list to match
+      # the previous identifier split; only the base identifier registry
+      # is auto-discovered from the Identifiers namespace).
+      SUPPLEMENT_TYPE_KEYS = %i[amd cor suppl ext add].freeze
+
       # We need to sort by length to match longest first because that's how Parslet works
-      TYPED_STAGES = Pubid::Iso::Scheme.typed_stages
+      TYPED_STAGES = Pubid::Iso.identifier_types
+        .reject { |k| SUPPLEMENT_TYPE_KEYS.include?(k.type[:key]) }
+        .flat_map { |k| k.const_defined?(:TYPED_STAGES) ? k.const_get(:TYPED_STAGES) : [] }
         .map(&:abbr).flatten.sort_by(&:length).reverse
-      TYPED_STAGES_SUPPLEMENTS = Pubid::Iso::Scheme.supplement_typed_stages
+      TYPED_STAGES_SUPPLEMENTS = Pubid::Iso.identifier_types
+        .select { |k| SUPPLEMENT_TYPE_KEYS.include?(k.type[:key]) }
+        .flat_map { |k| k.const_defined?(:TYPED_STAGES) ? k.const_get(:TYPED_STAGES) : [] }
         .map(&:abbr).flatten.sort_by(&:length).reverse
 
       root :identifier
@@ -66,7 +75,9 @@ module Pubid
       end
 
       rule(:sc_type) do
-        str("SC").as(:sc_type)
+        # "SC" plus the "SC/QC" quality-committee variant
+        # (e.g. ISO/TC 184/SC/QC 4 N 246). Longest first for Parslet.
+        (str("SC/QC") | str("SC")).as(:sc_type)
       end
 
       rule(:wg_type) do
@@ -327,7 +338,9 @@ module Pubid
       rule(:supplement_identifier_no_third) do
         identifier_copublishers_no_third.as(:base_identifier) >>
           str("/") >> supplement_type_with_stage >>
-          ((space? >> second_part) | (str(".") >> digits.as(:number)) | (space? >> date))
+          # The trailing number/date is optional: some draft supplements have no
+          # number yet, e.g. "ISO/IEC 9579/WD Amd".
+          ((space? >> second_part) | (str(".") >> digits.as(:number)) | (space? >> date)).maybe
       end
 
       rule(:supplement_identifier) do
@@ -383,6 +396,11 @@ module Pubid
         prefix_with_copublishers >> space? >>
           (directives_publisher_subgroup >> space).maybe >>
           array_to_str(DIRECTIVES_TYPED_STAGES).as(:type_with_stage) >>
+          # The subgroup may also follow the type, e.g. "ISO/IEC DIR JTC 1"
+          # (canonical form is "ISO/IEC JTC 1 DIR"). Guard against a trailing
+          # supplement, where "JTC 1" is the supplement publisher instead
+          # (e.g. "ISO/IEC DIR JTC 1 SUP").
+          (space >> directives_publisher_subgroup >> (space >> str("SUP")).absent?).maybe >>
           (
             (space >> directives_number_with_part).maybe >>
             (str(":") >> date).maybe

data/lib/pubid/iso/supplement_identifier.rb

@@ -7,14 +7,27 @@ module Pubid
                 polymorphic: true
 
       key_value do
-        map "base_identifier", to: :base_identifier, polymorphic: {
+        # Serialized key is "base" (matches JIS); the attribute/method stays
+        # `base_identifier`, which relaton-index's get_id_number depends on.
+        map "base", to: :base_identifier, polymorphic: {
           attribute: "_type",
           class_map: Identifier::ISO_TYPE_MAP,
         }
       end
 
+      # A supplement carries the publisher/copublishers of the document it
+      # supplements. Delegate to the root rather than the immediate base so a
+      # nested supplement (e.g. ".../Amd 1/Cor 1") reads identity from the
+      # underlying standard in one hop, regardless of chain depth. This keeps a
+      # parsed supplement and a from_hash-deserialized one in agreement (== and
+      # index matching compare both). Guard on base_identifier: `root` returns
+      # self when there is no base, which would otherwise recurse forever.
       def publisher
-        base_identifier&.publisher
+        root.publisher if base_identifier
+      end
+
+      def copublishers
+        root.copublishers if base_identifier
       end
 
       def to_s(**opts)

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,115 +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); an all-parts series
-        # reference carries no specific stage.
         stage_comp = stage_component
         parts << stage_comp if stage_comp && !identifier.all_parts
-
-        # 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
-
-        # Series suffix for all-parts identifiers (compact, no padding)
         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)
@@ -176,130 +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
 
-        # Series suffix for all-parts identifiers (compact, no padding)
         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)
@@ -309,111 +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
-        # An iterated PRF (Proof) stage (e.g. "PRF TR 17716.2") renders as the
-        # symbolic "draft" stage in the URN rather than its harmonized numeric
-        # code; a plain PRF without an iteration keeps the 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

@@ -231,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
 
@@ -336,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
@@ -348,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
@@ -360,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
@@ -395,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
@@ -429,7 +434,7 @@ typed_stage
         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