pubid 2.0.0.pre.alpha.7 → 2.0.0.pre.alpha.9

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ietf
+    module Identifiers
+      # An FYI (For Your Information) sub-series id, e.g. "FYI 1".
+      class Fyi < Identifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :fyi,
+            stage_code: :published,
+            type_code: :fyi,
+            abbr: ["FYI"],
+            name: "For Your Information",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :fyi, web: :fyi, title: "For Your Information", short: "FYI" }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# 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 `name`; the optional
+      # trailing two-digit version in `version`.
+      class InternetDraft < Identifier
+        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,25 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ietf
+    module Identifiers
+      # An RFC (Request for Comments), e.g. "RFC 2119".
+      class Rfc < Identifier
+        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/std.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ietf
+    module Identifiers
+      # An STD (Internet Standard) sub-series id, e.g. "STD 66".
+      class Std < Identifier
+        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,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Ietf
+    module Identifiers
+      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,43 @@
+# 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 < Parslet::Parser
+      rule(:space) { str(" ") }
+      rule(:digit) { match["0-9"] }
+      rule(:digits) { digit.repeat(1) }
+
+      # "RFC 2119"
+      rule(:rfc) { str("RFC") >> space >> digits.as(:number) }
+
+      # "BCP 3" / "STD 66" / "FYI 1"
+      rule(:subseries) do
+        (str("BCP") | str("STD") | str("FYI")).as(:series) >>
+          space >> digits.as(:number)
+      end
+
+      # Internet-Draft slug characters (lowercase, digits, and the "-", "+", "_"
+      # separators seen in the corpus). The whole remainder after "draft-" is
+      # captured; the Builder anchors the optional trailing "-NN" version.
+      rule(:draft_rest) { match['a-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,26 @@
+# 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)
+        id = @id
+
+        case id
+        when Identifiers::Rfc
+          "RFC #{id.number}"
+        when Identifiers::InternetDraft
+          id.version ? "#{id.name}-#{id.version}" : id.name
+        else # Bcp/Std/Fyi sub-series
+          "#{id.series} #{id.number}"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ietf/urn_generator.rb

@@ -0,0 +1,23 @@
+# 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
+      def generate
+        case identifier
+        when Identifiers::Rfc
+          "urn:ietf:rfc:#{identifier.number}"
+        when Identifiers::InternetDraft
+          base = "urn:ietf:id:#{identifier.name}"
+          identifier.version ? "#{base}:#{identifier.version}" : base
+        else # Bcp/Std/Fyi sub-series
+          "urn:ietf:#{identifier.series.downcase}:#{identifier.number}"
+        end
+      end
+    end
+  end
+end

data/lib/pubid/ietf/urn_parser.rb

@@ -0,0 +1,35 @@
+# 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
+          raise Errors::ParseError, "Invalid IETF URN type: #{type.inspect}"
+        end
+      end
+
+      def draft_text(parts)
+        name, version = parts
+        version ? "#{name}-#{version}" : name
+      end
+    end
+  end
+end

data/lib/pubid/ietf.rb

@@ -0,0 +1,76 @@
+# 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 — must be the first statement.
+      raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE if identifier.length > Pubid::MAX_INPUT_LENGTH
+
+      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/identifier.rb

@@ -3,7 +3,5 @@
 # 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
+# body and `.parse` 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

@@ -3,8 +3,7 @@
 module Pubid
   module Iho
     # 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.
+    # 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}]
@@ -65,10 +64,5 @@ module Pubid
       # 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/identifiers/bibliographic.rb

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

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

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

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

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

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

@@ -5,7 +5,7 @@ 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 < Base
+      class Publication < Identifier
         def self.type
           { key: :publication, title: "Publication", short: "P" }
         end

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

@@ -5,7 +5,7 @@ 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 < Base
+      class Standard < Identifier
         def self.type
           { key: :standard, title: "Standards and Specifications", short: "S" }
         end

data/lib/pubid/iho/identifiers.rb

@@ -3,7 +3,6 @@
 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.rb

@@ -8,7 +8,7 @@ module Pubid
     PREFIXES = ["IHO"].freeze
 
     autoload :Builder,      "#{__dir__}/iho/builder"
-    autoload :Identifier,   "#{__dir__}/iho/identifier"
+    autoload :Identifier, "#{__dir__}/iho/identifiers/base"
     autoload :Identifiers,  "#{__dir__}/iho/identifiers"
     autoload :Parser,       "#{__dir__}/iho/parser"
     autoload :Renderer,     "#{__dir__}/iho/renderer"
@@ -17,14 +17,14 @@ module Pubid
 
     # 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
+    # @return [Pubid::Iho::Identifier] The appropriate identifier object
     def self.parse(identifier)
       Identifier.parse(identifier)
     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: Iho::Renderer)
+    Identifier.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Iho::Renderer)
 
     # Auto-discover all identifier types from the Identifiers namespace.
     # @return [Array<Class>] identifier classes (Pubid::Identifier subclasses)
