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

data/lib/pubid/gost/identifier.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Gost
-    # Base class for all GOST identifiers.
-    #
-    # GOST identifiers observed in the wild have the shape:
-    #
-    #   GOST [R ][<copublisher> ][<subtype> ]<number>[-<year>][/<adopted>][(<refs>)]
-    #
-    # Where /<adopted> is the IDT slash form (modeled by IdenticalAdoption)
-    # and (<refs>) is the parenthesized harmonization list (modeled by
-    # Harmonized). A bare InterstateStandard/NationalStandard has neither.
-    class Identifier < ::Pubid::Identifier
-      def self.parse(identifier)
-        parsed = Parser.parse(identifier)
-        Builder.build(parsed)
-      end
-
-      attribute :publisher,   :string, default: "GOST"
-      attribute :copublisher, :string
-      attribute :subtype,     :string
-      attribute :number,      :string
-      attribute :year,        :string
-
-      GOST_TYPE_MAP = {
-        "pubid:gost:interstate-standard" => "Pubid::Gost::Identifiers::InterstateStandard",
-        "pubid:gost:national-standard"   => "Pubid::Gost::Identifiers::NationalStandard",
-        "pubid:gost:identical-adoption"  => "Pubid::Gost::Identifiers::IdenticalAdoption",
-        "pubid:gost:harmonized"          => "Pubid::Gost::Identifiers::Harmonized",
-        "pubid:gost:foreign-reference"   => "Pubid::Gost::Identifiers::ForeignReference",
-      }.freeze
-
-      key_value do
-        map "_type",       to: :_type, polymorphic_map: GOST_TYPE_MAP
-        map "copublisher", to: :copublisher
-        map "subtype",     to: :subtype
-        map "number",      to: :number
-        map "year",        to: :year
-      end
-
-      def to_urn
-        UrnGenerator.new(self).generate
-      end
-    end
-  end
-end

data/lib/pubid/gost/identifiers/foreign_reference.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Gost
-    module Identifiers
-      # Foreign reference captured verbatim when no registered flavor can
-      # parse the adopted identifier (e.g. "OECD 460:2017",
-      # "UNECE STANDARD FFV-18:2011"). It preserves the raw surface form
-      # for round-trip rendering without modelling the foreign standard's
-      # internal structure. Quacks like Pubid::Identifier for rendering
-      # and serialization.
-      class ForeignReference < Identifier
-        attribute :raw, :string
-
-        def self.type
-          { key: :"foreign-reference", title: "Foreign Reference", short: nil }
-        end
-
-        def to_s(**_opts)
-          raw.to_s
-        end
-      end
-    end
-  end
-end

data/lib/pubid/gost/identifiers/harmonized.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Gost
-    module Identifiers
-      # Harmonized standard. The GOST has been officially aligned with,
-      # modified from, or adopted directly from one or more foreign
-      # (typically ISO/IEC) standards. The parenthesized form is the
-      # Russian/CIS garmonizatsiya convention.
-      #
-      # Examples:
-      #   ГОСТ 25346-2013 (ISO 286-1:2010)
-      #   ГОСТ 6032-2017 (ISO 3651-1:1998, ISO 3651-2:1998)
-      #   ГОСТ 6996-66 (ИСО 4136-89, ИСО 5173-81, ИСО 5177-81)
-      #
-      # One GOST may harmonize with multiple foreign standards at once.
-      # The slash form (IdenticalAdoption) is reserved for the strict IDT case.
-      class Harmonized < Identifier
-        attribute :base, ::Pubid::Gost::Identifier, polymorphic: true
-        attribute :adopted_identifiers, ::Pubid::Identifier,
-                  collection: true, polymorphic: true
-
-        key_value do
-          map "base",                to: :base
-          map "adopted_identifiers", to: :adopted_identifiers
-        end
-
-        def self.type
-          { key: :harmonized, title: "Harmonized Standard", short: nil }
-        end
-
-        def number; base&.number; end
-        def year; base&.year; end
-        def copublisher; base&.copublisher; end
-        def subtype; base&.subtype; end
-      end
-    end
-  end
-end

