pubid 2.0.0.pre.alpha.2 → 2.0.0.pre.alpha.4

data/lib/pubid/ieee/renderer.rb

@@ -0,0 +1,307 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    # Human-readable renderer for IEEE identifiers.
+    #
+    # Produces strings like:
+    #   "IEEE Std 802.11-2020"
+    #   "IEEE Std 535-2013/Cor. 1-2017"
+    #   "ANSI C37.61-1973 and IEEE Std 321-1973"
+    #
+    # The renderer is registered as the +:human+ format in the IEEE format
+    # registry and invoked via +render(format: :human)+.
+    #
+    # For wrapper types (DualPublished, AdoptedStandard, etc.) the renderer
+    # composes child identifiers. For simple identifiers it delegates to the
+    # identifier's own publisher/code/relationship helpers.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        id = @id
+
+        case id
+        when Identifiers::DualPublished
+          render_dual_published(id)
+        when Identifiers::DualIdentifier
+          render_dual_identifier(id)
+        when Identifiers::AdoptedStandard
+          render_adopted_standard(id)
+        when Identifiers::RedlinedStandard
+          render_redlined_standard(id)
+        when Identifiers::Corrigendum
+          render_corrigendum(id)
+        when Identifiers::InterpretationIdentifier
+          render_interpretation(id)
+        when Identifiers::ConformanceIdentifier
+          render_conformance(id)
+        when Identifiers::MultiNumberedIdentifier
+          render_multi_numbered(id)
+        when Identifiers::ParentheticalIdentifier
+          render_parenthetical(id)
+        when Identifiers::CsaDualPublished
+          render_csa_dual_published(id)
+        when Identifiers::IecIeeeCopublished
+          render_iec_ieee_copublished(id)
+        when Identifiers::SiStandard
+          render_si_standard(id)
+        when Identifiers::JointDevelopment
+          id.to_s
+        else
+          render_base(id)
+        end
+      end
+
+      private
+
+      # ------------------------------------------------------------------
+      # Base IEEE identifier rendering
+      # ------------------------------------------------------------------
+
+      def render_base(id)
+        parts = []
+
+        # Publisher(s) - handle copublisher array properly
+        if id.copublisher && !id.copublisher.empty?
+          parts << [id.publisher, *id.copublisher].join("/")
+        else
+          parts << id.publisher
+        end
+
+        # Draft status
+        parts << id.draft_status if id.draft_status
+
+        # Type - only render for IEEE/AIEE publishers, and only for non-projects
+        should_render_type = id.publisher&.match?(/^(IEEE|AIEE)/)
+
+        if should_render_type && !id.typed_stage&.project_status && id.type && !id.type.to_s.strip.empty? && id.type != "P"
+          type_str = id.type.dup
+          type_str = type_str.sub(/^P/, "") if type_str.start_with?("P")
+          parts << type_str unless type_str.strip.empty?
+        end
+
+        # Code - with P prefix for projects (concatenated, not separated)
+        if id.code_obj
+          result = id.code_obj.to_s
+
+          # Prepend P if this is a project AND code doesn't already have P
+          if id.typed_stage&.project_status && should_render_type && !result.start_with?("P")
+            result = "P#{result}"
+          end
+
+          # Only attach year to code if there's no edition, no month, and no draft
+          result += "-#{id.year}" if id.year && !id.draft_obj && !id.edition && !id.month
+
+          # Append draft to code - with or without space based on original format
+          if id.draft_obj
+            result += id.space_before_draft ? " #{id.draft_obj}" : id.draft_obj.to_s
+          end
+
+          # Append interpretation notation (/INT)
+          result += "/INT" if id.interpretation
+
+          # Append conformance notation (/ConformanceNN-YYYY)
+          if id.conf_number
+            result += "/Conformance#{id.conf_number}"
+            result += "-#{id.conf_year}" if id.conf_year
+          end
+
+          # Append ASHRAE joint publication (/ASHRAE Guideline NN-YYYY)
+          if id.ashrae_number
+            result += "/ASHRAE Guideline #{id.ashrae_number}"
+            result += "-#{id.ashrae_year}" if id.ashrae_year
+          end
+
+          # Append IEEE cross-reference (/C62.22.1-1996)
+          result += id.crossref if id.crossref
+
+          parts << result
+        elsif should_render_type && id.typed_stage&.project_status
+          # No code but is a project - add standalone P
+          parts << "P"
+        end
+
+        # Edition - with year if present (IEC style)
+        if id.edition
+          edition_str = "Edition #{id.edition}"
+          if id.year
+            edition_str += " #{id.year}"
+            edition_str += "-#{id.edition_month}" if id.edition_month
+          end
+          parts << edition_str
+        end
+
+        # Build the main identifier (without month yet)
+        result = parts.join(" ")
+
+        # Month/Day - append directly to avoid extra space before comma
+        if id.month
+          result += ", #{id.month}"
+          result += " #{id.day}" if id.day
+          if id.year && !id.edition
+            result += ", #{id.year}"
+          end
+        end
+
+        # Add parenthetical content if present
+        parentheticals = []
+
+        reaff = id.reaffirmed
+        if reaff && !reaff.to_s.strip.empty?
+          parentheticals << "(R#{reaff})"
+        end
+
+        if id.parenthetical_content
+          parentheticals << "(#{id.parenthetical_content})"
+        elsif id.relationships && !id.relationships.empty?
+          relationship_str = id.relationships.join(" / ")
+          parentheticals << "(#{relationship_str})"
+        elsif id.revision_of
+          parentheticals << "(Revision of IEEE Std #{id.revision_of})"
+        elsif id.amendment_to
+          parentheticals << "(Amendment to IEEE Std #{id.amendment_to})"
+        elsif id.adoption
+          parentheticals << "(Adoption of #{id.adoption})"
+        elsif id.note && !id.note.to_s.strip.empty?
+          parentheticals << "(#{id.note})"
+        end
+
+        result += " #{parentheticals.join(' ')}" unless parentheticals.empty?
+
+        # Book nickname - outside parentheses in square brackets
+        result += " [#{id.nickname}]" if id.nickname && !id.nickname.to_s.strip.empty?
+
+        # Redline suffix
+        result += " - Redline" if id.redline
+
+        result
+      end
+
+      # ------------------------------------------------------------------
+      # Wrapper types
+      # ------------------------------------------------------------------
+
+      def render_dual_published(id)
+        "#{id.first_identifier} and #{id.second_identifier}"
+      end
+
+      def render_dual_identifier(id)
+        "#{id.first_identifier} and #{id.second_identifier}"
+      end
+
+      def render_adopted_standard(id)
+        result = id.ieee_identifier.to_s
+        if id.adopted_identifiers && !id.adopted_identifiers.empty?
+          adopted_strs = id.adopted_identifiers.map(&:to_s)
+          result += " (#{adopted_strs.join(' and ')})"
+        end
+        result
+      end
+
+      def render_redlined_standard(id)
+        result = id.base_identifier.to_s
+        result += " (Revision of #{id.revision_of})" if id.revision_of
+        result += " - Redline" if id.redline
+        result
+      end
+
+      def render_corrigendum(id)
+        return render_base(id) unless id.base_identifier
+
+        result = id.base_identifier.to_s
+        result += "/Cor"
+        result += ". " if id.cor_number # Add period and space for formal format
+        result += id.cor_number if id.cor_number
+        result += "-#{id.cor_year}" if id.cor_year
+        result
+      end
+
+      def render_interpretation(id)
+        return render_base(id) unless id.base_identifier
+
+        result = id.base_identifier.to_s
+        result += "/INT"
+        result += "-#{id.int_year}" if id.int_year
+        result
+      end
+
+      def render_conformance(id)
+        return render_base(id) unless id.base_identifier
+
+        result = id.base_identifier.to_s
+        result += "/Conformance#{id.conf_number}" if id.conf_number
+        result += "-#{id.conf_year}" if id.conf_year
+        result
+      end
+
+      def render_multi_numbered(id)
+        return id.primary_identifier.to_s unless id.secondary_identifier
+
+        secondary_code = id.secondary_identifier.code.to_s
+        if secondary_code.start_with?("C") && secondary_code.match?(/^C\d+\./)
+          "#{id.primary_identifier}/#{id.secondary_identifier}"
+        else
+          "#{id.primary_identifier} and #{id.secondary_identifier}"
+        end
+      end
+
+      def render_parenthetical(id)
+        result = id.base_identifier.to_s
+        result += " (#{id.parenthetical_identifier})" if id.parenthetical_identifier
+        result
+      end
+
+      def render_csa_dual_published(id)
+        csa_str = id.csa_identifier.to_s
+        csa_str = "CSA #{csa_str}" unless csa_str.start_with?("CSA", "CAN/")
+
+        "#{id.ieee_identifier}/#{csa_str}"
+      end
+
+      def render_iec_ieee_copublished(id)
+        result = "IEC/IEEE"
+        result += " #{id.copublished_number}" if id.copublished_number
+        result += id.draft_info if id.draft_info
+        result += " IEC:#{id.iec_year}" if id.iec_year
+        result += " #{id.date_info}" if id.date_info
+        result
+      end
+
+      def render_si_standard(id)
+        parts = []
+
+        # Publisher (IEEE/ASTM)
+        parts << "IEEE/ASTM"
+
+        # Type (SI or PSI based on typed_stage)
+        parts << if id.typed_stage&.abbr&.include?("PSI")
+                   "PSI"
+                 else
+                   "SI"
+                 end
+
+        # Code (number) with draft version for PSI
+        code_part = id.code.to_s
+        if id.draft_obj
+          code_part += "/D#{id.draft_obj.version}"
+        end
+        parts << code_part if id.code
+
+        # Date
+        if id.month && id.year
+          parts << ", #{id.month} #{id.year}"
+        elsif id.year
+          parts << "-#{id.year}"
+        end
+
+        # Relationships (if present)
+        result = parts.join(" ")
+        if id.relationships && !id.relationships.empty?
+          rel_strs = id.relationships.map(&:to_s)
+          result += " (#{rel_strs.join(' / ')})"
+        end
+
+        result
+      end
+    end
+  end
+end

