pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/iho/identifiers.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iho
+    module Identifiers
+      autoload :Bibliographic,  "#{__dir__}/identifiers/bibliographic"
+      autoload :CircularLetter, "#{__dir__}/identifiers/circular_letter"
+      autoload :Miscellaneous,  "#{__dir__}/identifiers/miscellaneous"
+      autoload :Publication,    "#{__dir__}/identifiers/publication"
+      autoload :Standard,       "#{__dir__}/identifiers/standard"
+    end
+  end
+end

data/lib/pubid/iho/parser.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Iho
+    # Parser class for IHO identifiers
+    class Parser < ::Pubid::Parser::Grammar
+      rule(:space)  { str(" ") }
+      rule(:dash)   { str("-") }
+      rule(:dot)    { str(".") }
+      rule(:digits) { match("[0-9]").repeat(1) }
+
+      rule(:series) do
+        (str("S") | str("P") | str("M") | str("B") | str("C")).as(:type)
+      end
+
+      rule(:number_suffix) do
+        (str(":") >> digits) | (str("/") >> digits) | (dash >> digits) | match("[A-Z]")
+      end
+
+      rule(:number) do
+        (digits >> number_suffix.maybe).as(:number)
+      end
+
+      rule(:appendix) do
+        space >> (str("Appendix") | str("Ap.")) >> space >>
+          (
+            (match("[A-Z]") >> dash >> digits) |
+            digits |
+            match("[A-Z]")
+          ).as(:appendix)
+      end
+
+      rule(:part) do
+        space >> str("Part") >> space >>
+          (
+            (digits >> match("[a-zA-Z]").repeat).as(:part) |
+            match("[A-Z]").as(:part)
+          )
+      end
+
+      rule(:annex) do
+        space >> str("Annex") >> space >> match("[A-Z]").as(:annex)
+      end
+
+      rule(:supplement) do
+        space >> str("Suppl") >> space >> digits.as(:supplement)
+      end
+
+      rule(:version) do
+        space >> (digits >> dot >> digits >> dot >> digits).as(:version)
+      end
+
+      rule(:identifier) do
+        (str("IHO") >> space).maybe >>
+          series >> dash >> number >>
+          appendix.maybe >> part.maybe >> annex.maybe >> supplement.maybe >> version.maybe
+      end
+
+      root :identifier
+
+      def self.parse(string)
+        new.parse(string.strip)
+      end
+    end
+  end
+end

data/lib/pubid/iho/renderer.rb

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

data/lib/pubid/iho/urn_generator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iho
+    # Generates URN strings for IHO identifiers.
+    #
+    # Format: urn:iho:{type-letter-lowercase}:{number}[:ap.{appendix}][:part.{part}][:annex.{annex}][:suppl.{supplement}][:{version}]
+    # Example: urn:iho:s:44:5.0.0 for "IHO S-44 5.0.0".
+    class UrnGenerator
+      attr_reader :identifier
+
+      def initialize(identifier)
+        @identifier = identifier
+      end
+
+      def generate
+        parts = ["urn", "iho"]
+        parts << identifier.class.type[:short].to_s.downcase
+        parts << identifier.number.to_s
+        parts << "ap.#{identifier.appendix}"     if identifier.appendix
+        parts << "part.#{identifier.part}"       if identifier.part
+        parts << "annex.#{identifier.annex}"     if identifier.annex
+        parts << "suppl.#{identifier.supplement}" if identifier.supplement
+        parts << identifier.version.to_s if identifier.version
+        parts.join(":")
+      end
+    end
+  end
+end