data/lib/pubid/gost/identifiers/identical_adoption.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Gost
-    module Identifiers
-      # Identical adoption (IDT per ISO Guide 2). The GOST is
-      # structurally and technically identical to the adopted
-      # foreign standard. The slash IS part of the official
-      # GOST designation.
-      #
-      # Examples:
-      #   ГОСТ 31610.18-2016/IEC 60079-18:2014
-      #   ГОСТ Р 58904-2020/ISO/TR 25901-1:2016
-      #   ГОСТ 31425.5-2025/ISO 9902-5:2001
-      #
-      # The MOD and NEQ degrees are NOT modeled here — they're
-      # bibliographic metadata (Relaton relations), not part of the
-      # identifier.
-      class IdenticalAdoption < Identifier
-        attribute :base, ::Pubid::Gost::Identifier, polymorphic: true
-        attribute :adopted, ::Pubid::Identifier, polymorphic: true
-
-        key_value do
-          map "base",    to: :base
-          map "adopted", to: :adopted
-        end
-
-        def self.type
-          { key: :"identical-adoption", title: "Identical Adoption", short: nil }
-        end
-
-        def number; base&.number; end
-        def year; base&.year; end
-        def copublisher; base&.copublisher; end
-        def subtype; base&.subtype; end
-      end
-    end
-  end
-end

data/lib/pubid/gost/identifiers/interstate_standard.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Gost
-    module Identifiers
-      # ГОСТ (bare) — interstate standard. Issued by МГС
-      # (Межгосударственный совет по стандартизации).
-      #
-      # Examples:
-      #   ГОСТ 14946-82           (dated)
-      #   ГОСТ 2.312              (undated)
-      #   ГОСТ ISO 9692-1         (copublisher + part, undated)
-      class InterstateStandard < Identifier
-        def self.type
-          { key: :"interstate-standard", title: "Interstate Standard", short: nil }
-        end
-      end
-    end
-  end
-end

data/lib/pubid/gost/identifiers/national_standard.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Gost
-    module Identifiers
-      # ГОСТ Р — Russian national standard. Issued by Росстандарт.
-      #
-      # Examples:
-      #   ГОСТ Р 71039-2023                   (dated)
-      #   ГОСТ Р МЭК 60794-1-23-2017         (copublisher, dated)
-      #   ГОСТ Р ИСО/МЭК МФС 10609-9-95      (compound copublisher + subtype)
-      class NationalStandard < Identifier
-        def self.type
-          { key: :"national-standard", title: "National Standard", short: "R" }
-        end
-      end
-    end
-  end
-end

data/lib/pubid/gost/identifiers.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Gost
-    module Identifiers
-      autoload :InterstateStandard, "#{__dir__}/identifiers/interstate_standard"
-      autoload :NationalStandard,   "#{__dir__}/identifiers/national_standard"
-      autoload :IdenticalAdoption,  "#{__dir__}/identifiers/identical_adoption"
-      autoload :Harmonized,         "#{__dir__}/identifiers/harmonized"
-      autoload :ForeignReference,   "#{__dir__}/identifiers/foreign_reference"
-    end
-  end
-end

