pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/ietf/identifiers/internet_draft.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ietf
+    module Identifiers
+      # An Internet-Draft, e.g. "draft-giuliano-treedn-02" (versioned) or
+      # "draft-giuliano-treedn" (the unversioned "latest" sibling). The full
+      # slug (including the leading "draft-") is stored in `number` — it is the
+      # relaton-index narrowing key, shared by a draft's unversioned aggregator
+      # row and all of its versions; the optional trailing two-digit version is
+      # in `version`.
+      class InternetDraft < Identifier
+        include Serialization
+
+        # Two-digit version string, zero-pad preserved ("02"); nil for the
+        # unversioned "latest" sibling, in which case the canonical to_hash
+        # drops the key entirely.
+        attribute :version, :string
+
+        # Merged with the block Serialization installs (lutaml combines a
+        # mixin-installed key_value with a second in-class one), so the
+        # serialized shape is {_type, number} plus `version` when set.
+        key_value do
+          map "version", to: :version
+        end
+
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :internet_draft,
+            stage_code: :draft,
+            type_code: :internet_draft,
+            abbr: ["I-D", "Internet-Draft"],
+            name: "Internet-Draft",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :internet_draft, web: :internet_draft,
+            title: "Internet-Draft", short: "I-D" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ietf/identifiers/rfc.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ietf
+    module Identifiers
+      # An RFC (Request for Comments), e.g. "RFC 2119".
+      class Rfc < Identifier
+        include Serialization
+
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :rfc,
+            stage_code: :published,
+            type_code: :rfc,
+            abbr: ["RFC"],
+            name: "Request for Comments",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :rfc, web: :rfc, title: "Request for Comments", short: "RFC" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ietf/identifiers/serialization.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ietf
+    module Identifiers
+      # Installs the flat, index-friendly attribute set and the shared
+      # `key_value` block on the five concrete IETF leaves (Rfc, Bcp, Std, Fyi,
+      # InternetDraft).
+      #
+      # Why the leaves and not the shared Pubid::Ietf::Identifier base:
+      # `number` redefines the parent ::Pubid::Identifier's
+      # `attribute :number, Components::Code` as a plain :string. Declaring that
+      # on a class the concrete types INHERIT from resolves against the parent
+      # definition nondeterministically under multi-flavor load — it passes an
+      # IETF-only run and can flip `root.number` to "" under the full suite (the
+      # IEEE lesson; see lib/pubid/ieee/identifiers/code_number.rb and
+      # CLAUDE.md). Declaring `number` directly on each leaf removes the
+      # ambiguity at the point of use.
+      #
+      # This matters because relaton-index bsearches on `id.root.number.to_s`,
+      # and every IETF identifier is its own root (the flavor has no wrapper or
+      # supplement types), so an empty key silently defeats the search for every
+      # row. spec/pubid/ietf/root_number_spec.rb guards it and must run under
+      # the FULL suite to be meaningful.
+      #
+      # `series` is deliberately NOT an attribute here: `_type` already encodes
+      # it, so storing it would duplicate the type in every sub-series row. The
+      # three sub-series leaves expose it as a derived reader instead.
+      module Serialization
+        def self.included(base)
+          # Document number of an RFC or sub-series id ("2119", "66"), kept as
+          # a string so the printed form carries no zero-pad; for an
+          # Internet-Draft, the version-less slug INCLUDING the leading
+          # "draft-" ("draft-ietf-quic-transport"). The slug is the right index
+          # key for the same reason the number is for an RFC: a draft's
+          # unversioned aggregator row and every one of its versions share it,
+          # so a document and its variants cluster into one bucket.
+          base.attribute :number, :string
+
+          # Only these keys serialize; the inherited Pubid::Identifier
+          # attributes are intentionally dropped. InternetDraft merges its own
+          # `version` mapping on top of this block.
+          base.key_value do
+            map "_type", to: :_type, polymorphic_map: Identifier::IETF_TYPE_MAP
+            map "number", to: :number
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ietf/identifiers/std.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ietf
+    module Identifiers
+      # An STD (Internet Standard) sub-series id, e.g. "STD 66".
+      class Std < Identifier
+        include Serialization
+
+        # The series token is derived from the class, not stored:
+        # `_type` already encodes it, so serializing `series` would
+        # duplicate the type in every index row.
+        SERIES = "STD"
+
+        def series
+          SERIES
+        end
+
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :std,
+            stage_code: :published,
+            type_code: :std,
+            abbr: ["STD"],
+            name: "Internet Standard",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :std, web: :std, title: "Internet Standard", short: "STD" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ietf/identifiers.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ietf
+    module Identifiers
+      autoload :Serialization, "#{__dir__}/identifiers/serialization"
+      autoload :Rfc, "#{__dir__}/identifiers/rfc"
+      autoload :Bcp, "#{__dir__}/identifiers/bcp"
+      autoload :Std, "#{__dir__}/identifiers/std"
+      autoload :Fyi, "#{__dir__}/identifiers/fyi"
+      autoload :InternetDraft, "#{__dir__}/identifiers/internet_draft"
+    end
+  end
+end

