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

data/lib/pubid/oiml/identifier.rb

@@ -6,56 +6,6 @@ module Pubid
       def to_urn
         UrnGenerator.new(self).generate
       end
-
-      # Factory mirroring pubid 1.x's `Pubid::Oiml::Identifier.create` API.
-      # Default subclass is {Identifiers::Recommendation}.
-      TYPE_KEY_TO_KLASS = {
-        recommendation:    "Recommendation",
-        document:          "Document",
-        guide:             "Guide",
-        vocabulary:        "Vocabulary",
-        basic_publication: "BasicPublication",
-        expert_report:     "ExpertReport",
-        seminar_report:    "SeminarReport",
-        annex:             "Annex",
-      }.freeze
-
-      def self.create(type: nil, **opts)
-        klass = resolve_create_class(type)
-        klass.new(**coerce_create_attrs(opts))
-      end
-
-      def self.resolve_create_class(type)
-        return Identifiers::Recommendation if type.nil?
-
-        klass_name = TYPE_KEY_TO_KLASS[type.to_sym]
-        raise ArgumentError, "Unknown OIML type: #{type.inspect}" unless klass_name
-
-        Identifiers.const_get(klass_name)
-      end
-
-      def self.coerce_create_attrs(opts)
-        attrs = { publisher: (opts[:publisher] || "OIML").to_s }
-
-        if opts[:code].is_a?(Pubid::Oiml::Components::Code)
-          attrs[:code] = opts[:code]
-        elsif opts[:code] || opts[:number]
-          attrs[:code] = Pubid::Oiml::Components::Code.new(
-            number:  (opts[:number] || opts[:code])&.to_s,
-            part:    opts[:part]&.to_s,
-            subpart: opts[:subpart]&.to_s,
-          )
-        end
-
-        if (v = opts[:year])
-          attrs[:date] = Pubid::Components::Date.new(year: v.to_s)
-        end
-        %i[stage iteration language edition].each do |k|
-          attrs[k] = opts[k].to_s unless opts[k].nil?
-        end
-        attrs
-      end
-      private_class_method :resolve_create_class, :coerce_create_attrs
     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

@@ -5,53 +5,19 @@ module Pubid
     # 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
-
-      # Factory that builds a PLATEAU identifier from a hash of primitives.
-      #
-      # Dispatch on `:type`:
-      #   * `:handbook` (default)            → Identifiers::Handbook
-      #   * `:technical_report` / `:tr`      → Identifiers::TechnicalReport
-      #   * `:annex`                         → Identifiers::Annex
-      #
-      # Attributes are plain integers/strings — no Component wrapping.
-      # `:publisher` is silently ignored (PLATEAU is hardcoded).
-      def self.create(type: nil, **opts)
-        klass = resolve_create_class(type)
-        klass.new(**coerce_create_attrs(opts, klass: klass))
-      end
-
-      def self.resolve_create_class(type)
-        case type&.to_sym
-        when nil, :handbook
-          Identifiers::Handbook
-        when :technical_report, :tr
-          Identifiers::TechnicalReport
-        when :annex
-          Identifiers::Annex
-        else
-          raise ArgumentError, "Unknown PLATEAU type: #{type.inspect}"
-        end
-      end
-
-      def self.coerce_create_attrs(opts, klass:)
-        attrs = {}
-        attrs[:number] = opts[:number].to_i if opts[:number]
-        attrs[:annex]  = opts[:annex].to_i  if opts[:annex]
-        # :edition exists only on Handbook (and possibly TechnicalReport);
-        # silently drop on Annex.
-        if opts[:edition] && klass.attributes.key?(:edition)
-          attrs[:edition] = opts[:edition].to_s
-        end
-        # TODO(create-shim): :publisher silently ignored (PLATEAU hardcoded).
-        attrs
-      end
-      private_class_method :resolve_create_class, :coerce_create_attrs
     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

data/lib/pubid/plateau/urn_parser.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Plateau
+    # Parses Plateau URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:plateau:{type}:{number}[:{annex}]
+    #
+    # type is one of: handbook, tr (technical report), an (annex), or another
+    # lowercase type string. Annex is a zero-padded 2-digit string when present.
+    #
+    # Examples:
+    # - urn:plateau:handbook:00        → PLATEAU Handbook #00
+    # - urn:plateau:tr:01              → PLATEAU Technical Report #01
+    class UrnParser < Pubid::UrnParser::Base
+      TYPE_MAP = {
+        "handbook" => "Handbook",
+        "tr" => "Technical Report",
+        "an" => "Annex",
+      }.freeze
+
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+
+        type_token = parts.fetch(0)
+        number = parts.fetch(1)
+        annex = parts[2]
+
+        text = "PLATEAU #{display_type(type_token)} ##{number}"
+        text += "-#{annex}" if annex
+        flavor_parse(text)
+      end
+
+      private
+
+      def display_type(token)
+        TYPE_MAP.fetch(token) { token.capitalize }
+      end
+    end
+  end
+end