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

data/lib/pubid/doi/identifier.rb

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

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

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

data/lib/pubid/doi/parser.rb

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

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

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

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

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

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

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

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

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

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

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

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

data/lib/pubid/easc.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module Pubid
-  module Easc
-    extend Pubid::PrefixesSupport
-
-    # Leading identifier tokens that an EASC document id can start with.
-    # Both Cyrillic (canonical — ПМГ, РМГ) and Latin transliterations
-    # (PMG, RMG) are accepted; the canonical render is Cyrillic per
-    # mgscatalog.by convention.
-    PREFIXES = ["ПМГ", "РМГ", "PMG", "RMG"].freeze
-
-    autoload :Builder,      "#{__dir__}/easc/builder"
-    autoload :Identifier,   "#{__dir__}/easc/identifier"
-    autoload :Identifiers,  "#{__dir__}/easc/identifiers"
-    autoload :Parser,       "#{__dir__}/easc/parser"
-    autoload :Renderer,     "#{__dir__}/easc/renderer"
-    autoload :UrnGenerator, "#{__dir__}/easc/urn_generator"
-    autoload :UrnParser,    "#{__dir__}/easc/urn_parser"
-
-    # @param identifier [String]
-    # @return [Pubid::Easc::Identifier]
-    def self.parse(identifier)
-      Identifier.parse(identifier)
-    end
-
-    # Per-flavor format registry.
-    Identifier.format_registry = FormatRegistry.new(parent: ::Pubid::Identifier.format_registry)
-    Identifier.format_registry.register(:human, renderer: Easc::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: series (ПМГ / РМГ / PMG / RMG) → identifier class
-    # @param series [String, Symbol]
-    # @return [Class<Identifier>, nil]
-    def self.identifier_klass_for_series(series)
-      @by_series ||= identifier_types.to_h do |klass|
-        [klass.type[:series].to_s, klass]
-      end
-      @by_series[series.to_s] || @by_series[series.to_s.upcase]
-    end
-  end
-end
-
-Pubid::Registry.register(:easc, Pubid::Easc)