data/lib/pubid/ietf/parser.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Ietf
+    # Parslet grammar for the three IETF families. The top-level alternation is
+    # keyed by leading token, and each alternative captures the raw fields the
+    # Builder needs:
+    #   * RFC        -> { number: }
+    #   * sub-series -> { series:, number: }
+    #   * draft      -> { draft_rest: }  (everything after "draft-"; the version
+    #                    split is done in the Builder to keep the digit-tail
+    #                    heuristic in one place)
+    class Parser < ::Pubid::Parser::Grammar
+      rule(:space) { str(" ") }
+      rule(:digit) { match["0-9"] }
+      rule(:digits) { digit.repeat(1) }
+
+      # "RFC 2119", and the zero-padded, space-less spelling the RFC editor's
+      # rfc-index.xml emits ("RFC0001"). See #subseries for why.
+      rule(:rfc) { str("RFC") >> space.maybe >> digits.as(:number) }
+
+      # "BCP 3" / "STD 66" / "FYI 1".
+      #
+      # The space is optional and leading zeros are allowed because
+      # rfc-index.xml writes the sub-series membership of an RFC in the padded,
+      # space-less form -- <is-also><doc-id>STD0066</doc-id></is-also> -- and
+      # relaton builds the STD/BCP/FYI <-> RFC cross-references from exactly
+      # those elements without normalizing them itself. The Builder strips the
+      # pad, so the printed form stays the canonical "STD 66".
+      rule(:subseries) do
+        (str("BCP") | str("STD") | str("FYI")).as(:series) >>
+          space.maybe >> digits.as(:number)
+      end
+
+      # Internet-Draft slug characters: lowercase, digits and the "-", "+", "_"
+      # separators, plus two historical shapes the published corpus carries --
+      # a dot inside a topic token ("draft-ietf-pilc-2.5g3g-12") and uppercase
+      # letters in protocol/organisation names ("draft-chapin-clnp-ISO8473-00").
+      # 50 of the 166,740 relaton-data-ids identifiers need those two
+      # characters; nothing else outside [a-z0-9-] occurs in the corpus.
+      #
+      # Widening the tail is unambiguous: the top-level alternation is keyed on
+      # the leading token (RFC / BCP|STD|FYI / draft-), so a wider draft tail
+      # cannot make another branch match.
+      #
+      # The whole remainder after "draft-" is captured; the Builder anchors the
+      # optional trailing "-NN" version.
+      rule(:draft_rest) { match['a-zA-Z0-9+_.\-'].repeat(1).as(:draft_rest) }
+      rule(:draft) { str("draft-") >> draft_rest }
+
+      rule(:identifier) { rfc | subseries | draft }
+      rule(:root) { identifier }
+
+      def self.parse(input)
+        new.parse(input)
+      end
+    end
+  end
+end

