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

data/lib/pubid/nist.rb

@@ -3,13 +3,51 @@
 module Pubid
   module Nist
     autoload :Builder, "#{__dir__}/nist/builder"
+    autoload :Caster, "#{__dir__}/nist/caster"
+    autoload :CircularSupplementBuilder, "#{__dir__}/nist/circular_supplement_builder"
     autoload :Components, "#{__dir__}/nist/components"
     autoload :Configuration, "#{__dir__}/nist/configuration"
+    autoload :Identifier, "#{__dir__}/nist/identifier"
     autoload :Identifiers, "#{__dir__}/nist/identifiers"
     autoload :Parser, "#{__dir__}/nist/parser"
-    autoload :Scheme, "#{__dir__}/nist/scheme"
+    autoload :ParserOutputNormalizer, "#{__dir__}/nist/parser_output_normalizer"
+    autoload :Preprocessor, "#{__dir__}/nist/preprocessor"
+    autoload :Renderer, "#{__dir__}/nist/renderer"
+    autoload :Router, "#{__dir__}/nist/router"
+    autoload :Series, "#{__dir__}/nist/series"
     autoload :SupplementIdentifier, "#{__dir__}/nist/supplement_identifier"
     autoload :UrnGenerator, "#{__dir__}/nist/urn_generator"
+    autoload :UrnParser, "#{__dir__}/nist/urn_parser"
+
+    # Explicit registry of NIST identifier classes.
+    #
+    # NIST identifier classes use `typed_stages` (not the `self.type` Hash
+    # pattern used by CEN/JCGM/ANSI), so they cannot be auto-discovered.
+    # Identifiers::Base is the fallback for unmapped series (e.g. AMS, VTS)
+    # and must be excluded from typed-stage aggregation.
+    IDENTIFIER_TYPES = [
+      Identifiers::SpecialPublication,
+      Identifiers::FederalInformationProcessingStandards,
+      Identifiers::InteragencyReport,
+      Identifiers::Handbook,
+      Identifiers::TechnicalNote,
+      Identifiers::Circular,
+      Identifiers::CircularSupplement,
+      Identifiers::CrplReport,
+      Identifiers::Report,
+      Identifiers::Monograph,
+      Identifiers::MiscellaneousPublication,
+      Identifiers::GrantContractorReport,
+      Identifiers::Ncstar,
+      Identifiers::Owmwp,
+      Identifiers::Nsrds,
+      Identifiers::LetterCircular,
+      Identifiers::CommercialStandard,
+      Identifiers::CommercialStandardEmergency,
+      Identifiers::CommercialStandardsMonthly,
+      Identifiers::DatedDocument,
+      Identifiers::Base, # Fallback for unmapped series
+    ].freeze
 
     # Parse a NIST identifier string
     # @param identifier [String] the identifier string to parse
@@ -19,9 +57,8 @@ module Pubid
       # Note: We call the class method directly to ensure preprocessing is applied
       parsed = Parser.class_parse_with_preprocessing(identifier)
 
-      # Use Scheme and Builder for clean architecture
-      # ONE CLASS PER SERIES TYPE (like ISO)
-      builder = Builder.new(Scheme)
+      # Builder is stateless — lookups go through this module (Pubid::Nist)
+      builder = Builder.new
       builder.build(parsed)
     end
 
@@ -30,6 +67,48 @@ module Pubid
     def self.configuration
       @configuration ||= Configuration.new
     end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    Identifiers::Base.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
+    Identifiers::Base.format_registry.register(:human, renderer: Nist::Renderer)
+
+    # All identifier classes for external consumption (export, website).
+    # Identifiers::Base is the fallback for unmapped series and is excluded
+    # from external type listings.
+    # @return [Array<Class>] identifier classes
+    def self.identifier_types
+      IDENTIFIER_TYPES.reject { |klass| klass == Identifiers::Base }
+    end
+
+    # Aggregate TYPED_STAGES from all identifier classes.
+    # Identifiers::Base is excluded because it has no typed stages and acts
+    # as the fallback for unmapped series.
+    # @return [Array<Pubid::Components::TypedStage>] all typed stages
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types
+        .reject { |klass| klass == Identifiers::Base }
+        .flat_map(&:typed_stages)
+        .freeze
+    end
+
+    # Lookup: type code -> identifier class.
+    # Identifiers::Base is excluded so it never gets selected by type code.
+    # @param code [String, Symbol] the type code to find
+    # @return [Class, nil] the matching identifier class, or nil
+    def self.locate_type(code)
+      type_str = code.to_s
+      identifier_types
+        .reject { |klass| klass == Identifiers::Base }
+        .find { |klass| klass.typed_stages.any? { |ts| ts.type_code.to_s == type_str } }
+    end
+
+    # Lookup: abbreviation -> typed stage
+    # @param abbr [String, Symbol] the abbreviation to find
+    # @return [Pubid::Components::TypedStage, nil] the matching typed stage
+    def self.locate_stage(abbr)
+      abbr_str = abbr.to_s.upcase
+      all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
+    end
   end
 end
 