data/lib/pubid/ieee/urn_parser.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ieee
+    # Parses IEEE URNs back into identifiers.
+    #
+    # UrnGenerator emits many fields; this parser handles the common
+    # published-standard shape:
+    #   urn:ieee:{publisher}:{code}:{year}
+    #
+    # publisher is the lowercase publisher (with optional copublishers
+    # joined by `-`). code is the alphanumeric designation (period is the
+    # part separator within the code). The year separator in human-readable
+    # form is `-`.
+    #
+    # Examples:
+    # - urn:ieee:ieee:802.3:2018 → IEEE Std 802.3-2018
+    # - urn:ieee:ieee:1018:2019  → IEEE Std 1018-2019
+    class UrnParser < Pubid::UrnParser::Base
+      PUBLISHER_LABEL = "IEEE"
+
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+
+        _publisher, code, year = parts
+
+        text = "#{PUBLISHER_LABEL} Std #{code}"
+        text += "-#{year}" if year
+        flavor_parse(text)
+      end
+    end
+  end
+end

data/lib/pubid/ieee.rb

@@ -9,9 +9,11 @@ module Pubid
     autoload :Ire, "#{__dir__}/ieee/ire"
     autoload :Nesc, "#{__dir__}/ieee/nesc"
     autoload :Parser, "#{__dir__}/ieee/parser"
