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

data/lib/pubid/csa/identifier.rb

@@ -355,12 +355,12 @@ module Pubid
           end
 
           # Parse base identifier recursively
-          base_identifier = base_input ? parse(base_input) : nil
-          return nil unless base_identifier
+          base = base_input ? parse(base_input) : nil
+          return nil unless base
 
           # Create PackageIdentifier
           result = Identifiers::Package.new
-          result.base_identifier = base_identifier
+          result.base = base
           # Set materials if present
           if package_materials && !package_materials.empty?
             result.package_materials = package_materials
@@ -458,6 +458,51 @@ module Pubid
 
         nil
       end
+
+      # CSA stores the publication year in its own plain `year` string
+      # attribute (not a `Components::Date`), so the base `#exclude`'s
+      # `:year`->`:date` remap nils the unused inherited `date` and leaves
+      # `year` intact. Override to nil `year` (and its formatting metadata)
+      # when `:year`/`:date` is excluded, so a partial (year-less) CSA
+      # reference is a year wildcard under `matches?(row, ignore: [:year])`.
+      # The metadata attrs (`year_format`, `year_prefix`,
+      # `original_year_4digit`, `french`) are year-derived — a year-less
+      # parse leaves them nil/false, so they must be reset here too or `==`
+      # would still differ. `french` in particular is only ever set from a
+      # `:F` year prefix (the French-edition form `CSA B149.1:F20`), so a
+      # bare `CSA B149.1` reference must wildcard it to match both the
+      # English and French editions of a document number. `super` preserves
+      # the base recursion into nested identifiers (adoption wrappers
+      # delegate their year to an inner id and lack a `year` accessor, hence
+      # the `respond_to?` guard). Mirrors BIPM.
+      def exclude(*args)
+        result = super
+        year_keys = args & %i[year date]
+        if !year_keys.empty? && result.respond_to?(:year=)
+          result.year = nil
+          result.year_format = nil
+          result.year_prefix = nil
+          result.original_year_4digit = false
+          result.french = nil
+        end
+        result
+      end
+
+      # CSA encodes its identity across many shape-specific attributes
+      # (`publisher_prefix`, `code`, `no_number`, `series`, `series_prefix`,
+      # `package`, `reaffirmation`, `year` with prefix/format/French markers,
+      # etc.) that the generic MrString renderer doesn't know about. The
+      # CSA `to_s` already round-trips losslessly through the CSA parser, so
+      # MR mirrors it: ` ` → `.`, `:` → `.` (so the year never looks like
+      # another code segment), `/` → `-` (CAN/CSA- prefix), then lowercased
+      # to match the all-lowercase MR convention (issue #142).
+      def to_mr_string
+        to_s.tr(" ", ".").tr(":", ".").tr("/", "-").downcase
+      end
+
+      def to_slug
+        to_mr_string
+      end
     end
   end
 end

data/lib/pubid/csa/identifiers/bundled.rb

@@ -14,6 +14,12 @@ module Pubid
         }
         attribute :year_format, :string # Add for compatibility with identifier.rb
 
+        # CSA bundles are not Pubid::Identifier objects, so they do not inherit
+        # #root. They are their own origin for matching purposes.
+        def root
+          self
+        end
+
         def to_s
           # For Cec identifiers, use normalized form (code instead of cec_part + NO.)
           # This is used for "normalized form" rendering in bundled identifiers

data/lib/pubid/csa/identifiers/combined.rb

@@ -23,6 +23,12 @@ module Pubid
         attribute :year_format, :string # Dummy for compatibility
         attribute :separator, :string, default: -> { "/" } # "/" or ", "
 
+        # CSA combined ids are not Pubid::Identifier objects, so they do not
+        # inherit #root. They are their own origin for matching purposes.
+        def root
+          self
+        end
+
         def to_s
           # For comma separator, render both parts with full prefix
           # For slash separator, second/third parts without prefix

data/lib/pubid/csa/identifiers/package.rb

@@ -12,7 +12,7 @@ module Pubid
       #   CSA C22.2 NO. 60601-1:15 PACKAGE WITH ADDENDUM
       #
       # This is a composite pattern where:
