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

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

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

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

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

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

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

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

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

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

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

@@ -1,85 +0,0 @@
-# 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/renderer.rb

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

data/lib/pubid/iho/urn_parser.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Iho
-    # Parses IHO URNs back into identifiers.
-    #
-    # UrnGenerator emits:
-    #   urn:iho:{type-lower}:{number}[:{part-kind}.{part}]:{version}
-    #
-    # type-lower is the lowercase series letter (s, p, m, b, c).
-    # part-kind is the lowercase part label (part, ap, annex, suppl).
-    # version is the dotted version string.
-    #
-    # Examples:
-    # - urn:iho:s:44:5.0.0                → IHO S-44 5.0.0
-    # - urn:iho:s:100:part.4a:1.0.0       → IHO S-100 Part 4a 1.0.0
-    # - urn:iho:s:65:ap.A:1.0.0           → IHO S-65 Ap. A 1.0.0
-    class UrnParser < Pubid::UrnParser::Base
-      PART_LABELS = {
-        "part" => "Part",
-        "ap" => "Ap.",
-        "annex" => "Annex",
-        "suppl" => "Suppl",
-      }.freeze
-
-      def parse_urn(urn)
-        body = strip_namespace(urn)
-        parts = split_parts(body)
-
-        type_token = parts.fetch(0).upcase
-        number = parts.fetch(1)
-        idx = 2
-        part_label = nil
-        if parts[idx] && part_kind?(parts[idx])
-          kind, value = parts[idx].split(".", 2)
-          label = PART_LABELS.fetch(kind.downcase) { kind.capitalize }
-          part_label = "#{label} #{value}"
-          idx += 1
-        end
-        version = parts[idx]
-
-        text = "IHO #{type_token}-#{number}"
-        text += " #{part_label}" if part_label
-        text += " #{version}" if version
-        flavor_parse(text)
-      end
-
-      private
-
-      # A part-kind token starts with letters followed by a dot, e.g.,
-      # "part.4a", "ap.A", "annex.A", "suppl.1". A version like "5.0.0"
-      # starts with a digit.
-      def part_kind?(token)
-        token.match?(/^[a-z]+\./i)
-      end
-    end
-  end
-end

data/lib/pubid/isbn/builder.rb

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

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