-    autoload :Scheme, "#{__dir__}/ieee/scheme"
+    autoload :PreParser, "#{__dir__}/ieee/pre_parser"
+    autoload :Renderer, "#{__dir__}/ieee/renderer"
     autoload :TypedStages, "#{__dir__}/ieee/typed_stages"
     autoload :UrnGenerator, "#{__dir__}/ieee/urn_generator"
+    autoload :UrnParser, "#{__dir__}/ieee/urn_parser"
 
     # Components submodule
     module Components
@@ -23,10 +25,73 @@ module Pubid
 
     class << self
       def parse(input)
+        if input.length > Pubid::MAX_INPUT_LENGTH
+          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
         Identifier.parse(input)
       end
+
+      # Auto-discover all identifier types from the Identifiers namespace
+      # @return [Array<Class>] identifier classes that define a self.type Hash
+      def 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 TypedStages module
+      # @return [Array<Pubid::Components::TypedStage>] all typed stages
+      def all_typed_stages
+        @all_typed_stages ||= TypedStages::TYPED_STAGES
+      end
+
+      # Lookup: type code -> identifier class
+      # @param code [String, Symbol] the type key to find
+      # @return [Class, nil] the matching identifier class
+      def 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 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
+
+      # Lookup: IEEE draft notation -> typed stage
+      # @param draft [String] IEEE draft notation (e.g., "D1", "D5", "P")
+      # @return [Pubid::Components::TypedStage, nil] the matching typed stage
+      def locate_stage_by_ieee_draft(draft)
+        return nil if draft.nil? || draft.to_s.strip.empty?
+
+        draft_str = draft.to_s.strip
+
+        # Try exact match on abbreviation first
+        ts = all_typed_stages.find { |t| t.abbr.include?(draft_str) }
+        return ts if ts
+
+        # Try match on ieee_draft_equivalent
+        all_typed_stages.find { |t| t.ieee_draft_equivalent == draft_str }
+      end
+
+      # Lookup: ISO stage code -> typed stage
+      # @param stage [String] ISO stage code (e.g., "WD", "CD", "DIS", "FDIS")
+      # @return [Pubid::Components::TypedStage, nil] the matching typed stage
+      def locate_stage_by_iso_stage(stage)
+        return nil if stage.nil? || stage.to_s.strip.empty?
+
+        all_typed_stages.find { |ts| ts.iso_stage_equivalent == stage.to_s.strip }
+      end
     end
   end
 end
 
 Pubid::Registry.register(:ieee, Pubid::Ieee)