data/lib/pubid/ietf/renderer.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ietf
+    # Human-readable renderer for IETF identifiers.
+    #
+    # Produces strings like:
+    #   "RFC 2119"
+    #   "BCP 3" / "STD 66" / "FYI 1"
+    #   "draft-giuliano-treedn-02" / "draft-giuliano-treedn"
+    class Renderer < ::Pubid::Renderers::Base
+      def render(context: nil, **_opts)
+        require_number!(@id)
+        render_identifier(@id)
+      end
+
+      private
+
+      # For an Internet-Draft, `number` holds the version-less slug including
+      # the leading "draft-"; for the sub-series, `series` is derived from the
+      # class rather than stored. The sub-series arm names its three classes
+      # explicitly instead of being a catch-all `else`, because a bare
+      # Pubid::Ietf::Identifier has no `series` reader at all.
+      def render_identifier(id)
+        case id
+        when Identifiers::Rfc then "RFC #{id.number}"
+        when Identifiers::InternetDraft then render_draft(id)
+        when Identifiers::Bcp, Identifiers::Std, Identifiers::Fyi
+          "#{id.series} #{id.number}"
+        else unsupported!(id)
+        end
+      end
+
+      def render_draft(id)
+        id.version ? "#{id.number}-#{id.version}" : id.number
+      end
+
+      # Fail loudly rather than render a nil/partial string. `number` carries
+      # the whole document identity for every IETF type, so a nil one means the
+      # object was built from something that is not a current IETF hash — most
+      # likely a pre-`number` index row, which stored an Internet-Draft slug
+      # under `name` (a key nothing reads any more; lutaml ignores it
+      # silently). Such a row would otherwise deserialize into an identifier
+      # that renders "" or "-02" and keys the index under "", with no error
+      # anywhere — exactly the silent-wrong-lookup failure this flavor's
+      # round-trip specs exist to prevent. Regenerate the
+      # relaton-data-{rfcs,rfcsubseries,ids} indexes instead.
+      def require_number!(id)
+        return unless id.respond_to?(:number)
+        return unless id.number.nil? || id.number.empty?
+
+        raise ArgumentError,
+              "Cannot render #{id.class} with an empty number " \
+              "(a pre-`number` index row stored the draft slug under `name`; " \
+              "regenerate the index)"
+      end
+
+      def unsupported!(id)
+        raise ArgumentError,
+              "Cannot render #{id.class}: not a concrete IETF identifier"
+      end
+    end
+  end
+end

data/lib/pubid/ietf/urn_generator.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ietf
+    # Emits the canonical IETF URNs:
+    #   RFC            -> urn:ietf:rfc:2119
+    #   BCP/STD/FYI    -> urn:ietf:bcp:3 / urn:ietf:std:66 / urn:ietf:fyi:1
+    #   Internet-Draft -> urn:ietf:id:draft-giuliano-treedn[:02]
+    class UrnGenerator < Pubid::UrnGenerator::Base
+      # The sub-series arm names its three classes explicitly rather than being
+      # a catch-all `else`, because a bare Pubid::Ietf::Identifier has no
+      # `series` reader at all — `series` is derived from the concrete class.
+      def generate
+        case identifier
+        when Identifiers::Rfc then "urn:ietf:rfc:#{identifier.number}"
+        when Identifiers::InternetDraft then draft_urn
+        when Identifiers::Bcp, Identifiers::Std, Identifiers::Fyi
+          "urn:ietf:#{identifier.series.downcase}:#{identifier.number}"
+        else unsupported!
+        end
+      end
+
+      private
+
+      def draft_urn
+        base = "urn:ietf:id:#{identifier.number}"
+        identifier.version ? "#{base}:#{identifier.version}" : base
+      end
+
+      def unsupported!
+        raise ArgumentError,
+              "Cannot build a URN for #{identifier.class}: " \
+              "not a concrete IETF identifier"
+      end
+    end
+  end
+end