data/lib/pubid/oiml/components/code.rb

@@ -3,6 +3,12 @@
 module Pubid
   module Oiml
     module Components
+      # Code component for OIML identifiers.
+      #
+      # Stays independent of Pubid::Components::Code because OIML uses
+      # +number+ as the primary field (shared Code uses +value+). The
+      # shape is otherwise compatible; a future rename of +number+ →
+      # +value+ would let this become a subclass.
       class Code < Lutaml::Model::Serializable
         attribute :number, :string
         attribute :part, :string
@@ -14,6 +20,10 @@ module Pubid
           result += "-#{subpart}" if subpart
           result
         end
+
+        def render(context: nil)
+          to_s
+        end
       end
     end
   end

data/lib/pubid/oiml/identifiers/annex.rb

@@ -10,51 +10,9 @@ module Pubid
           letter ? "Annex #{letter}" : "Annexes"
         end
 
-        def to_s(format: nil)
-          # Determine base format from its parsed_format
-          base_format = if base_identifier.class.attributes.key?(:parsed_format) && base_identifier.parsed_format == "long"
-                          :long
-                        else
-                          :short
-                        end
-
-          # Use format parameter or annex's own parsed_format
-          annex_format = if format
-                           format
-                         elsif self.class.attributes.key?(:parsed_format) && parsed_format == "long"
-                           :long
-                         else
-                           :short
-                         end
-
-          # Annexes have different pattern than amendments
-          base_str = base_identifier.to_s(format: base_format)
-          result = base_str.sub(/:.*/, "").sub(/\s+Edition\s+\d{4}/, "").sub(
-            /\(.*\)/, ""
-          ).strip
-          if letter
-            # Specific annex: "OIML R 60 Annex A Edition 2013 (E)"
-            result += " Annex #{letter}"
-
-            result += " Edition #{year}" if year
-
-          # Supplements ALWAYS use space before language
-
-          else
-            # General annexes: "OIML R 60 Annexes Edition 2021 (E)" or "OIML R 60 Annexes:2021 (E)"
-            result += " Annexes"
-
-            if year
-              result += annex_format == :long ? " Edition #{year}" : ":#{year}"
-            elsif base_identifier.date
-              result += annex_format == :long ? " Edition #{base_identifier.date.year}" : ":#{base_identifier.date.year}"
-            end
-
-            # Supplements ALWAYS use space before language
-
-          end
-          result += " (#{language})" if language
-          result
+        def to_s(format: nil, **opts)
+          @requested_format = format
+          render(format: :human, **opts)
         end
       end
     end

data/lib/pubid/oiml/identifiers/base.rb

@@ -12,23 +12,8 @@ module Pubid
         attribute :iteration, :string
         attribute :language, :string
 
-        def to_s
-          result = "#{publisher} #{type} #{code}"
-
-          # Add date if present
-          result += ":#{date.year}" if date
-
-          # Add draft stage if present (iteration + stage)
-          if stage || iteration
-            result += " "
-            result += iteration.to_s if iteration
-            result += stage.to_s if stage
-          end
-
-          # Add language portion if present
-          result += "(#{language})" if language
-
-          result
+        def to_s(**opts)
+          render(format: :human, **opts)
         end
       end
     end

