pubid 1.15.21 → 2.0.0.alpha.10

data/lib/pubid/doi/builder.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Doi
+    class Builder
+      def self.build(parsed_data)
+        new.build(parsed_data)
+      end
+
+      def build(data)
+        Identifiers::Resource.new(
+          prefix: "10.#{data[:prefix]}",
+          suffix: data[:suffix].to_s,
+        )
+      end
+    end
+  end
+end

data/lib/pubid/doi/identifier.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Doi
+    class Identifier < ::Pubid::Identifier
+      # The DOI prefix: "10." + registrar code, e.g. "10.1000", "10.6028".
+      attribute :prefix, :string
+
+      # The DOI suffix: arbitrary printable string with no whitespace. May
+      # contain slashes (e.g. "NIST.2022-04-15.001").
+      attribute :suffix, :string
+
+      DOI_TYPE_MAP = {
+        "pubid:doi:resource" => "Pubid::Doi::Identifiers::Resource",
+      }.freeze
+
+      key_value do
+        map "_type", to: :_type, polymorphic_map: DOI_TYPE_MAP
+        map "prefix", to: :prefix
+        map "suffix", to: :suffix
+      end
+
+      PUBLISHER = "DOI"
+
+      # The numeric registrar subcode (e.g. "1000" for prefix "10.1000").
+      def registrar
+        prefix.to_s.sub(/\A10\./, "") unless prefix.to_s.empty?
+      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
+
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      end
+    end
+  end
+end

