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

data/lib/pubid/plateau.rb

@@ -8,9 +8,10 @@ module Pubid
     autoload :Identifier, "#{__dir__}/plateau/identifier"
     autoload :Identifiers, "#{__dir__}/plateau/identifiers"
     autoload :Parser, "#{__dir__}/plateau/parser"
-    autoload :Scheme, "#{__dir__}/plateau/scheme"
+    autoload :Renderer, "#{__dir__}/plateau/renderer"
     autoload :SupplementIdentifier, "#{__dir__}/plateau/supplement_identifier"
     autoload :UrnGenerator, "#{__dir__}/plateau/urn_generator"
+    autoload :UrnParser, "#{__dir__}/plateau/urn_parser"
 
     def self.parse(input)
       # Apply legacy update_codes normalization first
@@ -19,6 +20,47 @@ module Pubid
       parsed = parser.parse(normalized)
       Builder.build(parsed)
     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: Plateau::Renderer)
+    SupplementIdentifier.format_registry = Identifiers::Base.format_registry
+
+    # 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/renderers/directives_renderer.rb

@@ -28,10 +28,15 @@ module Pubid
 
       def render_publisher_portion(context)
         ann = context.annotated
-        pub_str = annotate(@id.publisher.render(context:), "publisher",
-                           annotated: ann) if @id.publisher
+        if @id.publisher
+          pub_str = annotate(@id.publisher.render(context:), "publisher",
+                             annotated: ann)
+        end
         abbr = @id.typed_stage ? @id.typed_stage.abbreviation(format_long: false) : ""
-        abbr = annotate(abbr, typed_stage_css(@id.typed_stage), annotated: ann) unless abbr.empty?
+        unless abbr.empty?
+          abbr = annotate(abbr, typed_stage_css(@id.typed_stage), 
+                          annotated: ann)
+        end
         subgroup_str = @id.subgroup.render(context:) if @id.subgroup
 
         [
@@ -44,12 +49,21 @@ module Pubid
       def render_number_portion(context)
         ann = context.annotated
         parts = []
-        parts << annotate(@id.number.render(context:), "docnumber",
-                          annotated: ann) if @id.number
-        parts << " #{annotate(@id.part.render(context:), 'part', annotated: ann)}" if @id.part
-        parts << "-#{annotate(@id.subpart.render(context:), 'part', annotated: ann)}" if @id.subpart
+        if @id.number
+          parts << annotate(@id.number.render(context:), "docnumber",
+                            annotated: ann)
+        end
+        if @id.part
+          parts << " #{annotate(@id.part.render(context:), 'part', 
+                                annotated: ann)}"
+        end
+        if @id.subpart
+          parts << "-#{annotate(@id.subpart.render(context:), 'part', 
+                                annotated: ann)}"
+        end
         if @id.stage_iteration
-          parts << ".#{annotate(@id.stage_iteration.render(context:), 'iteration', annotated: ann)}"
+          parts << ".#{annotate(@id.stage_iteration.render(context:), 
+                                'iteration', annotated: ann)}"
         end
         date_str = @id.date.render(context:) if @id.date && context.with_date
         parts << ":#{annotate(date_str, 'year', annotated: ann)}" if date_str

data/lib/pubid/renderers/guide_renderer.rb

@@ -7,8 +7,10 @@ module Pubid
 
       def render_publisher_and_stage(context)
         ann = context.annotated
-        pub_str = annotate(@id.publisher.render(context:), "publisher",
-                           annotated: ann) if @id.publisher
+        if @id.publisher
+          pub_str = annotate(@id.publisher.render(context:), "publisher",
+                             annotated: ann)
+        end
         stage_str = @id.typed_stage.render(context:) if @id.typed_stage
 
         if stage_str && !stage_str.empty?

data/lib/pubid/renderers/human_readable.rb

@@ -18,8 +18,10 @@ module Pubid
 
       def render_publisher_and_stage(context)
         ann = context.annotated
