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

data/lib/pubid/gb.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Pubid
+  # Chinese Standard (GB) flavor.
+  #
+  # Covers national (GB), sector/industry (DB, QB, ZB, HB, JB, NY, YY, HJ,
+  # CJ, JG, MH, SL, DL, TB, TD, ...) and social-group (T/{ORG}) standards
+  # issued under the Chinese standards system. The mandate category is
+  # carried after a slash: T (recommended), Z (guideline), or omitted
+  # (mandatory).
+  module Gb
+    extend Pubid::PrefixesSupport
+
+    # Leading tokens a printed Chinese Standard identifier may start with.
+    # Used by relaton to route reference strings to this flavor. National
+    # "GB" comes first so PrefixesSupport's longest-match wins.
+    PREFIXES = %w[
+      GB GB/T GB/Z
+      DB DB/T DB/Z
+      QB QB/T
+      ZB ZB/T
+      HB HB/T
+      JB JB/T
+      NY NY/T
+      YY YY/T
+      HJ HJ/T
+      CJ CJ/T
+      JG JG/T
+      MH MH/T
+      SL SL/T
+      DL DL/T
+      TB TB/T
+      TD TD/T
+      T/
+    ].freeze
+
+    autoload :Builder, "#{__dir__}/gb/builder"
+    autoload :Identifier, "#{__dir__}/gb/identifier"
+    autoload :Identifiers, "#{__dir__}/gb/identifiers"
+    autoload :Parser, "#{__dir__}/gb/parser"
+    autoload :Renderer, "#{__dir__}/gb/renderer"
+
+    # Parse a Chinese Standard identifier string.
+    # @param identifier [String] e.g. "GB/T 20223-2006"
+    # @return [Pubid::Gb::Identifier]
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    end
+
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Gb::Renderer)
+
+    # Auto-discover concrete identifier types.
+    # @return [Array<Class>]
+    def self.identifier_types
+      @identifier_types ||= Identifiers.constants
+        .filter_map do |c| 
+        
+        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 do |s| 
+        s.abbr.any? do |a|
+          a.to_s.upcase == abbr_str
+        end
+      end
+    end
+  end
+end
+
+Pubid::Registry.register(:gb, Pubid::Gb)