data/lib/pubid/ietf/urn_parser.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ietf
+    # Parses IETF URNs back into identifiers by reconstructing the printed form
+    # and delegating to the flavor's text parser. Inverts UrnGenerator:
+    #   urn:ietf:rfc:2119                     -> "RFC 2119"
+    #   urn:ietf:bcp:3                        -> "BCP 3"
+    #   urn:ietf:id:draft-giuliano-treedn:02  -> "draft-giuliano-treedn-02"
+    #   urn:ietf:id:draft-giuliano-treedn     -> "draft-giuliano-treedn"
+    class UrnParser < Pubid::UrnParser::Base
+      def parse_urn(urn)
+        parts = split_parts(strip_namespace(urn))
+        flavor_parse(human_text(parts.shift, parts))
+      end
+
+      private
+
+      def human_text(type, parts)
+        case type
+        when "rfc" then "RFC #{parts[0]}"
+        when "bcp", "std", "fyi" then "#{type.upcase} #{parts[0]}"
+        when "id" then draft_text(parts)
+        else invalid_type!(type)
+        end
+      end
+
+      # `Errors` is defined under Pubid::UrnParser (the module), which is
+      # neither in this class's lexical scope nor an ancestor of Base, so the
+      # constant must be fully qualified — a bare `Errors::ParseError` raises
+      # NameError instead of the intended error.
+      def invalid_type!(type)
+        raise Pubid::UrnParser::Errors::ParseError,
+              "Invalid IETF URN type: #{type.inspect}"
+      end
+
+      def draft_text(parts)
+        name, version = parts
+        version ? "#{name}-#{version}" : name
+      end
+    end
+  end
+end

data/lib/pubid/ietf.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Pubid
+  # IETF flavor: one module covering the three IETF document families that share
+  # the IETF publisher and the `urn:ietf:` namespace —
+  #   * RFC              (e.g. "RFC 2119")     -> Identifiers::Rfc
+  #   * RFC sub-series   (BCP/STD/FYI)         -> Identifiers::Bcp/Std/Fyi
+  #   * Internet-Drafts  (e.g. "draft-...-02") -> Identifiers::InternetDraft
+  module Ietf
+    extend Pubid::PrefixesSupport
+
+    # Leading tokens a printed IETF id can begin with. "draft" covers the
+    # "draft-<slug>" Internet-Draft form. No joint/co-publication prefixes.
+    PREFIXES = ["RFC", "BCP", "STD", "FYI", "draft"].freeze
+
+    autoload :Builder, "#{__dir__}/ietf/builder"
+    autoload :Identifier, "#{__dir__}/ietf/identifiers/base"
+    autoload :Identifiers, "#{__dir__}/ietf/identifiers"
+    autoload :Parser, "#{__dir__}/ietf/parser"
+    autoload :Renderer, "#{__dir__}/ietf/renderer"
+    autoload :UrnGenerator, "#{__dir__}/ietf/urn_generator"
+    autoload :UrnParser, "#{__dir__}/ietf/urn_parser"
+
+    # Parse an IETF identifier string
+    def self.parse(identifier)
+      # Inline length guard (CodeQL rb/polynomial-redos barrier) before the
+      # normalization/parse path. The type check goes above it because it is
+      # what makes `.length` safe to call; the length check itself must still
+      # be the first thing the input string meets.
+      unless identifier.is_a?(String)
+        raise Pubid::Errors::InvalidInputError,
+              Pubid::INPUT_NOT_A_STRING_MESSAGE
+      end
+      if identifier.length > Pubid::MAX_INPUT_LENGTH
+        raise Pubid::Errors::InvalidInputError,
+              Pubid::INPUT_TOO_LONG_MESSAGE
+      end
+
+      Identifier.parse(identifier)
+    end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Ietf::Renderer)
+
+    # Auto-discover all identifier types from the Identifiers namespace
+    # @return [Array<Class>] identifier classes that define a self.type Hash
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants
+        .filter_map { |c| begin; Identifiers.const_get(c); rescue NameError; nil; end }
+        .select { |c| c.is_a?(Class) && c.singleton_methods(false).include?(:type) }
+        .select { |c| c.type.is_a?(Hash) }
+    end
+
+    # Build typed stage index from identifier types
+    # @return [Array<Pubid::Components::TypedStage>] all typed stages
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types.flat_map do |klass|
+        if klass.const_defined?(:TYPED_STAGES)
+          klass.const_get(:TYPED_STAGES)
+        else
+          []
+        end
+      end
+    end
+
+    # Lookup: type code -> identifier class
+    # @param code [String, Symbol] the type key to find
+    # @return [Class, nil] the matching identifier class
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    # Lookup: abbreviation -> typed stage
+    # @param abbr [String, Symbol] the abbreviation to find
+    # @return [Pubid::Components::TypedStage, nil] the matching typed stage
+    def self.locate_stage(abbr)
+      abbr_str = abbr.to_s.upcase
+      all_typed_stages.find { |s| s.abbr.any? { |a| a.to_s.upcase == abbr_str } }
+    end
+  end
+end
+
+# Register IETF flavor with the registry
+Pubid::Registry.register(:ietf, Pubid::Ietf)