data/lib/pubid/doi/identifiers/resource.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Doi
+    module Identifiers
+      # Concrete DOI identifier type.
+      #
+      # Examples:
+      #   doi:10.1000/182
+      #   10.6028/NIST.2022-04-15.001
+      #   https://doi.org/10.1006/jmbi.1998.2354
+      class Resource < Identifier
+        TYPED_STAGES = [
+          Pubid::Components::TypedStage.new(
+            code: :pubdoi,
+            stage_code: :published,
+            type_code: :doi,
+            abbr: ["DOI"],
+            name: "DOI",
+            harmonized_stages: [],
+          ),
+        ].freeze
+
+        def self.type
+          { key: :doi, web: :doi, title: "DOI", short: "DOI" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/doi/identifiers.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Doi
+    module Identifiers
+      autoload :Resource, "#{__dir__}/identifiers/resource"
+    end
+  end
+end

data/lib/pubid/doi/parser.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Doi
+    # Parslet grammar for Digital Object Identifiers per ISO 26324.
+    #
+    # Accepts:
+    #   [doi:|DOI:]10.{REGISTRAR}/{SUFFIX}
+    #   https://doi.org/10.{REGISTRAR}/{SUFFIX}
+    #
+    # SUFFIX is one-or-more chars from [A-Za-z0-9._\-/()] (printable minus
+    # whitespace). The grammar is intentionally permissive on suffix chars
+    # because real DOIs cover the full printable range.
+    class Parser < ::Pubid::Parser::Grammar
+      rule(:dot)   { str(".") }
+      rule(:slash) { str("/") }
+
+      # Optional URL resolver prefix.
+      rule(:url_prefix) { (str("https://") | str("http://")).maybe >> str("doi.org").maybe }
+
+      # Optional DOI scheme prefix.
+      rule(:scheme_prefix) do
+        (str("doi:") | str("DOI:") | str("Doi:")).maybe
+      end
+
+      # Prefix: "10." then 2+ registrar digits.
+      rule(:prefix) { str("10") >> dot >> match("[0-9]").repeat(2).as(:prefix) }
+
+      # Suffix: at least one printable non-whitespace char (DOI Handbook §2.2).
+      rule(:suffix) { match("[A-Za-z0-9._\\-/()]").repeat(1).as(:suffix) }
+
+      rule(:identifier) do
+        url_prefix.maybe >>
+          scheme_prefix.maybe >>
+          slash.maybe >>
+          prefix >> slash >> suffix
+      end
+
+      rule(:root) { identifier }
+
+      def self.parse(input)
+        # Normalize a URL resolver form to bare form before parsing. The
+        # parser's `url_prefix.maybe >> scheme_prefix.maybe >> slash.maybe`
+        # chain also handles this in-grammar, but pre-stripping yields a
+        # cleaner error message for malformed URLs.
+        new.parse(input)
+      end
+    end
+  end
+end

data/lib/pubid/doi/renderer.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Doi
+    # Human-readable renderer for DOIs. Produces the canonical "doi:PREFIX/SUFFIX"
+    # form (RFC 5650 §2).
+    class Renderer < ::Pubid::Renderers::Base
+      def render(**_opts)
+        "doi:#{@id.prefix}/#{@id.suffix}"
+      end
+    end
+  end
+end

data/lib/pubid/doi.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Pubid
+  # DOI (Digital Object Identifier) flavor.
+  #
+  # Parses the canonical DOI per ISO 26324:
+  #   doi:10.{REGISTRAR}/{SUFFIX}
+  #
+  # The optional URL form `https://doi.org/10.X/Y` is accepted; the resolver
+  # host is stripped before parsing.
+  module Doi
+    extend Pubid::PrefixesSupport
+
+    # Leading tokens a DOI string can start with. The bare "10." form is the
+    # canonical prefix per ISO 26324 §4.1.
+    PREFIXES = %w[doi: DOI: 10.].freeze
+
+    autoload :Builder, "#{__dir__}/doi/builder"
+    autoload :Identifier, "#{__dir__}/doi/identifier"
+    autoload :Identifiers, "#{__dir__}/doi/identifiers"
+    autoload :Parser, "#{__dir__}/doi/parser"
+    autoload :Renderer, "#{__dir__}/doi/renderer"
+
+    def self.parse(identifier)
+      Identifier.parse(identifier)
+    end
+
+    Identifier.format_registry = FormatRegistry.new(parent: Identifier.format_registry)
+    Identifier.format_registry.register(:human, renderer: Doi::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(:doi, Pubid::Doi)

data/lib/pubid/easc/builder.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Easc
+    # Builds an EASC identifier object from the Parslet parse tree.
+    class Builder
+      def build(parsed)
+        series_cyr = stringify(parsed[:series])&.upcase
+        canonical_series = series_to_canonical(series_cyr)
+        klass = Easc.identifier_klass_for_series(canonical_series) ||
+                Identifier
+        attrs = {
+          series:  canonical_series,
+          variant: variant_to_canonical(stringify(parsed[:variant])),
+          number:  stringify(parsed[:number]),
+          year:    stringify(parsed[:year]),
+        }.compact
+
+        klass.new(**attrs)
+      end
+
+      def self.build(parsed)
+        new.build(parsed)
+      end
+
+      private
+
+      # Map Cyrillic series to Latin canonical form (PMG/RMG). Latin
+      # input is preserved as-is (uppercased).
+      def series_to_canonical(series)
+        return nil unless series
+
+        case series
+        when "ПМГ", "PMG" then "PMG"
+        when "РМГ", "RMG" then "RMG"
+        else series
+        end
+      end
+
+      # Normalize variant marker to Latin "V" (regardless of script).
+      def variant_to_canonical(variant)
+        return nil unless variant
+
+        %w[В V].include?(variant.upcase) ? "V" : variant
+      end
+
+      def stringify(value)
+        return nil if value.nil?
+
+        str = value.to_s
+        str.empty? ? nil : str
+      end
+    end
+  end
+end

data/lib/pubid/easc/identifier.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Easc
+    # Base class for all EASC identifiers. Canonical name
+    # Pubid::Easc::Identifier; every concrete EASC identifier
+    # (Identifiers::*) descends from it.
+    #
+    # EASC identifiers have the form:
+    #   <series> [В ]<number>[-<year>]
+    #
+    # Where:
+    #   * <series> identifies the document class — ПМГ (Правила
+    #     межгосударственной стандартизации) or РМГ (Рекомендации по
+    #     межгосударственной стандартизации). Latin forms PMG/RMG are
+    #     also parsed; canonical render is Cyrillic per mgscatalog.by.
+    #   * the optional "В" (Cyrillic capital V) marks a defense-related
+    #     variant (e.g. "ПМГ В 31-2001"). Stored as `variant: "V"`
+    #     (Latin) for cross-script consistency.
+    #   * <number> is a digit run.
+    #   * <year> is 2 or 4 digits, separated by ASCII hyphen OR Unicode
+    #     em-dash / en-dash (Russian typographic convention).
+    #
+    # Examples:
+    #   ПМГ 03-2025
+    #   ПМГ В 31-2001
+    #   РМГ 151-2025
+    #   РМГ 29-2013
+    class Identifier < ::Pubid::Identifier
+      def self.parse(identifier)
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      end
+
+      attribute :publisher, :string, default: "EASC"
+      attribute :series,  :string    # "PMG" | "RMG" — Latin canonical
+      attribute :variant, :string    # "V" | nil
+      attribute :number,  :string    # "151", "03", "31"
+      attribute :year,    :string    # "2025", "13", nil
+
+      EASC_TYPE_MAP = {
+        "pubid:easc:pmg" => "Pubid::Easc::Identifiers::Pmg",
+        "pubid:easc:rmg" => "Pubid::Easc::Identifiers::Rmg",
+      }.freeze
+
+      key_value do
+        map "_type",   to: :_type, polymorphic_map: EASC_TYPE_MAP
+        map "series",  to: :series
+        map "variant", to: :variant
+        map "number",  to: :number
+        map "year",    to: :year
+      end
+
+      def to_urn
+        UrnGenerator.new(self).generate
+      end
+    end
+  end
+end

data/lib/pubid/easc/identifiers/pmg.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Easc
+    module Identifiers
+      # ПМГ — Правила по межгосударственной стандартизации
+      # (Rules on interstate standardization). Issued by EASC.
+      #
+      # Examples:
+      #   ПМГ 03-2025
+      #   ПМГ 126-2013
+      #   ПМГ В 31-2001           (defense variant)
+      class Pmg < Identifier
+        def self.type
+          { key: :pmg, title: "Interstate Rules", series: "PMG" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/easc/identifiers/rmg.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Easc
+    module Identifiers
+      # РМГ — Рекомендации по межгосударственной стандартизации
+      # (Recommendations on interstate standardization). Issued by EASC.
+      #
+      # Examples:
+      #   РМГ 151-2025
+      #   РМГ 29-2013
+      class Rmg < Identifier
+        def self.type
+          { key: :rmg, title: "Interstate Recommendations", series: "RMG" }
+        end
+      end
+    end
+  end
+end

data/lib/pubid/easc/identifiers.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Easc
+    module Identifiers
+      autoload :Pmg,  "#{__dir__}/identifiers/pmg"
+      autoload :Rmg,  "#{__dir__}/identifiers/rmg"
+    end
+  end
+end

data/lib/pubid/easc/parser.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "parslet"
+
+module Pubid
+  module Easc
+    # Parslet grammar for EASC identifiers.
+    #
+    # Accepts the Cyrillic surface forms observed in mgscatalog.by:
+    #
+    #   ПМГ 03-2025
+    #   ПМГ В 31-2001           (defense variant)
+    #   РМГ 151-2025
+    #   РМГ 29-2013
+    #
+    # Also accepts Latin transliterations (PMG, RMG, V) for
+    # round-tripping with English-language tooling. The renderer
+    # emits Cyrillic as the canonical form.
+    class Parser < ::Pubid::Parser::Grammar
+      include ::Pubid::Parser::CommonParseRules
+
+      root :identifier
+
+      rule(:space)  { str(" ") }
+      rule(:space?) { space.maybe }
+      rule(:dot)    { str(".") }
+
+      # Year separator: ASCII hyphen OR Unicode em-dash / en-dash,
+      # optionally surrounded by whitespace.
+      rule(:year_sep) do
+        space?.maybe >> (str("-") | str("—") | str("–")) >> space?.maybe
+      end
+
+      # Series prefix. Captured to route to the right Identifiers::*
+      # subclass (Pmg vs Rmg). Both Cyrillic and Latin forms.
+      rule(:series_word) do
+        (str("ПМГ") | str("РМГ") | str("PMG") | str("RMG")).as(:series) >> space
+      end
+
+      # Defense variant marker — Cyrillic "В" or Latin "V".
+      rule(:variant_word) do
+        (str("В") | str("V")).as(:variant) >> space
+      end
+
+      rule(:prefix) do
+        series_word >> variant_word.maybe
+      end
+
+      rule(:digits) do
+        match("[0-9]").repeat(1)
+      end
+
+      rule(:number) do
+        (digits >> (dot >> digits).repeat).as(:number)
+      end
+
+      rule(:year_2digit) do
+        match("[0-9]").repeat(2, 2)
+      end
+
+      rule(:year_4digit) do
+        match("[0-9]").repeat(4, 4)
+      end
+
+      rule(:year) do
+        (year_4digit | year_2digit).as(:year)
+      end
+
+      rule(:identifier) do
+        prefix >> number >> (year_sep >> year).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/easc/renderer.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Easc
+    # Human-readable renderer for EASC identifiers.
+    #
+    # Produces strings like:
+    #   "ПМГ 03-2025"
+    #   "ПМГ В 31-2001"      (defense variant)
+    #   "РМГ 151-2025"
+    #
+    # Always renders in Cyrillic — the canonical form used on
+    # mgscatalog.by. Latin transliterations (PMG, RMG, V) parse but
+    # render to Cyrillic.
+    class Renderer < ::Pubid::Renderers::Base
+      CYRILLIC_SERIES = {
+        "PMG" => "ПМГ",
+        "RMG" => "РМГ",
+      }.freeze
+
+      CYRILLIC_VARIANT = "В".freeze
+
+      def render(context: nil, **_opts)
+        id = @id
+
+        if id.is_a?(Identifiers::Pmg) || id.is_a?(Identifiers::Rmg)
+          return render_standard(id)
+        end
+
+        raise ArgumentError, "Unknown EASC identifier class: #{id.class}"
+      end
+
+      private
+
+      def render_standard(id)
+        rendered = +"#{cyrillic_series(id.series)}"
+        rendered << " #{CYRILLIC_VARIANT}" if id.variant == "V"
+        rendered << " #{id.number}"
+        rendered << "-#{id.year}" if id.year
+        rendered
+      end
+
+      def cyrillic_series(series)
+        CYRILLIC_SERIES.fetch(series, series)
+      end
+    end
+  end
+end

data/lib/pubid/easc/urn_generator.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Easc
+    # Generates URN strings for EASC identifiers.
+    #
+    # Format:
+    #   urn:easc:<series>[:<variant>]:<number>[:<year>]
+    #
+    # Examples:
+    #   urn:easc:pmg:3:2025
+    #   urn:easc:pmg:v:31:2001
+    #   urn:easc:rmg:151:2025
+    class UrnGenerator
+      attr_reader :identifier
+
+      def initialize(identifier)
+        @identifier = identifier
+      end
+
+      def generate
+        unless identifier.is_a?(Identifiers::Pmg) ||
+               identifier.is_a?(Identifiers::Rmg)
+          raise ArgumentError,
+                "Unknown EASC identifier class: #{identifier.class}"
+        end
+
+        parts = ["urn:easc", series_lower]
+        parts << variant_lower if identifier.variant
+        parts << identifier.number.to_s
+        parts << identifier.year.to_s if identifier.year
+        parts.join(":")
+      end
+
+      private
+
+      def series_lower
+        identifier.series.to_s.downcase
+      end
+
+      def variant_lower
+        identifier.variant.to_s.downcase
+      end
+    end
+  end
+end

data/lib/pubid/easc/urn_parser.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Pubid
+  module Easc
+    # Parses EASC URNs back into identifiers.
+    #
+    # UrnGenerator emits:
+    #   urn:easc:<series>[:<variant>]:<number>[:<year>]
+    #
+    # Examples:
+    #   urn:easc:pmg:3:2025           → ПМГ 3-2025
+    #   urn:easc:pmg:v:31:2001        → ПМГ В 31-2001
+    #   urn:easc:rmg:151:2025         → РМГ 151-2025
+    class UrnParser < Pubid::UrnParser::Base
+      PREFIX = "urn:easc:".freeze
+      VARIANT_SEGMENT = /\Av\z/i.freeze
+
+      def parse_urn(urn)
+        body = strip_namespace(urn)
+        parts = split_parts(body)
+        series = parts.fetch(0)
+        rest = parts.drop(1)
+
+        variant = nil
+        if rest.first&.match?(VARIANT_SEGMENT)
+          variant = "V"
+          rest = rest.drop(1)
+        end
+        number = rest[0]
+        year = rest[1]
+
+        klass = Easc.identifier_klass_for_series(series) || Identifier
+        klass.new(series: series.upcase, variant: variant,
+                  number: number, year: year)
+      end
+
+      private
+
+      def strip_namespace(urn)
+        unless urn.downcase.start_with?(PREFIX)
+          raise Pubid::UrnParser::Errors::ParseError,
+                "Invalid EASC URN: #{urn.inspect}"
+        end
+
+        urn[PREFIX.length..]
+      end
+
+      def split_parts(body)
+        parts = body.split(":")
+        raise Pubid::UrnParser::Errors::ParseError,
+              "EASC URN missing series: #{body.inspect}" if parts.empty?
+
+        parts
+      end
+    end
+  end
+end