data/lib/pubid/gost/parser.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-require "parslet"
-
-module Pubid
-  module Gost
-    # Parslet grammar for GOST identifiers.
-    #
-    # Accepts the Latin and Cyrillic surface forms observed in the wild:
-    #
-    #   ГОСТ 14946-82                       (interstate, dated)
-    #   ГОСТ 2.312                          (interstate, undated)
-    #   ГОСТ Р 71039— 2023                  (national, em-dash + space)
-    #   ГОСТ ISO 9692-1                     (copublisher, undated)
-    #   ГОСТ Р МЭК 60794-1-23-2017          (Cyrillic copublisher)
-    #   ГОСТ Р ИСО/МЭК МФС 10609-9-95      (compound copublisher + subtype)
-    #   ГОСТ ISO Guide 30-2019              (copublisher + subtype "Guide")
-    #   ГОСТ Р 58904-2020/ISO/TR 25901-1:2016  (IDT adoption, slash form)
-    #
-    # The parser captures three atoms:
-    #   * :scope_r     — "R"/"Р" if Russian national, nil if interstate
-    #   * :prefix_text — everything between scope_r and the number
-    #                     (copublisher, subtype, or both) as a raw string
-    #   * :raw         — digit runs separated by dots/dashes (number+year)
-    #   * :adopted_raw — the foreign identifier after "/" (IDT adoption)
-    #
-    # The builder interprets prefix_text (splits copublisher vs subtype,
-    # normalizes Cyrillic to Latin) and raw (splits number vs year).
-    class Parser < ::Pubid::Parser::Grammar
-      include ::Pubid::Parser::CommonParseRules
-
-      root :identifier
-
-      rule(:space)  { str(" ") }
-      rule(:space?) { space.maybe }
-      rule(:dot)    { str(".") }
-
-      rule(:year_sep) do
-        (str("-") | str("—") | str("–")) >> space?.maybe
-      end
-
-      rule(:gost_word) do
-        (str("GOST") | str("ГОСТ")).as(:gost_word) >> space
-      end
-
-      rule(:scope_r) do
-        (match("R") | match("Р")).as(:scope_r) >> space
-      end
-
-      # Everything between scope_r and the first digit: copublisher,
-      # subtype, or both. Captured as a raw string — the builder splits
-      # it into copublisher + subtype. Matches uppercase letters (Latin
-      # and Cyrillic), forward slashes, and spaces between words.
-      rule(:prefix_text) do
-        (match("[A-ZА-Яa-zа-я/]").repeat(1) >>
-          (space >> match("[A-ZА-Яa-zа-я/]").repeat(1)).repeat).as(:prefix_text) >> space
-      end
-
-      rule(:digits) do
-        match("[0-9]").repeat(1)
-      end
-
-      rule(:raw_body) do
-        (digits >> ((dot | year_sep) >> digits).repeat).as(:raw)
-      end
-
-      # IDT adoption suffix: "/<foreign-identifier>". The slash is
-      # consumed but NOT captured — only the foreign identifier text
-      # goes into :adopted_raw. Captures everything after the first
-      # slash, including subsequent slashes (the adopted identifier
-      # may itself contain slashes, e.g. "ISO/TR 25901-1:2016").
-      rule(:adopted_part) do
-        space?.maybe >> str("/") >> match(".").repeat(1).as(:adopted_raw)
-      end
-
-      # Adoption reference in parens: "(<foreign-id>)". The parens
-      # themselves are consumed but NOT captured. The content goes
-      # into :adopted_reference_raw. This form appears for MOD/NEQ
-      # adoptions where the foreign standard is referenced but not
-      # identical (IDT would use the slash form instead).
-      rule(:adopted_reference_part) do
-        space?.maybe >> str("(") >> match("[^)]").repeat(1).as(:adopted_reference_raw) >> str(")")
-      end
-
-      rule(:identifier) do
-        gost_word >> scope_r.maybe >> prefix_text.maybe >> raw_body >>
-          adopted_part.maybe >> adopted_reference_part.maybe
-      end
-
-      def self.parse(string)
-        unless string.is_a?(String)
-          raise ::Pubid::Errors::InvalidInputError,
-                ::Pubid::INPUT_NOT_A_STRING_MESSAGE
-        end
-
-        if string.length > ::Pubid::MAX_INPUT_LENGTH
-          raise ::Pubid::Errors::InvalidInputError,
-                ::Pubid::INPUT_TOO_LONG_MESSAGE
-        end
-
-        new.parse(string.strip)
-      end
-    end
-  end
-end

data/lib/pubid/gost/renderer.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Gost
-    # Human-readable renderer for GOST identifiers.
-    #
-    # Produces canonical Latin-script citations:
-    #   "GOST 14946-82"
-    #   "GOST R 34.12-2015"
-    #   "GOST ISO 9692-1"
-    #   "GOST R ISO/IEC ISP 10609-9-95"
-    #   "GOST R 58904-2020/ISO/TR 25901-1:2016"
-    class Renderer < ::Pubid::Renderers::Base
-      def render(context: nil, **_opts)
-        id = @id
-
-        return render_harmonized(id) if id.is_a?(Identifiers::Harmonized)
-        return render_identical_adoption(id) if id.is_a?(Identifiers::IdenticalAdoption)
-        return render_standard(id)
-
-        raise ArgumentError, "Unknown GOST identifier class: #{id.class}"
-      end
-
-      private
-
-      def render_standard(id)
-        rendered = +"GOST"
-        rendered << " R" if id.is_a?(Identifiers::NationalStandard)
-        rendered << " #{id.copublisher}" if id.copublisher
-        rendered << " #{id.subtype}" if id.subtype
-        rendered << " #{id.number}"
-        rendered << "-#{id.year}" if id.year
-        rendered
-      end
-
-      def render_identical_adoption(id)
-        +"#{id.base.to_s}/#{id.adopted.to_s}"
-      end
-
-      def render_harmonized(id)
-        rendered = +id.base.to_s
-        adopted = id.adopted_identifiers&.map(&:to_s)&.join(", ")
-        rendered << " (#{adopted})" unless adopted.nil? || adopted.empty?
-        rendered
-      end
-    end
-  end
-end