+
+# Per-flavor format registry: inherits global formats, overrides :human
+Pubid::Ieee::Identifiers::Base.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
+Pubid::Ieee::Identifiers::Base.format_registry.register(:human, renderer: Pubid::Ieee::Renderer)

data/lib/pubid/ieee_debug.rb

@@ -10,7 +10,6 @@ module Pubid
     autoload :Ire, "#{__dir__}/ire"
     autoload :Nesc, "#{__dir__}/nesc"
     autoload :Parser, "#{__dir__}/parser"
-    autoload :Scheme, "#{__dir__}/scheme"
     autoload :TypedStages, "#{__dir__}/typed_stages"
     autoload :UrnGenerator, "#{__dir__}/urn_generator"
 

data/lib/pubid/iho/builder.rb

@@ -9,7 +9,7 @@ module Pubid
         type_letter = stringify(hash[:type])
 
         attrs = {
-          code: stringify(hash[:code]),
+          number: stringify(hash[:number]),
           appendix: stringify(hash[:appendix]),
           part: stringify(hash[:part]),
           annex: stringify(hash[:annex]),
@@ -17,7 +17,7 @@ module Pubid
           version: stringify(hash[:version]),
         }.compact
 
-        Scheme.identifier_klass_for_type_letter(type_letter).new(**attrs)
+        Pubid::Iho.identifier_klass_for_type_letter(type_letter).new(**attrs)
       end
 
       def self.build(parsed)

data/lib/pubid/iho/identifier.rb

@@ -1,61 +1,9 @@
 # frozen_string_literal: true
 
