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

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

data/lib/pubid/plateau.rb

@@ -5,11 +5,13 @@ require "parslet"
 module Pubid
   module Plateau
     autoload :Builder, "#{__dir__}/plateau/builder"
+    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
@@ -18,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/base.rb

@@ -14,6 +14,40 @@ module Pubid
       def self.render(identifier)
         new(identifier).render
       end
+
+      # Partitions a value into (leading separators, core, trailing separators)
+      # so "- : / space , ." stay OUTSIDE the annotation span (v1 parity).
+      SEMANTIC_SPLIT = %r{\A([-:/ ,.]*)(.*?)([-:/ ,.]*)\z}m
+
+      # type_code (a string) → semantic CSS class for the typed-stage token.
+      # Anything not listed (and not the default "is") renders as "doctype".
+      TYPED_STAGE_CSS = {
+        "amd" => "amendment",
+        "cor" => "corrigendum",
+        "add" => "addendum",
+      }.freeze
+
+      private
+
+      # Wrap a rendered value in a <span class="css_class"> when annotation is
+      # enabled, keeping leading/trailing separator chars outside the span.
+      def annotate(value, css_class, annotated:)
+        str = value.to_s
+        return value unless annotated && css_class && !str.empty?
+
+        lead, core, trail = str.match(SEMANTIC_SPLIT).captures
+        return value if core.empty?
+
+        %(#{lead}<span class="#{css_class}">#{core}</span>#{trail})
+      end
+
+      # Choose between "stage" and a type/supplement class for a typed stage.
+      def typed_stage_css(typed_stage)
+        code = typed_stage&.type_code.to_s
+        return "stage" if code.empty? || code == "is"
+
+        TYPED_STAGE_CSS[code] || "doctype"
+      end
     end
   end
 end

data/lib/pubid/renderers/directives_renderer.rb

@@ -27,17 +27,17 @@ module Pubid
       private
 
       def render_publisher_portion(context)
-        pub_str = @id.publisher.render(context:) if @id.publisher
+        ann = context.annotated
+        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) : ""
-        subgroup_str = @id.subgroup.render(context:) if @id.subgroup
-
-        unless @id.publisher&.copublished?
-          return [
-            pub_str,
-            (subgroup_str ? " #{subgroup_str}" : ""),
-            (abbr.empty? ? "" : " #{abbr}"),
-          ].join
+        unless abbr.empty?
+          abbr = annotate(abbr, typed_stage_css(@id.typed_stage), 
+                          annotated: ann)
         end
+        subgroup_str = @id.subgroup.render(context:) if @id.subgroup
 
         [
           pub_str,
@@ -47,13 +47,26 @@ module Pubid
       end
 
       def render_number_portion(context)
+        ann = context.annotated
         parts = []
-        parts << @id.number.render(context:) if @id.number
-        parts << " #{@id.part.render(context:)}" if @id.part
-        parts << "-#{@id.subpart.render(context:)}" if @id.subpart
-        parts << ".#{@id.stage_iteration.render(context:)}" if @id.stage_iteration
+        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)}"
+        end
         date_str = @id.date.render(context:) if @id.date && context.with_date
-        parts << ":#{date_str}" if date_str
+        parts << ":#{annotate(date_str, 'year', annotated: ann)}" if date_str
         result = parts.join.strip
         result.empty? ? nil : result
       end

data/lib/pubid/renderers/guide_renderer.rb

@@ -6,10 +6,16 @@ module Pubid
       private
 
       def render_publisher_and_stage(context)
-        pub_str = @id.publisher.render(context:) if @id.publisher
+        ann = context.annotated
+        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?
+          stage_str = annotate(stage_str, typed_stage_css(@id.typed_stage),
+                               annotated: ann)
           "#{pub_str} #{stage_str}"
         else
           pub_str

data/lib/pubid/renderers/human_readable.rb

@@ -17,12 +17,18 @@ module Pubid
       private
 
       def render_publisher_and_stage(context)
-        pub_str = @id.publisher.render(context:) if @id.publisher
+        ann = context.annotated
+        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?
           has_copub = @id.publisher&.copublished?
           sep = has_copub ? " " : "/"
+          stage_str = annotate(stage_str, typed_stage_css(@id.typed_stage),
+                               annotated: ann)
           "#{pub_str}#{sep}#{stage_str}"
         else
           pub_str
@@ -30,18 +36,34 @@ module Pubid
       end
 
       def render_number_portion(context)
+        ann = context.annotated
         parts = []
-        parts << @id.number.render(context:) if @id.number
-        parts << "-#{@id.part.render(context:)}" if @id.part
-        parts << "-#{@id.subpart.render(context:)}" if @id.subpart
-        parts << ".#{@id.stage_iteration.render(context:)}" if @id.stage_iteration
+        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)}"
+        end
         date_str = @id.date.render(context:) if @id.date && context.with_date
-        parts << ":#{date_str}" if date_str
+        parts << ":#{annotate(date_str, 'year', annotated: ann)}" if date_str
         parts.join
       end
 
       def render_edition_portion(context)
-        @id.edition.render(context:) if @id.edition&.number
+        return unless @id.edition&.number
+
+        annotate(@id.edition.render(context:), "edition",
+                 annotated: context.annotated)
       end
 
       def render_language_portion(context, with_edition: false)
@@ -49,7 +71,8 @@ module Pubid
 
         use_single = with_edition ? false : context.with_language_code == :single
         rendered = @id.languages.map do |l|
-          l.render(context:, lang_single: use_single)
+          annotate(l.render(context:, lang_single: use_single), "language",
+                   annotated: context.annotated)
         end
         "(#{rendered.join(use_single ? '/' : ',')})"
       end

data/lib/pubid/renderers/iwa_renderer.rb

@@ -5,7 +5,11 @@ module Pubid
     class IwaRenderer < HumanReadable
       def render(context:, with_edition: false)
         parts = []
-        parts << @id.typed_stage.render(context:) if @id.typed_stage
+        if @id.typed_stage
+          parts << annotate(@id.typed_stage.render(context:),
+                            typed_stage_css(@id.typed_stage),
+                            annotated: context.annotated)
+        end
         parts << render_number_portion(context)
         result = parts.compact.join(" ")
         result << render_language_portion(context, with_edition: with_edition)

data/lib/pubid/renderers/supplement_renderer.rb

@@ -10,9 +10,12 @@ module Pubid
           with_edition: with_edition,
           stage_format_long: context.stage_format_long,
           with_date: context.with_date,
+          annotated: context.annotated,
         )
 
-        stage_str = @id.typed_stage.render(context:)
+        stage_str = annotate(@id.typed_stage.render(context:),
+                             typed_stage_css(@id.typed_stage),
+                             annotated: context.annotated)
         parts << "#{base_str}/#{stage_str}"
 
         num_port = render_number_portion(context)

data/lib/pubid/rendering/context.rb

@@ -2,30 +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
+                  :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)
@@ -33,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: " ",
@@ -42,7 +33,9 @@ module Pubid
                      lang_single: false,
                      with_language_code: :none,
                      stage_format_long: false,
-                     with_date: true)
+                     with_date: true,
+                     annotated: false)
+        @format = format
         @stage_separator = stage_separator
         @stage_separator_with_copublisher = stage_separator_with_copublisher
         @type_separator = type_separator
@@ -53,6 +46,19 @@ module Pubid
         @with_language_code = with_language_code
         @stage_format_long = stage_format_long
         @with_date = with_date
+        @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
@@ -115,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/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)