data/lib/pubid/gost/urn_generator.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Gost
-    # Generates URN strings for GOST identifiers.
-    #
-    # Format:
-    #   urn:gost:std:<number>[:<year>]              (interstate)
-    #   urn:gost:std:r:<number>[:<year>]            (Russian national)
-    #   urn:gost:std:r:<number>[:<year>]            (IdenticalAdoption delegates to base)
-    class UrnGenerator
-      attr_reader :identifier
-
-      def initialize(identifier)
-        @identifier = identifier
-      end
-
-      def generate
-        id = identifier
-        while id.is_a?(Identifiers::Harmonized) || id.is_a?(Identifiers::IdenticalAdoption)
-          id = id.base
-        end
-
-        return generate_for_standard(id) if standard?(id)
-
-        raise ArgumentError,
-              "Unknown GOST identifier class: #{identifier.class}"
-      end
-
-      private
-
-      def generate_for_standard(id)
-        parts = ["urn:gost:std"]
-        parts << "r" if id.is_a?(Identifiers::NationalStandard)
-        parts << id.number.to_s
-        parts << id.year.to_s if id.year
-        parts.join(":")
-      end
-
-      def standard?(id)
-        id.is_a?(Identifiers::InterstateStandard) ||
-          id.is_a?(Identifiers::NationalStandard)
-      end
-    end
-  end
-end

data/lib/pubid/gost/urn_parser.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Gost
-    # Parses GOST URNs back into identifiers.
-    #
-    # UrnGenerator emits:
-    #   urn:gost:std:<number>[:<year>]              (interstate)
-    #   urn:gost:std:r:<number>[:<year>]            (Russian national)
-    #
-    # Examples:
-    #   urn:gost:std:14946:82           → GOST 14946-82
-    #   urn:gost:std:r:34.12:2015       → GOST R 34.12-2015
-    class UrnParser < Pubid::UrnParser::Base
-      PREFIX = "urn:gost:std:".freeze
-
-      def parse_urn(urn)
-        body = strip_namespace(urn)
-        parts = split_parts(body)
-
-        if parts.first == "r"
-          number = parts[1]
-          year = parts[2]
-          Identifiers::NationalStandard.new(number: number, year: year)
-        else
-          number = parts[0]
-          year = parts[1]
-          Identifiers::InterstateStandard.new(number: number, year: year)
-        end
-      end
-
-      private
-
-      def strip_namespace(urn)
-        unless urn.downcase.start_with?(PREFIX)
-          raise Pubid::UrnParser::Errors::ParseError,
-                "Invalid GOST URN: #{urn.inspect}"
-        end
-
-        urn[PREFIX.length..]
-      end
-
-      def split_parts(body)
-        parts = body.split(":")
-        raise Pubid::UrnParser::Errors::ParseError,
-              "GOST URN missing number: #{body.inspect}" if parts.empty?
-
-        parts
-      end
-    end
-  end
-end

data/lib/pubid/gost.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Gost
-    extend Pubid::PrefixesSupport
-
-    # Leading identifier tokens that a GOST document id can start with.
-    # Latin "GOST" and Cyrillic "ГОСТ" are both official; "R" (Russian
-    # national, e.g. "GOST R 34.12-2015") routes to this flavor too.
-    PREFIXES = ["GOST", "ГОСТ"].freeze
-
-    autoload :Builder,      "#{__dir__}/gost/builder"
-    autoload :Identifier,   "#{__dir__}/gost/identifier"
-    autoload :Identifiers,  "#{__dir__}/gost/identifiers"
-    autoload :Parser,       "#{__dir__}/gost/parser"
-    autoload :Renderer,     "#{__dir__}/gost/renderer"
-    autoload :UrnGenerator, "#{__dir__}/gost/urn_generator"
-    autoload :UrnParser,    "#{__dir__}/gost/urn_parser"
-
-    # Parse a GOST identifier string into an identifier object.
-    # @param identifier [String]
-    # @return [Pubid::Gost::Identifier]
-    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: Gost::Renderer)
-
-    # Auto-discover identifier types from the Identifiers namespace.
-    # @return [Array<Class>]
-    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 }
-        .reject { |c| c == Identifier }
-    end
-
-    # Lookup: type key → identifier class
-    # @param code [String, Symbol]
-    # @return [Class, nil]
-    def self.locate_type(code)
-      identifier_types.find { |t| t.type[:key].to_s == code.to_s }
-    end
-  end
-end
-
-Pubid::Registry.register(:gost, Pubid::Gost)