-module Pubid
-  module Iho
-    # Entry point for parsing IHO identifiers.
-    module Identifier
-      # Parse an IHO identifier string into an identifier object
-      # @param identifier [String] The IHO identifier string to parse
-      # @return [Pubid::Iho::Identifiers::Base] The appropriate identifier object
-      # @raise [Parslet::ParseFailed] If parsing fails
-      def self.parse(identifier)
-        parsed = Parser.parse(identifier)
-        Builder.build(parsed)
-      rescue Parslet::ParseFailed => e
-        raise "Failed to parse IHO identifier '#{identifier}': #{e.message}"
-      end
-
-      # Factory that builds an IHO identifier from a hash of primitives.
-      #
-      # IHO identifiers are simpler than ISO/IEC: attributes are plain
-      # strings (no Component wrapping), so coercion just calls #to_s.
-      #
-      # Dispatch:
-      #   * `type:` accepts the type key (`:standard`, `:publication`,
-      #     `:miscellaneous`, `:bibliographic`, `:circular_letter`) or
-      #     the IHO series letter (`"S"`, `"P"`, `"M"`, `"B"`, `"C"`).
-      #   * Default is {Identifiers::Standard}.
-      #
-      # @param type [Symbol, String, nil]
-      # @param opts [Hash] :publisher (default "IHO"), :code, :appendix,
-      #   :part, :annex, :supplement, :version
-      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::Standard if type.nil?
-
-        by_key = Scheme::IDENTIFIERS.to_h { |k| [k.type[:key], k] }
-        return by_key[type.to_sym] if by_key.key?(type.to_sym)
-
-        begin
-          Scheme.identifier_klass_for_type_letter(type.to_s.upcase)
-        rescue KeyError
-          raise ArgumentError, "Unknown IHO type: #{type.inspect}"
-        end
-      end
-
-      def self.coerce_create_attrs(opts)
-        attrs = {}
-        %i[publisher code appendix part annex supplement version].each do |k|
-          v = opts[k]
-          attrs[k] = v.to_s unless v.nil?
-        end
-        attrs
-      end
-      private_class_method :resolve_create_class, :coerce_create_attrs
-    end
-  end
-end
+# The IHO flavor base class is Pubid::Iho::Identifier — a real Pubid::Identifier
+# subclass that every concrete IHO identifier descends from, so `is_a?` identity
+# and the shared polymorphic `from_hash` work natively (no facade needed). Its
+# body, `.parse`, and the Identifiers::Base back-compat alias live in
+# identifiers/base.rb; this file just ensures it is loaded when a consumer
+# references Pubid::Iho::Identifier directly.
+require_relative "identifiers/base"

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

@@ -2,40 +2,73 @@
 
 module Pubid
   module Iho
-    module Identifiers
-      # Base class for all IHO identifiers.
-      #
-      # IHO identifiers have the form:
-      #   IHO {S|P|M|B|C}-{code}[ Ap. {appendix}][ Part {part}][ Annex {annex}][ Suppl {supplement}][ {version}]
-      #
-      # The leading IHO publisher prefix is optional on input but always
-      # emitted on output.
-      class Base < Pubid::Identifier
-        attribute :publisher,  :string, default: "IHO"
-        attribute :code,       :string
-        attribute :appendix,   :string
-        attribute :part,       :string
-        attribute :annex,      :string
-        attribute :supplement, :string
-        attribute :version,    :string
+    # Base class for all IHO identifiers. Canonical name Pubid::Iho::Identifier;
+    # every concrete IHO identifier (Identifiers::*) descends from it, and
+    # Identifiers::Base — aliased at the foot of this file — points back to it.
+    #
+    # IHO identifiers have the form:
+    #   IHO {S|P|M|B|C}-{number}[ Ap. {appendix}][ Part {part}][ Annex {annex}][ Suppl {supplement}][ {version}]
+    #
+    # The leading IHO publisher prefix is optional on input but always
+    # emitted on output.
+    class Identifier < ::Pubid::Identifier
+      # Parse an IHO identifier string into an identifier object
+      # @param identifier [String] The IHO identifier string to parse
+      # @return [Pubid::Iho::Identifier] The appropriate identifier object
+      # @raise [Parslet::ParseFailed] If parsing fails
+      def self.parse(identifier)
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      rescue Parslet::ParseFailed => e
+        raise "Failed to parse IHO identifier '#{identifier}': #{e.message}"
+      end
 
-        def self.parse(string)
-          Iho::Identifier.parse(string)
-        end
+      # `number` overrides the generic Components::Code attribute with a plain
+      # string (same pattern as `part` below); it holds the IHO document
+      # number (e.g. "100", "1/21"). Kept as the generic `number` so the
+      # relaton index sorts/binary-searches on it natively via `id.number`.
+      attribute :number,     :string
+      attribute :publisher,  :string, default: "IHO"
+      attribute :appendix,   :string
+      attribute :part,       :string
+      attribute :annex,      :string
+      attribute :supplement, :string
+      attribute :version,    :string
 