data/lib/pubid/iho/builder.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iho
+    # Build IHO identifier objects from parslet parse output.
+    class Builder
+      def build(parsed)
+        hash = parsed.is_a?(Array) ? parsed.reduce({}, :merge) : parsed
+        type_letter = stringify(hash[:type])
+
+        attrs = {
+          number: stringify(hash[:number]),
+          appendix: stringify(hash[:appendix]),
+          part: stringify(hash[:part]),
+          annex: stringify(hash[:annex]),
+          supplement: stringify(hash[:supplement]),
+          version: stringify(hash[:version]),
+        }.compact
+
+        Pubid::Iho.identifier_klass_for_type_letter(type_letter).new(**attrs)
+      end
+
+      def self.build(parsed)
+        new.build(parsed)
+      end
+
+      private
+
+      def stringify(value)
+        return nil if value.nil?
+
+        str = value.to_s
+        str.empty? ? nil : str
+      end
+    end
+  end
+end

data/lib/pubid/iho/identifier.rb

@@ -0,0 +1,7 @@
+# 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.

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+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
+        end
+
+        if identifier.length > Pubid::MAX_INPUT_LENGTH
+          raise Pubid::Errors::InvalidInputError, Pubid::INPUT_TOO_LONG_MESSAGE
+        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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iho
+    module Identifiers
+      # IHO Bibliographic Publication (B series).
+      # Example: IHO B-4 2.19.0.
+      class Bibliographic < Identifier
+        def self.type
+          { key: :bibliographic, title: "Bibliographic Publication",
+            short: "B" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iho
+    module Identifiers
+      # IHO Circular Letter (C series).
+      # Example: IHO C-13 1.0.0.
+      class CircularLetter < Identifier
+        def self.type
+          { key: :circular_letter, title: "Circular Letter", short: "C" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iho
+    module Identifiers
+      # IHO Miscellaneous Publication (M series).
+      # Example: IHO M-3 2.0.0.
+      class Miscellaneous < Identifier
+        def self.type
+          { key: :miscellaneous, title: "Miscellaneous Publication",
+            short: "M" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iho
+    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
+        def self.type
+          { key: :publication, title: "Publication", short: "P" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iho
+    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
+        def self.type
+          { key: :standard, title: "Standards and Specifications", short: "S" }
+        end
+      end
+    end
+  end
+end