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

data/lib/pubid/isbn/identifier.rb

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

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

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

data/lib/pubid/isbn/parser.rb

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

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

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

data/lib/pubid/iso/normalizer.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Iso
-    # Applies pre-parse normalizations to ISO identifier strings, then dispatches
-    # to the parser/builder. Handles Cyrillic (Russian) translations, legacy
-    # update_codes regex rewrites, and the DAD/FDAM pattern that the PEG
-    # parser cannot recognize because it treats "/" as a copublisher separator.
-    class Normalizer
-      DAD_PATTERN = /^(.+?)\/(F?DAD)\s+(\d+)(?::(\d{4}))?$/.freeze
-
-      class << self
-        # Apply all normalizations to an identifier string and return the
-        # parsed identifier object.
-        # @param identifier [String]
-        # @return [Pubid::Iso::Identifier]
-        def apply(identifier)
-          if (match = identifier.match(DAD_PATTERN))
-            parse_dad_pattern(match)
-          else
-            normalized = Core::UpdateCodes.apply(identifier, :iso)
-            normalized = normalize_cyrillic(normalized)
-            parse_with_builder(normalized)
-          end
-        end
-
-        private
-
-        def parse_with_builder(string)
-          parsed = Pubid::Iso.parser.parse(string)
-          Pubid::Iso.builder.build(parsed)
-        end
-
-        # Normalize Cyrillic (Russian) ISO identifiers to Latin equivalents.
-        # ИСО = ISO, МЭК = IEC, Руководство/Руководства = Guide,
-        # ОПМС = FDIS, ПМС = DIS, ТО = TR, ТС = TS.
-        # @return [String]
-        def normalize_cyrillic(identifier)
-          return identifier unless identifier.match?(/[а-яА-Я]/)
-
-          normalized = identifier.dup
-          # Remove inline comments (Russian style comments with #)
-          normalized = normalized.gsub(/\s*#\s*.*$/, "")
-          # Translate Russian abbreviations (order matters: longer first)
-          normalized = normalized.gsub("Руководства", "GUIDE")
-          normalized = normalized.gsub("Руководство", "GUIDE")
-          normalized = normalized.gsub("ИСО/МЭК", "ISO/IEC")
-          normalized = normalized.gsub("ИСО/ОПМС", "ISO/FDIS")
-          normalized = normalized.gsub("ИСО/ПМС", "ISO/DIS")
-          normalized = normalized.gsub("ИСО/ТО", "ISO/TR")
-          normalized = normalized.gsub("ИСО/ТС", "ISO/TS")
-          normalized = normalized.gsub("ИСО", "ISO")
-          normalized = normalized.gsub("МЭК", "IEC")
-          # Standalone Cyrillic stage abbreviations (after publisher replacements)
-          normalized = normalized.gsub("ТО", "TR")
-          normalized = normalized.gsub("ТС", "TS")
-          normalized = normalized.gsub("ОПМС", "FDIS")
-          normalized = normalized.gsub("ПМС", "DIS")
-          normalized.strip
-        end
-
-        # Parse the DAD/FDAM pattern manually. The parser fails because it
-        # treats "/" as a copublisher separator.
-        # Pattern: "ISO 2631/DAD 1" or "ISO 2553/DAD 1:1987"
-        def parse_dad_pattern(match)
-          base_str = match[1]          # "ISO 2631" or "ISO 2553"
-          stage_abbr = match[2]        # "DAD" or "FDAD"
-          supplement_number = match[3] # "1"
-          supplement_year = match[4]   # "1987" or nil
-
-          base_parsed = Pubid::Iso.parser.parse(base_str)
-          base = Pubid::Iso.builder.build(base_parsed)
-
-          addendum = Identifiers::Addendum.new
-          addendum.base = base
-          addendum.number = Iso::Components::Code.new(value: supplement_number)
-          addendum.date = Pubid::Components::Date.new(year: supplement_year) if supplement_year
-
-          typed_stage = Pubid::Iso.locate_stage(stage_abbr)
-          addendum.typed_stage = typed_stage
-          addendum.stage = typed_stage.to_stage
-          addendum.type = typed_stage.to_type
-
-          addendum
-        end
-      end
-    end
-  end
-end

data/lib/pubid/itu/components/designation.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require "lutaml/model"
-
-module Pubid
-  module Itu
-    module Components
-      # One series+number designation of a combined (joint) recommendation.
-      # A combined recommendation such as "ITU-T G.780/Y.1351" keeps its primary
-      # designation on the base identifier (series "G", code "780") and carries
-      # each *additional* designation ("Y.1351", and any further "/Z.1362" …) as
-      # a Designation in Identifiers::CombinedIdentifier#combined.
-      #
-      # Format: SERIES.CODE  (e.g. "Y.1351", "Y.1362-2")
-      class Designation < Lutaml::Model::Serializable
-        attribute :series, Pubid::Itu::Components::Series
-        attribute :code, Pubid::Itu::Components::Code
-
-        def to_s
-          "#{series}.#{code}"
-        end
-
-        def render(context: nil)
-          to_s
-        end
-
-        def ==(other)
-          return false unless other.is_a?(Designation)
-
-          series == other.series && code == other.code
-        end
-      end
-    end
-  end
-end

data/lib/pubid/itu/components.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Itu
-    module Components
-      autoload :Sector, "#{__dir__}/components/sector"
-      autoload :Series, "#{__dir__}/components/series"
-      autoload :Code, "#{__dir__}/components/code"
-      autoload :Designation, "#{__dir__}/components/designation"
-    end
-  end
-end

data/lib/pubid/itu/identifiers/addendum.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Itu
-    module Identifiers
-      # Addendum identifier (Add.)
-      # Pattern: "ITU-T I.363 (1993) Add. 1 (11/1993)"
-      class Addendum < Supplement
-        def to_s(**opts)
-          annotate_plain_render(render_supplement("Add."), **opts)
-        end
-      end
-    end
-  end
-end

data/lib/pubid/itu/identifiers/annex_of_recommendation.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Itu
-    module Identifiers
-      # A labelled annex of a Recommendation — "ITU-T A.23 Annex A (06/2014)",
-      # "ITU-T Z.100 Annex F3 (10/2019)", "ITU-T G.729 Annex C+ (02/2000)".
-      #
-      # The annex is a document in its own right: it is published (and dated)
-      # separately from the Recommendation it annexes, and may itself carry a
-      # corrigendum/errata/amendment ("ITU-T G.729 Annex B (1996) Cor. 3
-      # (03/2001)").
-      #
-      # Distinct from Identifiers::Annex, which models the label-less
-      # "Annex to ITU OB No. 1000" form (a prefix rendering with its own i18n
-      # templates). Keeping them apart keeps each `_type` — already persisted in
-      # relaton index rows — unambiguous.
-      class AnnexOfRecommendation < Identifier
-        attribute :base, Identifier, polymorphic: true
-        # The annex label ("A", "F3", "C+"). Named `number` for symmetry with
-        # Supplement's ordinal; it shadows Identifier#number (code&.number),
-        # which is nil here anyway — the document number is reached via #root.
-        attribute :number, :string
-
-        # Compact serialization: the annex is the nested (itself-flat) base plus
-        # its own label, date and language. sector/series/code are the base's
-        # and are deliberately not re-emitted (the wrapper lesson).
-        key_value do
-          map "_type", to: :_type
-          map "number", to: :number
-          map "year", with: { to: :year_to_kv, from: :year_from_kv }
-          map "month", with: { to: :month_to_kv, from: :month_from_kv }
-          map "base", with: { to: :base_to_kv, from: :base_from_kv }
-          map "language", to: :language
-          map "common_text_twin",
-              with: { to: :common_text_twin_to_kv,
-                      from: :common_text_twin_from_kv }
-        end
-
-        # "<base urn>:annex:<label>[:<date>]" — the annex's own date must be
-        # there, or two editions of one annex share a URN (the base's date
-        # rides inside base_urn, so omitting the annex's would be asymmetric).
-        def to_urn
-          segments = [base&.to_urn || "urn:itu", "annex", number&.downcase]
-          segments << urn_date_segment
-          segments.compact.join(":")
-        end
-
-        def render_base(**opts)
-          result = base ? base.render_base(**opts) : "#{publisher}-#{sector}"
-
-          "#{result} Annex #{number}#{render_date_suffix}"
-        end
-
-        # MR: recurse into the annexed document and append "annex.<label>[.year]"
-        # (the documented supplement-suffix hook), so the slug stays distinct
-        # per annex. Without it the wrapper's own nil sector/series/code would
-        # collapse every annex onto a bare "itu.<year>".
-        def mr_supplement_suffix
-          # "C+" -> "cplus", not "c" — the MR charset excludes "+", and
-          # dropping it would collide with the sibling "Annex C".
-          label = number.to_s.downcase.gsub("+", "plus").gsub(/[^a-z0-9]/, "")
-
-          ["annex", label.empty? ? nil : label, date&.year].compact.join(".")
-        end
-
-        def ==(other)
-          return false unless other.instance_of?(self.class)
-
-          base == other.base &&
-            number == other.number &&
-            date == other.date &&
-            language == other.language &&
-            common_text_twin == other.common_text_twin
-        end
-
-        private
-
-        def urn_date_segment
-          return nil unless date
-
-          date.month ? "#{date.month}/#{date.year}" : date.year.to_s
-        end
-      end
-    end
-  end
-end

data/lib/pubid/itu/identifiers/appendix_of_recommendation.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Itu
-    module Identifiers
-      # A labelled appendix of a Recommendation — "ITU-T G.101 App. I
-      # (05/2000)", "ITU-T G.722 (1988) App. IV (11/2006)".
-      #
-      # Structurally the twin of AnnexOfRecommendation: an appendix is
-      # published and dated separately from the Recommendation it appends, and
-      # may itself carry an amendment/errata ("ITU-T G.729 App. I (2002)
-      # Amd. 1"). The label is a Roman numeral rather than a series letter.
-      class AppendixOfRecommendation < Identifier
-        attribute :base, Identifier, polymorphic: true
-        # The appendix label ("I", "II", "IV"). Named `number` for symmetry
-        # with Supplement's ordinal and AnnexOfRecommendation's label; it
-        # shadows Identifier#number (code&.number), which is nil here anyway —
-        # the document number is reached via #root.
-        attribute :number, :string
-        # The companion artefact published under the appendix's designation:
-        # "test vectors" or "Software". Its own catalogue record, so it must
-        # stay distinct from the appendix itself.
-        attribute :material, :string
-
-        # Compact serialization: the nested (itself-flat) base plus this
-        # document's own label, date and language. sector/series/code belong to
-        # the base and are deliberately not re-emitted.
-        key_value do
-          map "_type", to: :_type
-          map "number", to: :number
-          map "material", to: :material
-          map "year", with: { to: :year_to_kv, from: :year_from_kv }
-          map "month", with: { to: :month_to_kv, from: :month_from_kv }
-          map "base", with: { to: :base_to_kv, from: :base_from_kv }
-          map "language", to: :language
-          map "common_text_twin",
-              with: { to: :common_text_twin_to_kv,
-                      from: :common_text_twin_from_kv }
-        end
-
-        # "<base urn>:appendix:<label>[:<date>]" — the appendix's own date must
-        # be there, or two editions of one appendix share a URN (the base's
-        # date rides inside base_urn, so omitting this one would be asymmetric).
-        def to_urn
-          segments = [base&.to_urn || "urn:itu", "appendix", number&.downcase]
-          # Without this the test-vector record and the appendix itself would
-          # share a URN.
-          segments << material.downcase.gsub(/[^a-z0-9]/, "") if material
-          segments << urn_date_segment
-          segments.compact.join(":")
-        end
-
-        def render_base(**opts)
-          result = base ? base.render_base(**opts) : "#{publisher}-#{sector}"
-
-          result += " App. #{number}"
-          result += " #{material}" if material
-          result + render_date_suffix
-        end
-
-        # MR: recurse into the appendixed document and append
-        # "app.<label>[.year]" (the documented supplement-suffix hook), so the
-        # slug stays distinct per appendix. Without it the wrapper's own nil
-        # sector/series/code would collapse every appendix onto "itu.<year>".
-        def mr_supplement_suffix
-          label = "#{number}#{material}".downcase.gsub(/[^a-z0-9]/, "")
-
-          ["app", label.empty? ? nil : label, date&.year].compact.join(".")
-        end
-
-        def ==(other)
-          return false unless other.instance_of?(self.class)
-
-          base == other.base &&
-            number == other.number &&
-            material == other.material &&
-            date == other.date &&
-            language == other.language &&
-            common_text_twin == other.common_text_twin
-        end
-
-        private
-
-        def urn_date_segment
-          return nil unless date
-
-          date.month ? "#{date.month}/#{date.year}" : date.year.to_s
-        end
-      end
-    end
-  end
-end

data/lib/pubid/itu/identifiers/errata.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Itu
-    module Identifiers
-      # Errata identifier (Err.)
-      # Pattern: "ITU-T G.9701 (2014) Err. 1 (07/2016)"
-      class Errata < Supplement
-        def to_s(**opts)
-          annotate_plain_render(render_supplement("Err."), **opts)
-        end
-      end
-    end
-  end
-end

data/lib/pubid/itu/identifiers/handbook.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Itu
-    module Identifiers
-      # ITU Handbook
-      # Format: ITU-{SECTOR} {NUMBER}.HDB
-      # Example: ITU-R 23.HDB
-      #
-      # Handbooks are companion publications keyed to a study-group number; the
-      # printed form is the number followed by the literal ".HDB" marker. There
-      # is no series and (in practice) no date.
-      class Handbook < Identifier
-        include StandardSerialization
-
-        def render_base(**_opts)
-          result = "#{publisher}-#{sector} #{code&.number}.HDB"
-
-          if date
-            result += if date.month
-                        " (#{date.month}/#{date.year})"
-                      else
-                        " (#{date.year})"
-                      end
-          end
-
-          result
-        end
-
-        def ==(other)
-          return false unless other.is_a?(Handbook)
-
-          sector == other.sector && code == other.code && date == other.date
-        end
-      end
-    end
-  end
-end