@@ -32,9 +32,9 @@ module Pubid
       @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 }
-        # Exclude the flavor base itself by identity (Identifiers::Base is now an
+        # Exclude the flavor base itself by identity (Identifier is now an
         # alias for Pubid::Iho::Identifier, so name-based matching misses it).
-        .reject { |c| c == Identifiers::Base }
+        .reject { |c| c == Identifier }
     end
 
     # Build typed stage index from identifier types
@@ -66,7 +66,7 @@ module Pubid
 
     # Look up an identifier class by its IHO series letter (S/P/M/B/C).
     # @param letter [String]
-    # @return [Class<Identifiers::Base>]
+    # @return [Class<Identifier>]
     def self.identifier_klass_for_type_letter(letter)
       @by_letter ||= identifier_types.to_h { |klass| [klass.type[:short], klass] }
       @by_letter.fetch(letter.to_s)

data/lib/pubid/isbn/builder.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Isbn
+    # Builds a Pubid::Isbn::Identifier from a parse tree.
+    #
+    # Validates the check digit; raises if invalid. Stores both the
+    # hyphenated form (for round-trip rendering) and the bare digits
+    # (for queries).
+    class Builder
+      INVALID_LENGTH = /^(?:\d{9}[\dX]|\d{13})$/.freeze
+
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      end
+
+      def build(data)
+        hyphenated = data[:body].to_s
+        raw = hyphenated.delete("-")
+
+        validate_length!(raw)
+        validate_check_digit!(raw)
+
+        Identifiers::Book.new(raw: raw, hyphenated: hyphenated.include?("-") ? hyphenated : nil)
+      end
+
+      private
+
+      def validate_length!(raw)
+        return if raw.match?(INVALID_LENGTH)
+
+        raise ArgumentError,
+              "ISBN must be 10 or 13 digits (got #{raw.length})"
+      end
+
+      def validate_check_digit!(raw)
+        return if CheckDigit.valid?(raw)
+
+        raise ArgumentError,
+              "ISBN check digit invalid for #{raw}"
+      end
+    end
+  end
+end