-        # Render the identifier as a string in canonical IHO form.
-        # @return [String]
-        def to_s
-          letter = self.class.type[:short]
-          rendered = "#{publisher} #{letter}-#{code}"
-          rendered << " Ap. #{appendix}" if appendix
-          rendered << " Part #{part}"    if part
-          rendered << " Annex #{annex}"  if annex
-          rendered << " Suppl #{supplement}" if supplement
-          rendered << " #{version}" if version
-          rendered
-        end
+      # Polymorphic type map for lutaml::Model key_value serialization: maps
+      # each subclass's polymorphic_name to its class name so `from_hash` can
+      # re-instantiate the concrete type from `_type`.
+      IHO_TYPE_MAP = {
+        "pubid:iho:standard" => "Pubid::Iho::Identifiers::Standard",
+        "pubid:iho:publication" => "Pubid::Iho::Identifiers::Publication",
+        "pubid:iho:miscellaneous" => "Pubid::Iho::Identifiers::Miscellaneous",
+        "pubid:iho:bibliographic" => "Pubid::Iho::Identifiers::Bibliographic",
+        "pubid:iho:circular-letter" => "Pubid::Iho::Identifiers::CircularLetter",
+      }.freeze
+
+      # The base Pubid::Identifier no longer auto-maps attributes, so each
+      # flavor's top class must declare its own key_value mapping. IHO
+      # attributes are plain strings, so they map directly. `publisher` is
+      # intentionally omitted: it is always the "IHO" default and is restored
+      # on load.
+      key_value do
+        map "_type",      to: :_type, polymorphic_map: IHO_TYPE_MAP
+        map "number",     to: :number
+        map "appendix",   to: :appendix
+        map "part",       to: :part
+        map "annex",      to: :annex
+        map "supplement", to: :supplement
+        map "version",    to: :version
       end
+
+      # from_hash is the shared polymorphic dispatch on Pubid::Identifier.
+      # IHO_TYPE_MAP remains as the key_value polymorphic_map.
+    end
+
+    module Identifiers
+      # Backward-compatible alias: IHO's base class used to be
+      # Pubid::Iho::Identifiers::Base. It is now Pubid::Iho::Identifier.
+      Base = Pubid::Iho::Identifier
     end
   end
 end

data/lib/pubid/iho/parser.rb

@@ -19,8 +19,8 @@ module Pubid
         (str(":") >> digits) | (str("/") >> digits) | (dash >> digits) | match("[A-Z]")
       end
 
-      rule(:code) do
-        (digits >> number_suffix.maybe).as(:code)
+      rule(:number) do
+        (digits >> number_suffix.maybe).as(:number)
       end
 
       rule(:appendix) do
@@ -54,7 +54,7 @@ module Pubid
 
       rule(:identifier) do
         (str("IHO") >> space).maybe >>
-          series >> dash >> code >>
+          series >> dash >> number >>
           appendix.maybe >> part.maybe >> annex.maybe >> supplement.maybe >> version.maybe
       end
 

data/lib/pubid/iho/renderer.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iho
+    # Human-readable renderer for IHO identifiers.
+    #
+    # Produces strings like:
+    #   "IHO S-44 5.0.0"
+    #   "IHO P-1/21 1.0.0"
+    #   "IHO S-100 Part 4a 1.0.0"
+    #   "IHO S-65 Ap. A 1.0.0"
+    #
+    # The renderer is registered as the `:human` format in the IHO format
+    # registry and invoked via `render(format: :human)`.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **opts)
+        id = @id
+
+        letter = id.class.type[:short]
+        rendered = "#{id.publisher} #{letter}-#{id.number}"
+        rendered << " Ap. #{id.appendix}" if id.appendix
+        rendered << " Part #{id.part}" if id.part
+        rendered << " Annex #{id.annex}" if id.annex
+        rendered << " Suppl #{id.supplement}" if id.supplement
+        rendered << " #{id.version}" if id.version
+        rendered
+      end
+    end
+  end
+end