-        pub_str = annotate(@id.publisher.render(context:), "publisher",
-                           annotated: ann) if @id.publisher
+        if @id.publisher
+          pub_str = annotate(@id.publisher.render(context:), "publisher",
+                             annotated: ann)
+        end
         stage_str = @id.typed_stage.render(context:) if @id.typed_stage
 
         if stage_str && !stage_str.empty?
@@ -36,12 +38,21 @@ module Pubid
       def render_number_portion(context)
         ann = context.annotated
         parts = []
-        parts << annotate(@id.number.render(context:), "docnumber",
-                          annotated: ann) if @id.number
-        parts << "-#{annotate(@id.part.render(context:), 'part', annotated: ann)}" if @id.part
-        parts << "-#{annotate(@id.subpart.render(context:), 'part', annotated: ann)}" if @id.subpart
+        if @id.number
+          parts << annotate(@id.number.render(context:), "docnumber",
+                            annotated: ann)
+        end
+        if @id.part
+          parts << "-#{annotate(@id.part.render(context:), 'part', 
+                                annotated: ann)}"
+        end
+        if @id.subpart
+          parts << "-#{annotate(@id.subpart.render(context:), 'part', 
+                                annotated: ann)}"
+        end
         if @id.stage_iteration
-          parts << ".#{annotate(@id.stage_iteration.render(context:), 'iteration', annotated: ann)}"
+          parts << ".#{annotate(@id.stage_iteration.render(context:), 
+                                'iteration', annotated: ann)}"
         end
         date_str = @id.date.render(context:) if @id.date && context.with_date
         parts << ":#{annotate(date_str, 'year', annotated: ann)}" if date_str

data/lib/pubid/rendering/context.rb

@@ -2,31 +2,20 @@
 
 module Pubid
   module Rendering
-    # Context object for flavor-specific rendering rules
-    #
-    # This encapsulates the rendering rules that vary between flavors,
-    # allowing components to render themselves correctly based on context.
-    #
-    # == Usage
-    #
-    #   context = RenderingContext.new(
-    #     stage_separator: "/",
-    #     stage_separator_with_copublisher: " ",
-    #     type_separator: "/",
-    #     type_separator_with_prefix: " ",
-    #     default_type_abbr: "IS"
-    #   )
-    #   identifier.to_s(context: context)
+    # Context object for flavor-specific and format-specific rendering rules
     #
+    # Encapsulates rendering rules that vary between flavors and between
+    # output formats (human-readable, URN, MR string). Components receive
+    # this context and render themselves accordingly — renderers and
+    # URN generators never reach into component internals.
     class RenderingContext
-      attr_reader :stage_separator, :stage_separator_with_copublisher,
+      attr_reader :format, :stage_separator, :stage_separator_with_copublisher,
                   :type_separator, :type_separator_with_prefix,
                   :default_type_abbr, :lang, :lang_single,
                   :with_language_code, :stage_format_long, :with_date,
                   :annotated
 
-      # Initialize a new rendering context
-      #
+      # @param format [Symbol] output format: :human, :urn, or :mr
       # @param stage_separator [String] separator before stage without copublisher
       # @param stage_separator_with_copublisher [String] separator before stage with copublisher
       # @param type_separator [String] separator before type (default)
@@ -34,7 +23,8 @@ module Pubid
       # @param default_type_abbr [String] default type abbreviation to skip rendering
       # @param lang [Symbol] language for rendering (:en or :fr)
       # @param lang_single [Boolean] use single char language format
-      def initialize(stage_separator: "/",
+      def initialize(format: :human,
+                     stage_separator: "/",
                      stage_separator_with_copublisher: " ",
                      type_separator: "/",
                      type_separator_with_prefix: " ",
@@ -45,6 +35,7 @@ module Pubid
                      stage_format_long: false,
                      with_date: true,
                      annotated: false)
+        @format = format
         @stage_separator = stage_separator
         @stage_separator_with_copublisher = stage_separator_with_copublisher
         @type_separator = type_separator
@@ -58,6 +49,18 @@ module Pubid
         @annotated = annotated
       end
 
+      def urn?
+        @format == :urn
+      end
+
+      def human?
+        @format == :human
+      end
+
+      def mr?
+        @format == :mr
+      end
+
       # Get the appropriate stage separator based on whether there's a copublisher
       #
       # @param has_copublisher [Boolean] whether identifier has copublisher
@@ -118,6 +121,12 @@ module Pubid
         )
       end
 
