pubid 2.0.0.alpha.10 → 2.0.0.pre.alpha.1

data/lib/pubid/ieee/scheme.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative "typed_stages"
+
+module Pubid
+  module Ieee
+    # Scheme provides registry access for IEEE identifiers
+    # Following the proven ISO/IEC/CEN/BSI pattern
+    #
+    # This class is the single source of truth for:
+    # - TypedStage lookup by abbreviation
+    # - TypedStage lookup by IEEE draft notation
+    # - TypedStage lookup by ISO stage code
+    # - Identifier class selection based on type code
+    class Scheme < Pubid::Scheme
+      class << self
+        # Locate typed stage by abbreviation
+        # @param abbr [String, nil] stage abbreviation (e.g., "D1", "FDIS", "Std")
+        # @return [Components::TypedStage] matching typed stage
+        def locate_typed_stage_by_abbr(abbr)
+          return TypedStages::DEFAULT_TYPED_STAGE if abbr.nil? || abbr.to_s.strip.empty?
+
+          # Normalize abbreviation
+          abbr_str = abbr.to_s.strip
+
+          # Find typed stage that includes this abbreviation
+          typed_stage = TypedStages::TYPED_STAGES.find { |ts| ts.abbr.include?(abbr_str) }
+
+          # Fall back to default if not found
+          typed_stage || TypedStages::DEFAULT_TYPED_STAGE
+        end
+
+        # Locate typed stage by IEEE draft notation
+        # @param draft [String] IEEE draft notation (e.g., "D1", "D5", "P")
+        # @return [Components::TypedStage, nil] matching typed stage
+        def locate_typed_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 = TypedStages::TYPED_STAGES.find { |t| t.abbr.include?(draft_str) }
+          return ts if ts
+
+          # Try match on ieee_draft_equivalent
+          TypedStages::TYPED_STAGES.find { |t| t.ieee_draft_equivalent == draft_str }
+        end
+
+        # Locate typed stage by ISO stage code
+        # @param stage [String] ISO stage code (e.g., "WD", "CD", "DIS", "FDIS")
+        # @return [Components::TypedStage, nil] matching typed stage
+        def locate_typed_stage_by_iso_stage(stage)
+          return nil if stage.nil? || stage.to_s.strip.empty?
+
+          TypedStages::TYPED_STAGES.find { |ts| ts.iso_stage_equivalent == stage.to_s.strip }
+        end
+
+        # Locate identifier class by type code
+        # @param type_code [String, Symbol] type code (:standard, :draft, :std, :P, etc.)
+        # @return [Class] identifier class
+        def locate_identifier_klass_by_type_code(type_code)
+          type_str = type_code.to_s
+
+          case type_str
+          when "draft", "Draft Std", "Draft", "P"
+            # "P" indicates project draft status - maps to ProjectDraftIdentifier
+            Identifiers::ProjectDraftIdentifier
+          when "standard", "Std", "std"
+            Identifiers::Standard
+          else
+            # Default to base identifier
+            Identifiers::Base
+          end
+        end
+
+        # Get all typed stages
+        # @return [Array<Components::TypedStage>] all registered typed stages
+        def typed_stages
+          TypedStages::TYPED_STAGES
+        end
+
+        # Get default typed stage (published standard)
+        # @return [Components::TypedStage] default typed stage
+        def default_typed_stage
+          TypedStages::DEFAULT_TYPED_STAGE
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ieee/typed_stages.rb

@@ -101,7 +101,7 @@ module Pubid
         ),
 
         Components::TypedStage.new(
-          abbr: ["CD", "CD1", "CD2", "CD3", "CD4"],
+          abbr: ["CD", "CD2", "CD3"],
           stage_code: "committee_draft",
           type_code: "draft",
           ieee_draft_equivalent: "D2-D3",
@@ -110,17 +110,6 @@ module Pubid
           project_status: true,
         ),
 