data/lib/pubid/gost/builder.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Gost
+    # Builds a GOST identifier object from the Parslet parse tree.
+    class Builder
+      NUMBER_YEAR_SPLIT = /\A(.+?)\s*[-—–]\s*(\d{2}|\d{4})\z/.freeze
+
+      # Cyrillic → Latin copublisher normalization. Compound forms
+      # (with /) are included.
+      COPUBLISHER_MAP = {
+        "ИСО" => "ISO", "МЭК" => "IEC", "ЕН" => "EN",
+        "ИСО/МЭК" => "ISO/IEC", "МЭК/ИСО" => "IEC/ISO",
+        "ИСО/ТУ" => "ISO/TS", "ИСО/ТО" => "ISO/TR",
+        "МЭК/ТУ" => "IEC/TS", "МЭК/ТО" => "IEC/TR",
+        "ИСО/МЭК/ТУ" => "ISO/IEC/TS",
+      }.freeze
+
+      # Cyrillic → Latin subtype normalization.
+      SUBTYPE_MAP = {
+        "МФС" => "ISP",
+        "ТУ" => "TS", "ТО" => "TR",
+      }.freeze
+
+      def build(parsed)
+        base = build_base(parsed)
+        with_foreign_adoption(base, parsed)
+      end
+
+      def self.build(parsed)
+        new.build(parsed)
+      end
+
+      private
+
+      def build_base(parsed)
+        russian = parsed[:scope_r] ? true : false
+        copublisher, subtype = split_prefix(stringify(parsed[:prefix_text]))
+        number, year = split_number_year(stringify(parsed[:raw]))
+
+        klass = russian ? Identifiers::NationalStandard : Identifiers::InterstateStandard
+        klass.new(**{
+          copublisher: copublisher,
+          subtype: subtype,
+          number: number,
+          year: year,
+        }.compact)
+      end
+
+      # Apply the slash (IdenticalAdoption) and/or parens (Harmonized)
+      # wrappers around the base standard. Both can apply simultaneously.
+      def with_foreign_adoption(base, parsed)
+        wrapper = wrap_identical_adoption(base, parsed)
+        wrap_harmonized(wrapper, parsed)
+      end
+
+      def wrap_identical_adoption(base, parsed)
+        adopted_raw = stringify(parsed[:adopted_raw])
+        return base unless adopted_raw
+
+        adopted = parse_foreign(adopted_raw)
+        Identifiers::IdenticalAdoption.new(base: base, adopted: adopted)
+      end
+
+      def wrap_harmonized(base, parsed)
+        reference_raw = stringify(parsed[:adopted_reference_raw])
+        return base unless reference_raw
+
+        items = reference_raw.split(",").map(&:strip).map { |s| normalize_foreign(s) }
+        adopted = items.map { |item| adopt_identifier(item) }
+
+        Identifiers::Harmonized.new(base: base, adopted_identifiers: adopted)
+      end
+
+      # Parse a single foreign identifier, falling back to a
+      # ForeignReference that preserves the raw surface form when no
+      # registered flavor recognizes it (e.g. OECD, UNECE STANDARD).
+      def adopt_identifier(raw)
+        parse_foreign(raw) || Identifiers::ForeignReference.new(raw: raw)
+      end
+
+      def split_prefix(text)
+        return [nil, nil] unless text
+
+        tokens = text.strip.split(/\s+/)
+        copublisher_raw = tokens.first
+        subtype_raw = tokens.size > 1 ? tokens.drop(1).join(" ") : nil
+
+        [normalize_copublisher(copublisher_raw), normalize_subtype(subtype_raw)]
+      end
+
+      def normalize_copublisher(raw)
+        return nil unless raw
+        COPUBLISHER_MAP.fetch(raw) { raw.upcase }
+      end
+
+      def normalize_subtype(raw)
+        return nil unless raw
+        SUBTYPE_MAP.fetch(raw) { raw }
+      end
+
+      # Normalize a leading Cyrillic publisher token (e.g. "ИСО") to its
+      # Latin equivalent so a foreign parser can recognize it. Longest
+      # keys first so "ИСО/МЭК" wins over "ИСО".
+      def normalize_foreign(raw)
+        COPUBLISHER_MAP.keys.sort_by(&:length).reverse.each do |cyr|
+          next unless raw.start_with?(cyr + " ") || raw.start_with?(cyr + "/")
+
+          return COPUBLISHER_MAP[cyr] + raw[cyr.length..]
+        end
+        raw
+      end
+
+      def split_number_year(raw)
+        return [raw, nil] unless raw
+
+        m = raw.match(NUMBER_YEAR_SPLIT)
+        return [raw, nil] unless m
+
+        [m[1], m[2]]
+      end
+
+      # Try every registered flavor (other than GOST itself) as a parser
+      # for a foreign adopted identifier. Returns the first successful
+      # parse, or nil if none recognize the string.
+      def parse_foreign(raw)
+        ::Pubid.eager_load_flavors!
+        ::Pubid::Registry.flavors.each_value do |mod|
+          next if mod == ::Pubid::Gost
+
+          begin
+            return mod.parse(raw)
+          rescue StandardError
+            next
+          end
+        end
+        nil
+      end
+
+      def stringify(value)
+        return nil if value.nil?
+
+        str = value.to_s
+        str.empty? ? nil : str
+      end
+    end
+  end
+end

data/lib/pubid/gost/identifier.rb

@@ -0,0 +1,49 @@
+# 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)
+      rescue Parslet::ParseFailed => e
+        raise "Failed to parse GOST identifier '#{identifier}': #{e.message}"
+      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

@@ -0,0 +1,25 @@
+# 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
+          raw.to_s
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

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

@@ -0,0 +1,97 @@
+# 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 < Parslet::Parser
+      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)
+        raise ArgumentError, ::Pubid::INPUT_TOO_LONG_MESSAGE if string.length > ::Pubid::MAX_INPUT_LENGTH
+
+        new.parse(string.strip)
+      end
+    end
+  end
+end

data/lib/pubid/gost/renderer.rb

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

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

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