+      # URN rendering context: components emit URN-format fragments
+      # @return [RenderingContext] URN-specific context
+      def self.urn
+        @urn ||= new(format: :urn)
+      end
+
       # Format factory methods — replace RenderingStyle hierarchy
       def self.ref_num_short
         new(with_language_code: :single, stage_format_long: false,

data/lib/pubid/rendering.rb

@@ -2,10 +2,7 @@
 
 module Pubid
   module Rendering
-    autoload :Base, "pubid/rendering/base"
-    autoload :Common, "pubid/rendering/common"
     autoload :Date, "pubid/rendering/date"
-    autoload :Format, "pubid/rendering/format"
     autoload :Language, "pubid/rendering/language"
     autoload :Numbering, "pubid/rendering/numbering"
     autoload :Publisher, "pubid/rendering/publisher"

data/lib/pubid/sae/components/date.rb

@@ -10,7 +10,15 @@ module Pubid
       class Date < Lutaml::Model::Serializable
         attribute :year, :integer
 
+        def present?
+          !year.nil?
+        end
+
         def to_s
+          render
+        end
+
+        def render(context: nil)
           year.to_s
         end
       end

data/lib/pubid/sae/components/type.rb

@@ -6,11 +6,15 @@ module Pubid
   module Sae
     module Components
       # Type component for SAE document types
-      # AMS, AIR,, ARP, AS, MA
+      # AMS, AIR, ARP, AS, MA
       class Type < Lutaml::Model::Serializable
         attribute :abbr, :string
 
         def to_s
+          render
+        end
+
+        def render(context: nil)
           abbr.to_s
         end
       end

data/lib/pubid/sae/identifier.rb

@@ -9,29 +9,6 @@ module Pubid
       rescue Parslet::ParseFailed => e
         raise "Failed to parse SAE identifier: #{input}\n#{e.message}"
       end
-
-      # Factory that builds a SAE identifier from a hash of primitives.
-      # SAE has only one identifier class ({Identifiers::Base}); `:type`
-      # is data (the document-type abbreviation: "J", "AS", "ARP", "AMS",
-      # "AIR", "MA") rather than a class-dispatch key.
-      def self.create(**opts)
-        Identifiers::Base.new(**coerce_create_attrs(opts))
-      end
-
-      def self.coerce_create_attrs(opts)
-        attrs = { publisher: (opts[:publisher] || "SAE").to_s }
-        if (v = opts[:type])
-          attrs[:type] = Pubid::Sae::Components::Type.new(abbr: v.to_s)
-        end
-        if (v = opts[:number])
-          attrs[:number] = Pubid::Components::Code.new(value: v.to_s)
-        end
-        if (v = opts[:year])
-          attrs[:date] = Pubid::Components::Date.new(year: v.to_s)
-        end
-        attrs
-      end
-      private_class_method :coerce_create_attrs
     end
   end
 end

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

@@ -15,22 +15,8 @@ module Pubid
         attribute :number, Sae::Components::Code
         attribute :date, Sae::Components::Date
 
-        def to_s
-          parts = []
-
-          # Publisher and type
-          parts << publisher if publisher
-          parts << type.to_s if type
-
-          # Number
-          parts << number.to_s if number
-
-          result = parts.join(" ")
-
-          # Date
-          result += ":#{date.year}" if date
-
-          result
+        def self.type
+          { key: :base, web: :standard, title: "Standard", short: "SAE" }
         end
 
         def year

data/lib/pubid/sae/renderer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Sae
+    # Human-readable renderer for SAE identifiers.
+    #
+    # Produces strings like:
+    #   "SAE AS5553"
+    #   "SAE ARP4754A"
+    #   "SAE AMS2475:2023"
+    #
+    # The renderer is registered as the +:human+ format in the SAE format
+    # registry and invoked via +render(format: :human)+.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **_opts)
+        id = @id
+
+        parts = []
+
+        # Publisher and type
+        parts << id.publisher if id.publisher
+        parts << id.type.to_s if id.type
+
+        # Number
+        parts << id.number.to_s if id.number
+
+        result = parts.join(" ")
+
+        # Date
+        result += ":#{id.date.render(context:)}" if id.date
+
+        result
+      end
+    end
+  end
+end

data/lib/pubid/sae/urn_generator.rb

@@ -9,18 +9,10 @@ module Pubid
         identifier.type.abbr.to_s.downcase
       end
 
-      def urn_year
-        if identifier.date&.year
-          return identifier.date.year.to_s
-        end
-
-        identifier.year&.to_s
-      end
-
       def urn_number
         return nil unless identifier.number
 
-        identifier.number.value.to_s
+        identifier.number.render(context: URN_CONTEXT)
       end
 
       def generate
@@ -29,7 +21,7 @@ module Pubid
         parts << urn_number if urn_number
         parts << urn_year if urn_year
 
-        parts[1] = identifier.publisher.to_s.downcase if identifier.publisher
+        parts[1] = urn_publisher if urn_publisher
 
         parts.join(":")
       end

data/lib/pubid/sae/urn_parser.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Sae
+    # Parses SAE URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:sae:{type|std}:{number}:{year}
+    # where slot[1] is overwritten with the publisher string when a publisher
+    # is set. The common single-publisher case keeps slot[1] = "sae".
+    #
+    # Examples:
+    # - urn:sae:j:300:2019     → SAE J300:2019
+    # - urn:sae:air:500        → SAE AIR500
+    # - urn:sae:ams:5000:2020  → SAE AMS5000:2020
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+
+        type_token, number, year = parts
+        text = build_text(type_token, number, year)
+        flavor_parse(text)
+      end
+
+      private
+
+      def build_text(type_token, number, year)
+        head = type_token == "std" ? "" : type_token.upcase
+        text = "SAE #{head}#{number}"
+        text += ":#{year}" if year
+        text
+      end
+    end
+  end
+end

data/lib/pubid/sae.rb

@@ -7,13 +7,54 @@ module Pubid
     autoload :Identifier, "#{__dir__}/sae/identifier"
     autoload :Identifiers, "#{__dir__}/sae/identifiers"
     autoload :Parser, "#{__dir__}/sae/parser"
-    autoload :Scheme, "#{__dir__}/sae/scheme"
+    autoload :Renderer, "#{__dir__}/sae/renderer"
     autoload :UrnGenerator, "#{__dir__}/sae/urn_generator"
+    autoload :UrnParser, "#{__dir__}/sae/urn_parser"
 
     def self.parse(input)
       Identifier.parse(input)
     end
+
+    # Auto-discover all identifier types from the Identifiers namespace.
+    # SAE has only one identifier class (Base), which IS the document type.
+    # @return [Array<Class>] identifier classes (Pubid::Identifier subclasses)
+    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 < Pubid::Identifier }
+    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
 
 Pubid::Registry.register(:sae, Pubid::Sae)