-        # Committee Draft for Vote (IEC/ISO-led historical stage)
-        Components::TypedStage.new(
-          abbr: ["CDV"],
-          stage_code: "committee_draft_for_vote",
-          type_code: "draft",
-          ieee_draft_equivalent: "D2-D3",
-          iso_stage_equivalent: "CDV",
-          approval_status: "unapproved",
-          project_status: true,
-        ),
-
         Components::TypedStage.new(
           abbr: ["DIS"],
           stage_code: "draft_international_standard",

data/lib/pubid/ieee/urn_generator.rb

@@ -17,8 +17,7 @@ module Pubid
         cc = code_component
         parts << cc if cc
 
-        yc = year_component
-        parts << yc if yc
+        parts << identifier.year if identifier.year
 
         dc = draft_component
         parts << dc if dc
@@ -40,9 +39,11 @@ module Pubid
           parts << "int"
         end
 
-        # Conformance is always a ConformanceIdentifier wrapper (special_type
-        # "conformance"), never inline on a base standard — the base no longer
-        # carries a conf_number attribute, so there is no inline conf part.
+        if special_type != "conformance" && identifier.conf_number
+          conf = "conf.#{identifier.conf_number}"
+          conf += "-#{identifier.conf_year}" if identifier.conf_year
+          parts << conf
+        end
 
         if identifier.ashrae_number
           ashrae = "ashrae.#{identifier.ashrae_number}"
@@ -127,7 +128,8 @@ module Pubid
       end
 
       def publisher_component
-        pub = normalized_publisher
+        pub = identifier.publisher || "IEEE"
+        pub = pub.to_s.downcase
 
         if identifier.copublisher&.any?
           copubs = identifier.copublisher.map(&:to_s).map(&:downcase)
@@ -137,18 +139,6 @@ module Pubid
         pub
       end
 
-      # A dual-published document has TWO publishers, and
-      # DualPublished#publisher returns them as an Array — which `to_s`
-      # rendered into the URN as a literal Ruby array literal, brackets and
-      # quotes included: `urn:ieee:["ieee", "asme"]`. Join them the same way a
-      # copublisher list is joined above.
-      def normalized_publisher
-        names = Array(identifier.publisher)
-          .map { |p| p.to_s.downcase }.reject(&:empty?)
-
-        names.empty? ? "ieee" : names.join("-")
-      end
-
       def type_component
         return nil unless identifier.type
 
@@ -164,23 +154,6 @@ module Pubid
         identifier.code_obj.to_s
       end
 
-      # A multi-designation wrapper (AdoptedStandard, DualPublished,
-      # MultiNumberedIdentifier) carries no year of its own — the year sits on
-      # the designation it wraps — so the URN dropped it and two editions of
-      # one document produced the SAME urn: "AIEE No 15-1944" and
-      # "AIEE No 15-1959" both gave urn:ieee:aiee:15.
-      #
-      # Fixed here, in the one place that reads the year, rather than by
-      # defining a `#year` method on each wrapper: `year` is a lutaml attribute
-      # on the base and a method of that name would shadow its generated
-      # accessor. `#root` already walks to the wrapped designation.
-      def year_component
-        return identifier.year if identifier.year
-
-        root = identifier.root
-        root.equal?(identifier) ? nil : root.year
-      end
-
       def draft_component
         return nil unless identifier.draft_obj
 

data/lib/pubid/ieee.rb

@@ -2,27 +2,16 @@
 
 module Pubid
   module Ieee
-    extend Pubid::PrefixesSupport
-
-    # Publisher prefix. The private PreParser::PUBLISHERS list also holds adopted
-    # co-org names (ANSI, AIEE, ASA, ...) that are not leading routing tokens for
-    # an IEEE reference, so they are deliberately excluded. The joint ISO/IEC/IEEE
-    # form comes from Pubid::JOINT_PREFIXES.
-    PREFIXES = ["IEEE"].freeze
-
     autoload :Aiee, "#{__dir__}/ieee/aiee"
     autoload :Builder, "#{__dir__}/ieee/builder"
-    autoload :Identifier, "#{__dir__}/ieee/identifiers/base"
+    autoload :Identifier, "#{__dir__}/ieee/identifier"
     autoload :Identifiers, "#{__dir__}/ieee/identifiers"
     autoload :Ire, "#{__dir__}/ieee/ire"
     autoload :Nesc, "#{__dir__}/ieee/nesc"
     autoload :Parser, "#{__dir__}/ieee/parser"
-    autoload :PreParser, "#{__dir__}/ieee/pre_parser"
-    autoload :Compaction, "#{__dir__}/ieee/compaction"
-    autoload :Renderer, "#{__dir__}/ieee/renderer"
+    autoload :Scheme, "#{__dir__}/ieee/scheme"
     autoload :TypedStages, "#{__dir__}/ieee/typed_stages"
     autoload :UrnGenerator, "#{__dir__}/ieee/urn_generator"
-    autoload :UrnParser, "#{__dir__}/ieee/urn_parser"
 
     # Components submodule
     module Components
@@ -32,132 +21,12 @@ module Pubid
       autoload :TypedStage, "#{__dir__}/ieee/components/typed_stage"
     end
 
-    # Document-number series carrying an IEEE registered trademark ("®").
-    # 8802 is the ISO/IEC co-published form of the 802 series.
-    REGISTERED_SERIES = %w[802 8802 2030].freeze
-
-    # The ISO/IEC adoption of IEEE 802: the number alone identifies the series,
-    # whatever publishers are printed.
-    ISO_ADOPTED_SERIES = "8802"
-
     class << self
       def parse(input)
-        unless input.is_a?(String)
-          raise Pubid::Errors::InvalidInputError,
-                Pubid::INPUT_NOT_A_STRING_MESSAGE
-        end
-
-        if input.length > Pubid::MAX_INPUT_LENGTH
-          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
-        end
-
         Identifier.parse(input)
       end
-
-      # True when the document number belongs to a registered-trademark series.
-      # A project number keeps its series identity, so a leading "P" is
-      # stripped. `prefix` is the code's letter series, which must be absent
-      # (or the bare project "P") — "C802.1" is a different series that merely
-      # starts with the same digits. `publishers` guards against claiming an
-      # IEEE registered mark for another body that happens to have numbered a
-      # document 802 or 2030 — "AIEE Std No. 802" predates the IEEE 802 series
-      # by two decades. It is optional: with no publishers given the number
-      # decides, which keeps the plain number lookup usable on its own.
-      # @param number [String, nil] bare document number ("802", "P802")
-      # @param prefix [String, nil] letter series of the code ("C" for C37.09)
-      # @param publishers [Array<String>, String, nil] printed publisher tokens
-      def registered_series?(number, prefix = nil, publishers: nil)
-        return false unless prefix.nil? || prefix.to_s.empty? ||
-          prefix.to_s == "P"
-
-        bare = number.to_s.delete_prefix("P")
-        return false unless REGISTERED_SERIES.include?(bare)
-        return true if bare == ISO_ADOPTED_SERIES || publishers.nil?
-
-        Array(publishers).any? { |p| p.to_s.split("/").include?("IEEE") }
-      end
-
-      # IEEE trademark symbol for a document number: ® for the registered
-      # series, ™ for everything else. This is the entry point render sites
-      # use, because they hold the identifier and so know its number — the
-      # symbol must not depend on where in the rendered string the mark lands.
-      def trademark_symbol_for(number, prefix = nil, publishers: nil)
-        if registered_series?(number, prefix, publishers: publishers)
-          "®"
-        else
-          "™"
-        end
-      end
-
-      # IEEE trademark symbol for a rendered identifier string. Kept for
-      # external callers only — every render site inside pubid passes the
-      # document number to #trademark_symbol_for instead, because the first
-      # numeric token of a rendered string is not reliably the document number
-      # (a NESC or IRE string starts with the publication year).
-      def trademark_symbol(rendered)
-        trademark_symbol_for(rendered.to_s[/(?<![0-9A-Za-z])P?(\d+)/, 1])
-      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::Identifier.format_registry = Pubid::FormatRegistry.new(parent: Pubid::Identifier.format_registry)
-Pubid::Ieee::Identifier.format_registry.register(:human, renderer: Pubid::Ieee::Renderer)

data/lib/pubid/ieee_debug.rb

@@ -10,6 +10,7 @@ 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 = {
-          number: stringify(hash[:number]),
+          code: stringify(hash[:code]),
           appendix: stringify(hash[:appendix]),
           part: stringify(hash[:part]),
           annex: stringify(hash[:annex]),
@@ -17,7 +17,7 @@ module Pubid
           version: stringify(hash[:version]),
         }.compact
 
-        Pubid::Iho.identifier_klass_for_type_letter(type_letter).new(**attrs)
+        Scheme.identifier_klass_for_type_letter(type_letter).new(**attrs)
       end
 
       def self.build(parsed)

data/lib/pubid/iho/identifier.rb

@@ -1,7 +1,19 @@
 # frozen_string_literal: true
 
-# 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 and `.parse` live in identifiers/base.rb; this file just ensures it is loaded when a consumer
-# references Pubid::Iho::Identifier directly.
+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
+    end
+  end
+end

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

@@ -2,74 +2,40 @@
 
 module Pubid
   module Iho
-    # Base class for all IHO identifiers. Canonical name Pubid::Iho::Identifier;
-    # every concrete IHO identifier (Identifiers::*) descends from 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 [Pubid::Errors::ParseError] If parsing fails
-      def self.parse(identifier)
-        unless identifier.is_a?(String)
-          raise Pubid::Errors::InvalidInputError,
-                Pubid::INPUT_NOT_A_STRING_MESSAGE
+    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
+
+        def self.parse(string)
+          Iho::Identifier.parse(string)
         end
 
-        if identifier.length > Pubid::MAX_INPUT_LENGTH
-          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        # Render the identifier as a string in canonical IHO form.
+        # @return [String]
+        def to_s
+          letter = type.is_a?(Hash) ? type[:short].to_s : type.to_s
+          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
-
-        parsed = Parser.parse(identifier)
-        Builder.build(parsed)
       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
-
-      # 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
-
   end
 end

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

@@ -5,11 +5,15 @@ module Pubid
     module Identifiers
       # IHO Bibliographic Publication (B series).
       # Example: IHO B-4 2.19.0.
-      class Bibliographic < Identifier
+      class Bibliographic < Base
         def self.type
           { key: :bibliographic, title: "Bibliographic Publication",
             short: "B" }
         end
+
+        def type
+          self.class.type
+        end
       end
     end
   end

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

@@ -5,10 +5,14 @@ module Pubid
     module Identifiers
       # IHO Circular Letter (C series).
       # Example: IHO C-13 1.0.0.
-      class CircularLetter < Identifier
+      class CircularLetter < Base
         def self.type
           { key: :circular_letter, title: "Circular Letter", short: "C" }
         end
+
+        def type
+          self.class.type
+        end
       end
     end
   end

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

@@ -5,11 +5,15 @@ module Pubid
     module Identifiers
       # IHO Miscellaneous Publication (M series).
       # Example: IHO M-3 2.0.0.
-      class Miscellaneous < Identifier
+      class Miscellaneous < Base
         def self.type
           { key: :miscellaneous, title: "Miscellaneous Publication",
             short: "M" }
         end
+
+        def type
+          self.class.type
+        end
       end
     end
   end

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

@@ -5,10 +5,14 @@ module Pubid
     module Identifiers
       # IHO Publication (P series).
       # Examples: IHO P-1 1.0.0, IHO P-1/21 1.0.0, IHO P-6-3 1.0.0.
-      class Publication < Identifier
+      class Publication < Base
         def self.type
           { key: :publication, title: "Publication", short: "P" }
         end
+
+        def type
+          self.class.type
+        end
       end
     end
   end

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

@@ -5,10 +5,14 @@ module Pubid
     module Identifiers
       # IHO Standards and Specifications (S series).
       # Examples: IHO S-44 5.0.0, IHO S-100 Part 4a 1.0.0, IHO S-65 Ap. A 1.0.0.
-      class Standard < Identifier
+      class Standard < Base
         def self.type
           { key: :standard, title: "Standards and Specifications", short: "S" }
         end
+
+        def type
+          self.class.type
+        end
       end
     end
   end

data/lib/pubid/iho/identifiers.rb

@@ -3,6 +3,7 @@
 module Pubid
   module Iho
     module Identifiers
+      autoload :Base,           "#{__dir__}/identifiers/base"
       autoload :Bibliographic,  "#{__dir__}/identifiers/bibliographic"
       autoload :CircularLetter, "#{__dir__}/identifiers/circular_letter"
       autoload :Miscellaneous,  "#{__dir__}/identifiers/miscellaneous"

data/lib/pubid/iho/parser.rb

@@ -5,7 +5,7 @@ require "parslet"
 module Pubid
   module Iho
     # Parser class for IHO identifiers
-    class Parser < ::Pubid::Parser::Grammar
+    class Parser < Parslet::Parser
       rule(:space)  { str(" ") }
       rule(:dash)   { str("-") }
       rule(:dot)    { str(".") }
@@ -19,8 +19,8 @@ module Pubid
         (str(":") >> digits) | (str("/") >> digits) | (dash >> digits) | match("[A-Z]")
       end
 
-      rule(:number) do
-        (digits >> number_suffix.maybe).as(:number)
+      rule(:code) do
+        (digits >> number_suffix.maybe).as(:code)
       end
 
       rule(:appendix) do
@@ -54,7 +54,7 @@ module Pubid
 
       rule(:identifier) do
         (str("IHO") >> space).maybe >>
-          series >> dash >> number >>
+          series >> dash >> code >>
           appendix.maybe >> part.maybe >> annex.maybe >> supplement.maybe >> version.maybe
       end
 

data/lib/pubid/iho/scheme.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iho
+    # Scheme registry for IHO identifier types.
+    class Scheme < Pubid::Scheme
+      IDENTIFIERS = [
+        Identifiers::Standard,
+        Identifiers::Publication,
+        Identifiers::Miscellaneous,
+        Identifiers::Bibliographic,
+        Identifiers::CircularLetter,
+      ].freeze
+
+      def initialize
+        @identifiers = IDENTIFIERS
+      end
+
+      # Look up an identifier class by its IHO series letter (S/P/M/B/C).
+      # @param letter [String]
+      # @return [Class<Identifiers::Base>]
+      # @raise [KeyError] if the letter is not a known IHO series
+      def self.identifier_klass_for_type_letter(letter)
+        @by_letter ||= IDENTIFIERS.to_h { |klass| [klass.type[:short], klass] }
+        @by_letter.fetch(letter.to_s)
+      end
+    end
+  end
+end