-      #   - base_identifier is the core CSA standard (recursively parsed)
+      #   - base is the core CSA standard (recursively parsed)
       #   - package_materials describes what's included in the package
       #   - Package portion is metadata, not a parseable identifier
       #
@@ -34,7 +34,7 @@ module Pubid
         attribute :materials_after_keyword, :boolean, default: -> { true }
 
         def to_s
-          result = base_identifier.to_s
+          result = base.to_s
 
           # Add package materials if present
           if package_materials && !package_materials.empty?

data/lib/pubid/csa/parser.rb

@@ -179,7 +179,7 @@ module Pubid
           # Optional series prefix (MH, RV, etc.) before SERIES keyword
           (series_prefix >> space).maybe >>
           series_keyword.as(:series_type) >>
-          (colon_year | dash_year) >>
+          (colon_year | dash_year).maybe >>
           reaffirmation.maybe
       end
 
@@ -194,7 +194,7 @@ module Pubid
           ).as(:cec_part) >>
           no_notation >>
           no_number >>
-          (colon_year | dash_year) >>
+          (colon_year | dash_year).maybe >>
           reaffirmation.maybe
       end
 
@@ -257,7 +257,7 @@ module Pubid
             (space >> series_keyword.as(:series) >> (colon_year | dash_year)) |
             # Option 4: just year (no series, no NO.)
             (colon_year | dash_year)
-          ) >>
+          ).maybe >> # trailing year optional (partial reference)
           amendment_slash.maybe # Add amendment support here
       end
 
@@ -274,7 +274,7 @@ module Pubid
             (space >> series_keyword.as(:series) >> (colon_year | dash_year)) |
             # Option 4: just year
             (colon_year | dash_year)
-          )
+          ).maybe # trailing year optional (partial reference)
       end
 
       # Continuation code (optional CSA publisher prefix, for combined identifiers)
@@ -290,7 +290,7 @@ module Pubid
             (space >> series_keyword.as(:series) >> (colon_year | dash_year)) |
             # Option 4: just year
             (colon_year | dash_year)
-          ) >>
+          ).maybe >> # trailing year optional (partial reference)
           amendment_slash.maybe
       end
 
@@ -353,7 +353,7 @@ module Pubid
             (space >> series_keyword.as(:series) >> (colon_year | dash_year)) |
             # Option 3: just year
             (colon_year | dash_year)
-          ) >>
+          ).maybe >> # trailing year optional (partial reference)
           (space >> str("PACKAGE")).as(:package_portion).maybe
       end
 

data/lib/pubid/csa/wrapper_identifier.rb

@@ -26,6 +26,23 @@ module Pubid
       def to_s
         raise NotImplementedError, "Subclasses must implement to_s method"
       end
+
+      # CSA wrappers serialise through `to_s` (their distinct shape is what
+      # makes them wrappers), so MR mirrors that with ` ` → `.`, `:` → `.`,
+      # `/` → `-`, then lowercased (issue #142).
+      def to_mr_string
+        to_s.tr(" ", ".").tr(":", ".").tr("/", "-").downcase
+      end
+
+      def to_slug
+        to_mr_string
+      end
+
+      # CSA wrappers are not Pubid::Identifier objects, so they do not inherit
+      # #root. They are their own origin for matching purposes.
+      def root
+        self
+      end
     end
   end
 end

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,46 @@
+# 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)
+        if identifier.length > Pubid::MAX_INPUT_LENGTH
+          raise ArgumentError, Pubid::INPUT_TOO_LONG_MESSAGE
+        end
+
+        parsed = Parser.parse(identifier)
+        Builder.build(parsed)
+      rescue Parslet::ParseFailed => e
+        raise "Failed to parse DOI '#{identifier}': #{e.message}"
+      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 < Parslet::Parser
+      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,61 @@
+# 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)
+      rescue Parslet::ParseFailed => e
+        raise "Failed to parse EASC identifier '#{identifier}': #{e.message}"
+      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,80 @@
+# 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 < Parslet::Parser
+      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)
+        raise ArgumentError, ::Pubid::INPUT_TOO_LONG_MESSAGE if string.length > ::Pubid::MAX_INPUT_LENGTH
+
+        new.parse(string.strip)
+      end
+    end
+  end
+end