+
+# Per-flavor format registry: inherits global formats, overrides :human
+Pubid::Sae::Identifiers::Base.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
+Pubid::Sae::Identifiers::Base.format_registry.register(:human, renderer: Pubid::Sae::Renderer)

data/lib/pubid/urn_generator/base.rb

@@ -6,6 +6,9 @@ module Pubid
     # Provides template methods for common URN parts.
     # Flavors subclass and override only what differs.
     class Base
+      URN_CONTEXT = Rendering::RenderingContext.urn.freeze
+      private_constant :URN_CONTEXT
+
       attr_reader :identifier
 
       def initialize(identifier)
@@ -35,7 +38,7 @@ module Pubid
         pub = maybe(:publisher)
         return nil unless pub
 
-        pub.to_s.downcase
+        pub.is_a?(Components::Publisher) ? pub.render(context: URN_CONTEXT) : pub.to_s.downcase
       end
 
       def urn_type
@@ -46,34 +49,31 @@ module Pubid
         val = maybe(:number) || maybe(:code)
         return nil unless val
 
-        val.is_a?(Components::Code) ? val.value.to_s : val.to_s
+        val.is_a?(Components::Code) ? val.render(context: URN_CONTEXT) : val.to_s
       end
 
       def urn_part
         val = maybe(:part)
         return nil unless val
 