data/lib/pubid/iho/urn_parser.rb

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Iho
+    extend Pubid::PrefixesSupport
+
+    # Sole IHO publisher token (see the parser grammar).
+    PREFIXES = ["IHO"].freeze
+
+    autoload :Builder,      "#{__dir__}/iho/builder"
+    autoload :Identifier, "#{__dir__}/iho/identifiers/base"
+    autoload :Identifiers,  "#{__dir__}/iho/identifiers"
+    autoload :Parser,       "#{__dir__}/iho/parser"
+    autoload :Renderer,     "#{__dir__}/iho/renderer"
+    autoload :UrnGenerator, "#{__dir__}/iho/urn_generator"
+    autoload :UrnParser, "#{__dir__}/iho/urn_parser"
+
+    # 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
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    end
+
+    # Per-flavor format registry: inherits global formats, overrides :human
+    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)
+    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 < Pubid::Identifier }
+        # 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 == Identifier }
+    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
+
+    # Look up an identifier class by its IHO series letter (S/P/M/B/C).
+    # @param letter [String]
+    # @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)
+    end
+  end
+end
+
+Pubid::Registry.register(:iho, Pubid::Iho)

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,81 @@
+# 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)
+        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
+
+        # The two guards above must stay OUTSIDE build_identifier: this method
+        # rescues ArgumentError to convert the Builder's check-digit and
+        # length validation into a parse failure, and that rescue used to
+        # swallow the guards' own ArgumentError and re-raise it as a
+        # RuntimeError - so ISBN was the one guarded flavor where an over-long
+        # input did not surface as ArgumentError.
+        build_identifier(identifier)
+      end
+
+      # @raise [Pubid::Errors::ParseError] if the string is not a valid ISBN
+      def self.build_identifier(identifier)
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      rescue ArgumentError => e
+        # The Builder validates length and check digit. Surface that as a parse
+        # failure, so every ISBN rejection reaches the caller as the same class
+        # a grammar rejection does.
+        raise Pubid::Errors::ParseError.new(
+          "invalid ISBN '#{identifier}': #{e.message}",
+          input: identifier, flavor: "isbn",
+        )
+      end
+      private_class_method :build_identifier
+    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

data/lib/pubid/isbn/parser.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Isbn
+    # Parslet grammar for ISBN identifiers per ISO 2108.
+    #
+    # Accepts:
+    #   [ISBN[ |:]] {10 or 13 digits with optional hyphens}
+    #
+    # ISBN-10 final digit may be "X" (check digit value 10). Hyphens are
+    # optional and may appear in any group position; they are preserved
+    # for round-trip rendering.
+    class Parser < ::Pubid::Parser::Grammar
+      rule(:space)   { str(" ") }
+      rule(:colon)   { str(":") }
+      rule(:hyphen)  { str("-") }
+      rule(:digit)   { match("[0-9]") }
+      rule(:x_digit) { digit | str("X") }
+
+      rule(:isbn_prefix) do
+        (str("ISBN") >> (space | (space.maybe >> colon >> space.maybe))).maybe
+      end
+
+      rule(:digit_group) { digit.repeat(1) }
+      rule(:x_group)     { x_digit.repeat(1) }
+
+      # Loose "ISBN-ish" token: digits or final X, separated by hyphens.
+      rule(:isbn_body) do
+        (digit_group >> (hyphen >> digit_group).repeat >>
+          (hyphen >> x_digit).maybe).as(:body) |
+          (digit.repeat(9, 12) >> x_digit.maybe).as(:body)
+      end
+
+      rule(:identifier) { isbn_prefix >> isbn_body }
+
+      rule(:root) { identifier }
+
+      def self.parse(input)
+        new.parse(input)
+      end
+    end
+  end
+end

data/lib/pubid/isbn/renderer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Isbn
+    # Human-readable renderer for ISBN identifiers.
+    #
+    # Preserves the original hyphenation when present; otherwise emits the
+    # bare digits. Always emits the "ISBN " prefix.
+    class Renderer < ::Pubid::Renderers::Base
+      def render(**_opts)
+        body = @id.hyphenated || @id.raw
+        "ISBN #{body}"
+      end
+    end
+  end
+end

data/lib/pubid/isbn.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Pubid
+  # ISBN flavor — bibliographic book identifier per ISO 2108.
+  #
+  # Parses both 10-digit (ISBN-10) and 13-digit (ISBN-13) forms with
+  # optional hyphenation. The check digit is validated; an invalid check
+  # digit raises on parse.
+  module Isbn
+    extend Pubid::PrefixesSupport
+
+    PREFIXES = ["ISBN"].freeze
+
+    autoload :CheckDigit, "#{__dir__}/isbn/check_digit"
+    autoload :Builder, "#{__dir__}/isbn/builder"
+    autoload :Identifier, "#{__dir__}/isbn/identifier"
+    autoload :Identifiers, "#{__dir__}/isbn/identifiers"
+    autoload :Parser, "#{__dir__}/isbn/parser"
+    autoload :Renderer, "#{__dir__}/isbn/renderer"
+
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    end
+
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Isbn::Renderer)
+
+    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
+
+    def self.all_typed_stages
+      @all_typed_stages ||= identifier_types.flat_map do |klass|
+        klass.const_defined?(:TYPED_STAGES) ? klass.const_get(:TYPED_STAGES) : []
+      end
+    end
+
+    def self.locate_type(code)
+      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
+    end
+
+    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
+
+Pubid::Registry.register(:isbn, Pubid::Isbn)