data/lib/pubid/oiml/renderer.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    # Human-readable renderer for OIML identifiers.
+    #
+    # Produces strings like:
+    #   "OIML R 60:2000"
+    #   "OIML R 60 Edition 2013"
+    #   "OIML R 60 Annex A Edition 2013 (E)"
+    #   "OIML R 60 Annexes:2021 (E)"
+    #
+    # The renderer is registered as the `:human` format in the OIML format
+    # registry and invoked via `render(format: :human)`.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        id = @id
+        @context = context
+
+        case id
+        when Identifiers::Annex
+          render_annex(id)
+        when SupplementIdentifier
+          render_supplement(id)
+        when SingleIdentifier
+          render_single(id)
+        when Identifiers::Base
+          render_base_identifier(id)
+        else
+          id.to_s
+        end
+      end
+
+      private
+
+      def effective_format(id)
+        id.requested_format ||
+          (id.parsed_format == "long" ? :long : :short)
+      end
+
+      def render_single(id)
+        format = effective_format(id)
+
+        result = "#{id.publisher} #{id.type_string} #{id.code}"
+
+        using_edition_format = false
+
+        if id.edition && id.date
+          result += " #{id.edition} Edition #{id.date.render(context: @context)}"
+          using_edition_format = true
+        elsif id.edition
+          result += " #{id.edition}"
+          using_edition_format = true
+        elsif id.date
+          if format == :long
+            result += " Edition #{id.date.render(context: @context)}"
+            using_edition_format = true
+          else
+            result += ":#{id.date.render(context: @context)}"
+          end
+        end
+
+        if id.stage || id.iteration
+          result += " "
+          result += id.iteration.to_s if id.iteration
+          result += id.stage.to_s if id.stage
+        end
+
+        if id.language
+          result += if using_edition_format || id.parsed_format == "short_with_space"
+                      " (#{id.language})"
+                    else
+                      "(#{id.language})"
+                    end
+        end
+
+        result
+      end
+
+      def render_supplement(id)
+        format = effective_format(id)
+
+        base_format = if format && format != :short
+                        format
+                      elsif id.base_identifier.class.attributes.key?(:parsed_format) && id.base_identifier.parsed_format == "long"
+                        :long
+                      else
+                        :short
+                      end
+
+        base_str = if id.base_identifier.is_a?(SingleIdentifier)
+                     id.base_identifier.to_s(format: base_format)
+                   else
+                     id.base_identifier.to_s
+                   end
+        base_str = base_str.sub(/\s*\([^)]+\)\s*$/, "").strip
+
+        result = "#{id.supplement_type} (#{id.year}) to #{base_str}"
+        result += " (#{id.language})" if id.language
+
+        result
+      end
+
+      def render_annex(id)
+        format = effective_format(id)
+
+        base_format = if id.base_identifier.class.attributes.key?(:parsed_format) && id.base_identifier.parsed_format == "long"
+                        :long
+                      else
+                        :short
+                      end
+
+        annex_format = if format
+                         format
+                       elsif id.class.attributes.key?(:parsed_format) && id.parsed_format == "long"
+                         :long
+                       else
+                         :short
+                       end
+
+        base_str = if id.base_identifier.is_a?(SingleIdentifier)
+                     id.base_identifier.to_s(format: base_format)
+                   else
+                     id.base_identifier.to_s
+                   end
+        result = base_str.sub(/:.*/, "").sub(/\s+Edition\s+\d{4}/, "").sub(
+          /\(.*\)/, ""
+        ).strip
+
+        if id.letter
+          result += " Annex #{id.letter}"
+          result += " Edition #{id.year}" if id.year
+        else
+          result += " Annexes"
+          if id.year
+            result += annex_format == :long ? " Edition #{id.year}" : ":#{id.year}"
+          elsif id.base_identifier.date
+            result += annex_format == :long ? " Edition #{id.base_identifier.date.render(context: @context)}" : ":#{id.base_identifier.date.render(context: @context)}"
+          end
+        end
+
+        result += " (#{id.language})" if id.language
+        result
+      end
+
+      def render_base_identifier(id)
+        result = "#{id.publisher} #{id.type} #{id.code}"
+        result += ":#{id.date.render(context: @context)}" if id.date
+
+        if id.stage || id.iteration
+          result += " "
+          result += id.iteration.to_s if id.iteration
+          result += id.stage.to_s if id.stage
+        end
+
+        result += "(#{id.language})" if id.language
+        result
+      end
+    end
+  end
+end

data/lib/pubid/oiml/single_identifier.rb

@@ -15,56 +15,17 @@ module Pubid
         "short"
       } # Track parsed format
 
+      attr_reader :requested_format
+
       # Type is determined by the subclass
       def type
         type_string
       end
 