-        "-#{val.is_a?(Components::Code) ? val.value : val}"
+        "-#{val.is_a?(Components::Code) ? val.render(context: URN_CONTEXT) : val}"
       end
 
       def urn_subpart
         val = maybe(:subpart)
         return nil unless val
 
-        "-#{val.is_a?(Components::Code) ? val.value : val}"
+        "-#{val.is_a?(Components::Code) ? val.render(context: URN_CONTEXT) : val}"
       end
 
       def urn_year
         date = maybe(:date)
-        if date
-          year = date.is_a?(Components::Date) ? date.year : date.to_s
-          return year.to_s if year
-        end
-        if maybe(:year)
-          return identifier.year.to_s
+        if date.is_a?(Components::Date)
+          return date.render(context: URN_CONTEXT) if date.present?
+        elsif date
+          return date.to_s
         end
-
-        nil
+        maybe(:year)&.to_s
       end
 
       def urn_edition

data/lib/pubid/urn_parser/base.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Pubid
+  module UrnParser
+    # Base class for flavor-specific URN parsers.
+    #
+    # A UrnParser inverts its sibling UrnGenerator: it consumes the URN
+    # emitted by {Pubid::{Flavor}::UrnGenerator} and rebuilds an Identifier.
+    # The preferred strategy is to reconstruct a human-readable identifier
+    # string from the URN fields and delegate to the flavor's text parser —
+    # this keeps parsing logic in one place (the flavor's text parser).
+    #
+    # Subclasses MUST override {#parse_urn}. They typically use
+    # {#strip_namespace} and {#flavor_parse} helpers and may pass through
+    # {#build_from_parts} for the common `urn:{flavor}:{publisher}:{type}:
+    # {number}:{year}` shape.
+    class Base
+      # Parse a URN string into an Identifier.
+      # @param urn [String]
+      # @return [Pubid::Identifier]
+      def self.parse(urn)
+        new.parse_urn(urn)
+      end
+
+      # Subclasses override.
+      # @raise [NotImplementedError]
+      def parse_urn(_urn)
+        raise NotImplementedError,
+              "#{self.class} must implement #parse_urn"
+      end
+
+      protected
+
+      # The flavor module this parser belongs to (e.g., Pubid::Sae).
+      # Derived from the class name: Pubid::Sae::UrnParser → Pubid::Sae.
+      def flavor_module
+        @flavor_module ||=
+          begin
+            path = self.class.name.to_s.split("::")
+            Object.const_get(path[0..-2].join("::"))
+          end
+      end
+
+      # The lowercase flavor name used as the URN namespace (e.g., "sae").
+      # Defaults to the last segment of the module name. Override in
+      # subclasses whose URN namespace differs from the module name
+      # (e.g., CenCenelec emits URNs under "urn:cen:").
+      def flavor_name
+        @flavor_name ||= flavor_module.name.split("::").last.downcase
+      end
+
+      # Validate the URN starts with `urn:{flavor}:` and return the body.
+      # @param urn [String]
+      # @return [String] body after `urn:{flavor}:`
+      # @raise [Errors::ParseError] if prefix is wrong
+      def strip_namespace(urn)
+        prefix = "urn:#{flavor_name}:"
+        unless urn.downcase.start_with?(prefix)
+          raise Errors::ParseError,
+                "Invalid #{flavor_name.upcase} URN: #{urn.inspect}"
+        end
+
+        urn[prefix.length..]
+      end
+
+      # Delegate to the flavor's text parser.
+      # @param code [String] human-readable identifier
+      # @return [Pubid::Identifier]
+      def flavor_parse(code)
+        flavor_module.parse(code)
+      end
+
+      # Split the URN body on ":" into parts.
+      # @param body [String]
+      # @return [Array<String>]
+      def split_parts(body)
+        body.split(":")
+      end
+    end
+  end
+end

data/lib/pubid/urn_parser/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pubid
+  module UrnParser
+    module Errors
+      class ParseError < StandardError; end
+    end
+  end
+end