data/lib/pubid/iala/builder.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Iala
-    # Builds an IALA identifier object from the Parslet parse tree.
-    class Builder
-      def build(parsed)
-        hash = parsed
-
-        return build_annex(hash) if hash[:annex_marker]
-
-        type_letter = stringify(hash[:type_letter])&.upcase
-        klass = Iala.identifier_klass_for_type_letter(type_letter)
-
-        attrs = {
-          number:   build_number(hash, klass),
-          edition:  stringify(hash.dig(:edition, :edition_value)),
-          language: stringify(hash.dig(:language_group, :language))&.upcase,
-        }.compact
-
-        klass.new(**attrs)
-      end
-
-      def self.build(parsed)
-        new.build(parsed)
-      end
-
-      private
-
-      # Build the Annex wrapper from the parse tree. The base sub-tree
-      # (captured under :base) is recursively built via the same logic as
-      # a flat identifier, then wrapped.
-      def build_annex(hash)
-        base_hash = hash[:base]
-        base_type = stringify(base_hash[:type_letter])&.upcase
-        base_klass = Iala.identifier_klass_for_type_letter(base_type)
-        base = base_klass.new(number: build_number(base_hash, base_klass))
-
-        attrs = {
-          base: base,
-          annex_form:      stringify(hash[:annex_marker]),
-          letter:          stringify(hash[:annex_letter]),
-          edition:         stringify(hash.dig(:edition, :edition_value)),
-          language:        stringify(hash.dig(:language_group, :language))&.upcase,
-        }.compact
-
-        Identifiers::Annex.new(**attrs)
-      end
-
-      # Compose the full number string from the leading doc_number plus any
-      # dotted continuation (GA01.13 → "01.13", L2.1.11 → "2.1.11") plus
-      # the optional dash-separated subpart (C0103-1 → "0103-1", L2.7.1-2
-      # → "2.7.1-2"). Padding is class-driven: the resolved identifier
-      # class declares its canonical IALA cover-page widths via
-      # `canonical_number_width` / `canonical_dotted_segment_width`, so a
-      # new type declares its padding on its own class instead of editing
-      # this builder's case statement.
-      def build_number(hash, klass)
-        base = stringify(hash[:doc_number])
-        return base unless base
-
-        base = canonical_base(base, klass)
-
-        dots = hash[:doc_number_dots]
-        dots_str = dots.is_a?(Array) ? "" : canonical_dots(stringify(dots).to_s, klass)
-
-        subpart_str = hash[:subpart] ? "-#{subpart_to_s(hash[:subpart])}" : ""
-        subpart_str = "" if subpart_str == "-"
-        "#{base}#{dots_str}#{subpart_str}"
-      end
-
-      def canonical_base(base, klass)
-        width = klass&.canonical_number_width
-        width ? base.rjust(width, "0") : base
-      end
-
-      def canonical_dots(str, klass)
-        return "" if str.empty?
-
-        width = klass&.canonical_dotted_segment_width
-        return str unless width
-
-        str.split(".", -1).map { |seg| seg.empty? ? seg : seg.rjust(width, "0") }.join(".")
-      end
-
-      # The subpart capture may be an array of {subpart_number: "1"},
-      # {subpart_number: "9"}, … (repeated matches). Join with "-".
-      def subpart_to_s(subpart)
-        return stringify(subpart).to_s unless subpart.is_a?(Array)
-
-        subpart.filter_map { |h| h.is_a?(Hash) ? stringify(h[:subpart_number]) : nil }.join("-")
-      end
-
-      def stringify(value)
-        return nil if value.nil?
-
-        str = value.to_s
-        str.empty? ? nil : str
-      end
-    end
-  end
-end