-      def to_s(format: nil)
-        # Use parsed format if not explicitly overridden
-        format ||= (parsed_format == "long" ? :long : :short)
-
-        result = "#{publisher} #{type_string} #{code}"
-
-        # Track if we're using Edition format for language spacing
-        using_edition_format = false
-
-        # Add edition/date portion
-        if edition && date
-          # Has edition number: "6th Edition 2015"
-          result += " #{edition} Edition #{date.year}"
-          using_edition_format = true
-        elsif edition
-          # Edition without year (shouldn't happen but handle it)
-          result += " #{edition}"
-          using_edition_format = true
-        elsif date
-          # Date without edition number
-          if format == :long
-            result += " Edition #{date.year}"
-            using_edition_format = true
-          else
-            result += ":#{date.year}"
-          end
-        end
-
-        # Add draft stage if present (iteration + stage)
-        if stage || iteration
-          result += " "
-          result += iteration.to_s if iteration
-          result += stage.to_s if stage
-        end
-
-        # Add language portion - depends on format
-        if language
-          result += if using_edition_format || parsed_format == "short_with_space"
-                      " (#{language})"
-                    else
-                      "(#{language})"
-                    end
-        end
-
-        result
+      def to_s(format: nil, **opts)
+        # Store requested format so the renderer can access it
+        @requested_format = format
+        render(format: :human, **opts)
       end
 
       def edition_portion

data/lib/pubid/oiml/supplement_identifier.rb

@@ -12,26 +12,11 @@ module Pubid
         "short"
       } # Track supplement's parsed format
 
-      def to_s(format: :short)
-        # Determine base format: explicit parameter takes priority, else use parsed format
-        base_format = if format && format != :short
-                        format # Use explicit override
-                      elsif base_identifier.class.attributes.key?(:parsed_format) && base_identifier.parsed_format == "long"
-                        :long
-                      else
-                        :short
-                      end
+      attr_reader :requested_format
 
-        # Render base with determined format (preserves Edition vs colon)
-        base_str = base_identifier.to_s(format: base_format)
-        base_str = base_str.sub(/\s*\([^)]+\)\s*$/, "").strip # Remove language from base
-
-        result = "#{supplement_type} (#{year}) to #{base_str}"
-
-        # Supplements ALWAYS add space before their language
-        result += " (#{language})" if language
-
-        result
+      def to_s(format: nil, **opts)
+        @requested_format = format
+        render(format: :human, **opts)
       end
 
       # Subclasses override this

data/lib/pubid/oiml/urn_generator.rb

@@ -15,14 +15,6 @@ module Pubid
         identifier.code.to_s
       end
 
-      def urn_year
-        if identifier.date&.year
-          return identifier.date.year.to_s
-        end
-
-        nil
-      end
-
       def urn_stage
         identifier.stage&.to_s&.downcase
       end

data/lib/pubid/oiml/urn_parser.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Oiml
+    # Parses OIML URNs back into identifiers.
+    #
+    # UrnGenerator emits: `urn:oiml:{type}:{number}[-{part}]` where type
+    # is the lowercase document class (r for Recommendation, d for Document).
+    #
+    # Examples:
+    # - urn:oiml:r:111-1 → OIML R 111-1
+    # - urn:oiml:d:1     → OIML D 1
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+        type_token, number = parts
+        flavor_parse("OIML #{type_token.upcase} #{number}")
+      end
+    end
+  end
+end

data/lib/pubid/oiml.rb

@@ -7,10 +7,11 @@ module Pubid
     autoload :Identifier, "#{__dir__}/oiml/identifier"
     autoload :Identifiers, "#{__dir__}/oiml/identifiers"
     autoload :Parser, "#{__dir__}/oiml/parser"
-    autoload :Scheme, "#{__dir__}/oiml/scheme"
+    autoload :Renderer, "#{__dir__}/oiml/renderer"
     autoload :SingleIdentifier, "#{__dir__}/oiml/single_identifier"
     autoload :SupplementIdentifier, "#{__dir__}/oiml/supplement_identifier"
     autoload :UrnGenerator, "#{__dir__}/oiml/urn_generator"
+    autoload :UrnParser, "#{__dir__}/oiml/urn_parser"
 
     def self.parse(identifier)
       parser = Parser.new
@@ -19,6 +20,46 @@ module Pubid
       parsed = parser.parse(identifier)
       builder.build(parsed)
     end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Oiml::Renderer)