data/lib/pubid/isbn/check_digit.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Isbn
+    # Pure-functional check digit math for ISBN-10 and ISBN-13 per ISO 2108.
+    #
+    # ISBN-10: weighted sum with weights 10..1, mod 11. Check digit 10 is
+    # rendered as "X".
+    # ISBN-13: weighted sum with alternating weights 1/3, mod 10. Check digit
+    # is 0-9.
+    class CheckDigit
+      # Compute the correct ISBN-10 check digit for a 9-digit payload.
+      # @return [String] "0".."9" or "X"
+      def self.compute_isbn10(payload)
+        raise ArgumentError, "ISBN-10 payload must be 9 digits" unless payload.to_s.match?(/\A\d{9}\z/)
+
+        sum = payload.to_s.each_char.with_index.sum { |c, i| c.to_i * (10 - i) }
+        digit = (11 - sum % 11) % 11
+        digit == 10 ? "X" : digit.to_s
+      end
+
+      # Compute the correct ISBN-13 check digit for a 12-digit payload.
+      # @return [String] "0".."9"
+      def self.compute_isbn13(payload)
+        raise ArgumentError, "ISBN-13 payload must be 12 digits" unless payload.to_s.match?(/\A\d{12}\z/)
+
+        sum = payload.to_s.each_char.with_index.sum do |c, i|
+          c.to_i * (i.even? ? 1 : 3)
+        end
+        ((10 - sum % 10) % 10).to_s
+      end
+
+      # Verify the check digit on a full 10- or 13-digit ISBN string.
+      # @param full [String] 10 or 13 chars; ISBN-10 may end with X.
+      # @return [Boolean]
+      def self.valid?(full)
+        digits = full.to_s.upcase.delete("^0-9X")
+        case digits.length
+        when 10
+          payload = digits[0, 9]
+          actual = digits[9]
+          compute_isbn10(payload) == actual
+        when 13
+          payload = digits[0, 12]
+          actual = digits[12]
+          compute_isbn13(payload) == actual
+        else
+          false
+        end
+      end
+    end
+  end
+end

data/lib/pubid/isbn/identifier.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Isbn
+    class Identifier < ::Pubid::Identifier
+      # The digits-only ISBN (no hyphens), including check digit. 10 or 13 chars.
+      attribute :raw, :string
+
+      # Original hyphenated form (may be nil when the input had no hyphens).
+      # Preserved for round-trip rendering; not queryable semantics.
+      attribute :hyphenated, :string
+
+      ISBN_TYPE_MAP = {
+        "pubid:isbn:book" => "Pubid::Isbn::Identifiers::Book",
+      }.freeze
+
+      key_value do
+        map "_type", to: :_type, polymorphic_map: ISBN_TYPE_MAP
+        map "raw", to: :raw
+        map "hyphenated", to: :hyphenated
+      end
+
+      PUBLISHER = "ISBN"
+
+      # Returns :isbn10 or :isbn13.
+      def form
+        case raw.to_s.length
+        when 10 then :isbn10
+        when 13 then :isbn13
+        else raise "Invalid ISBN length: #{raw.inspect}"
+        end
+      end
+
+      def check_digit
+        raw.to_s[-1]
+      end
+
+      def valid?
+        CheckDigit.valid?(raw)
+      end
+
+      def to_s(**opts)
+        render(format: :human, **opts)
+      end
+
+      def self.parse(identifier)
+        if identifier.length > Pubid::MAX_INPUT_LENGTH
+          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      rescue Parslet::ParseFailed => e
+        raise "Failed to parse ISBN '#{identifier}': #{e.message}"
+      rescue ArgumentError => e
+        # Builder validates length/check-digit; surface as a parse error so
+        # the error contract matches other flavors (always raises a string
+        # beginning with "Failed to parse").
+        raise "Failed to parse ISBN '#{identifier}': #{e.message}"
+      end
+    end
+  end
+end

data/lib/pubid/isbn/identifiers/book.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Isbn
+    module Identifiers
+      # ISBN book identifier — supports both ISBN-10 and ISBN-13.
+      #
+      # Examples:
+      #   ISBN 978-3-16-148410-0
+      #   ISBN 0-306-40615-2
+      #   9783161484100
+      class Book < Identifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubisbn,
+            stage_code: :published,
+            type_code: :isbn,
+            abbr: ["ISBN"],
+            name: "ISBN",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :isbn, web: :book, title: "ISBN", short: "ISBN" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/isbn/identifiers.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Isbn
+    module Identifiers
+      autoload :Book, "#{__dir__}/identifiers/book"
+    end
+  end
+end