+
+    # Auto-discover all identifier types from the Identifiers namespace
+    # @return [Array<Class>] identifier classes that define a self.type Hash
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants
+        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
+        .select { |c| c.is_a?(Class) && c.singleton_methods(false).include?(:type) }
+        .select { |c| c.type.is_a?(Hash) }
+    end
+
+    # Build typed stage index from identifier types
+    # @return [Array<Pubid::Components::TypedStage>] all typed stages
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types.flat_map do |klass|
+        if klass.const_defined?(:TYPED_STAGES)
+          klass.const_get(:TYPED_STAGES)
+        else
+          []
+        end
+      end
+    end
+
+    # Lookup: type code -> identifier class
+    # @param code [String, Symbol] the type key to find
+    # @return [Class, nil] the matching identifier class
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    # Lookup: abbreviation -> typed stage
+    # @param abbr [String, Symbol] the abbreviation to find
+    # @return [Pubid::Components::TypedStage, nil] the matching typed stage
+    def self.locate_stage(abbr)
+      abbr_str = abbr.to_s.upcase
+      all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
+    end
   end
 end
 

data/lib/pubid/plateau/identifier.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Plateau
+    # Plateau factory entry point. `.parse` lives on `Pubid::Plateau`
+    # itself for historical reasons; this module hosts `.create` for API
+    # consistency with the other pubid flavors.
+    #
+    # NOTE: intentionally does NOT `extend Pubid::IdentifierFacade`. PLATEAU's
+    # `to_hash` currently raises (publisher stored as a String, not a Publisher
+    # component), so enabling the facade's identity check would route PLATEAU
+    # ids through a consumer's `to_hash` (e.g. relaton-index#save) and crash.
+    # Re-enable once PLATEAU serialization round-trips cleanly. See
+    # identifier_facade.rb.
+    module Identifier
+      # Delegate to the flavor module so callers can use
+      # `Pubid::Plateau::Identifier.parse` consistently with other flavors.
+      def self.parse(identifier)
+        Pubid::Plateau.parse(identifier)
+      end
+    end
+  end
+end

data/lib/pubid/plateau/identifiers/handbook.rb

@@ -14,9 +14,7 @@ module Pubid
         end
 
         def to_s
-          result = "#{publisher} #{type_string} #{formatted_number}#{formatted_annex}"
-          result += " #{formatted_edition}" if edition
-          result
+          render(format: :human)
         end
 
         def formatted_edition

data/lib/pubid/plateau/identifiers/technical_report.rb

@@ -12,7 +12,7 @@ module Pubid
         end
 
         def to_s
-          "#{publisher} #{type_string} #{formatted_number}#{formatted_annex}"
+          render(format: :human)
         end
       end
     end

data/lib/pubid/plateau/renderer.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Plateau
+    # Human-readable renderer for PLATEAU identifiers.
+    #
+    # Produces strings like:
+    #   "PLATEAU Technical Report #01"
+    #   "PLATEAU Handbook #00 第1.0版"
+    #   "PLATEAU Handbook #01-1 Annex A"
+    #
+    # The renderer is registered as the `:human` format in the PLATEAU format
+    # registry and invoked via `render(format: :human)`.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        id = @id
+
+        case id
+        when SupplementIdentifier
+          render_supplement(id)
+        when Identifiers::Handbook
+          render_handbook(id)
+        when Identifiers::TechnicalReport
+          render_technical_report(id)
+        else
+          render_base(id)
+        end
+      end
+
+      private
+
+      def render_base(id)
+        "#{id.publisher} #{id.type_string} #{id.formatted_number}#{id.formatted_annex}"
+      end
+
+      def render_technical_report(id)
+        "#{id.publisher} #{id.type_string} #{id.formatted_number}#{id.formatted_annex}"
+      end
+
+      def render_handbook(id)
+        result = "#{id.publisher} #{id.type_string} #{id.formatted_number}#{id.formatted_annex}"
+        result += " #{id.formatted_edition}" if id.edition
+        result
+      end
+
+      def render_supplement(id)
+        "#{id.base_identifier} #{id.supplement_string}"
+      end
+    end
+  end
+end

data/lib/pubid/plateau/supplement_identifier.rb

@@ -20,7 +20,7 @@ module Pubid
       end
 
       def to_s
-        "#{base_identifier} #{supplement_string}"
+        render(format: :human)
       end
 
       # Override base_hash to extract edition, type, and annex from base_identifier