relaton 2.2.0.pre.alpha.1 → 3.0.0.pre.alpha.2

data/lib/relaton/doi/processor.rb

@@ -0,0 +1,65 @@
+require "relaton/core/processor"
+
+module Relaton
+  module Doi
+    class Processor < Core::Processor
+      attr_reader :idtype
+
+      def initialize # rubocop:disable Lint/MissingSuper
+        @short = :relaton_doi
+        @prefix = "DOI"
+        @defaultprefix = %r{^doi:}
+        @idtype = "DOI"
+      end
+
+      # @param code [String] DOI
+      # @param date [String, nil] year
+      # @param opts [Hash]
+      # @return [RelatonBib::BibliographicItem]
+      def get(code, _date, _opts)
+        require_relative "../doi"
+        Crossref.get(code)
+      end
+
+      #
+      # @param [String] source source name
+      # @param [Hash] opts
+      # @option opts [String] :output directory to output documents
+      # @option opts [String] :format
+      #
+      def fetch_data(_source, _opts)
+        Util.info "This processor does not support fetching data by source name. Use `get` method with DOI instead."
+      end
+
+      # @param xml [String]
+      # @return [Bib::ItemData]
+      def from_xml(xml)
+        require_relative "../doi"
+        Bib::Item.from_xml xml
+      end
+
+      # @param yaml [String]
+      # @return [Bib::ItemData]
+      def from_yaml(yaml)
+        require_relative "../doi"
+        Bib::Item.from_yaml yaml
+      end
+
+      # Returns hash of XML grammar
+      # @return [String]
+      def grammar_hash
+        require_relative "../doi"
+        @grammar_hash ||= ::Relaton::Doi.grammar_hash
+      end
+
+      def remove_index_file
+        require_relative "../doi" # defines Util — needed when called cold
+        Util.info "This processor does not support index file. No action taken."
+      end
+
+      # Returns number of threads
+      # @return [Integer]
+      def threads = 2
+    end
+  end
+end

data/lib/relaton/doi/util.rb

@@ -0,0 +1,8 @@
+module Relaton
+  module Doi
+    module Util
+      extend Relaton::Bib::Util
+      PROGNAME = "relaton-doi".freeze
+    end
+  end
+end

data/lib/relaton/doi.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require "relaton/bipm"
+require "relaton/ietf"
+require "relaton/ieee"
+require "relaton/nist"
+require_relative "version"
+require_relative "doi/util"
+require_relative "doi/parser"
+require_relative "doi/crossref"
+
+module Relaton
+  module Doi
+    extend self
+
+    def grammar_hash
+      Digest::MD5.hexdigest Relaton::VERSION
+    end
+  end
+end

data/lib/relaton/easc/bibdata.rb

@@ -0,0 +1,8 @@
+module Relaton
+  module Easc
+    class Bibdata < Item
+      model ItemData
+      include Bib::BibdataShared
+    end
+  end
+end

data/lib/relaton/easc/bibitem.rb

@@ -0,0 +1,8 @@
+module Relaton
+  module Easc
+    class Bibitem < Item
+      model ItemData
+      include Bib::BibitemShared
+    end
+  end
+end

data/lib/relaton/easc/bibliography.rb

@@ -0,0 +1,95 @@
+require "net/http"
+
+module Relaton
+  module Easc
+    # Index-backed retrieval for the EASC flavor (no scraping). Mirrors
+    # Relaton::Oiml::Bibliography: it parses the reference with
+    # Pubid::Easc, narrows the pre-built `relaton-data-easc` index by
+    # number, fetches the matching per-document YAML over Net::HTTP, and
+    # deserializes it into a Relaton::Easc::Item.
+    module Bibliography
+      ENDPOINT = "https://raw.githubusercontent.com/relaton/relaton-data-easc/main/".freeze
+
+      class << self
+        #
+        # Search for an EASC publication by its identifier.
+        #
+        # @param text [String, Pubid::Easc::Identifier] the EASC reference to
+        #   look up (e.g. "ПМГ 03-2025", "РМГ 151-2025", or the Latin
+        #   transliteration "PMG 03-2025")
+        # @param year [String, nil] the edition year (optional; usually embedded
+        #   in the reference)
+        # @param _opts [Hash] options (unused)
+        #
+        # @return [Relaton::Easc::Item, nil] the publication or nil if not found
+        #
+        def search(text, year = nil, _opts = {})
+          pubid = text.is_a?(String) ? ::Pubid::Easc.parse(text) : text
+          Util.info "Fetching from Relaton repository ...", key: pubid.to_s
+          # Pass the pubid so Relaton::Index narrows candidates by number via
+          # binary search before applying the block. Every row's `:id` is a
+          # Pubid::Easc::Identifier (deserialized via the `pubid_class` passed to
+          # #index), so the block compares pubids and picks the latest edition.
+          row = index.search(pubid) { |r| pubid_match?(r[:id], pubid, year) }
+                     .max_by { |r| r[:id].year.to_i }
+          unless row
+            Util.info "Not found.", key: pubid.to_s
+            return
+          end
+
+          uri = URI("#{ENDPOINT}#{row[:file]}")
+          resp = Net::HTTP.get_response uri
+          unless resp.code == "200"
+            raise Relaton::RequestError, "Could not access #{uri}: HTTP #{resp.code}"
+          end
+
+          item = Relaton::Easc::Item.from_yaml resp.body
+          Util.info "Found: `#{item.docidentifier.first&.content}`", key: pubid.to_s
+          item.tap { |i| i.fetched = Date.today.to_s }
+        rescue SocketError, Errno::EINVAL, Errno::ECONNRESET, EOFError,
+               Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError,
+               Net::ProtocolError, Net::ReadTimeout, OpenSSL::SSL::SSLError,
+               Errno::ETIMEDOUT => e
+          raise Relaton::RequestError, "Could not access #{uri}: #{e.message}"
+        end
+
+        #
+        # Fetch an EASC publication. EASC citations are always dated
+        # (e.g. "ПМГ 03-2025"), so there is no undated/most-recent handling to
+        # mirror from the ISO/OIML fetchers — `get` just returns what `search`
+        # resolves.
+        #
+        # @see #search
+        #
+        def get(ref, year = nil, opts = {})
+          search(ref, year, opts)
+        end
+
+        private
+
+        def index
+          Relaton::Index.find_or_create(
+            :easc,
+            url: "#{ENDPOINT}#{INDEXFILE}.zip",
+            file: "#{INDEXFILE}.yaml",
+            pubid_class: ::Pubid::Easc::Identifier,
+          )
+        end
+
+        # Both `row_id` and `query` are Pubid::Easc::Identifier instances. A row
+        # matches when its series, defense variant, and number are equal (so a
+        # ПМГ never matches a РМГ, and the «В» defense variant never matches the
+        # plain series). Year is nil-tolerant: an unqualified query finds the
+        # latest edition (selected by `max_by` in #search); the `year` argument
+        # lets a caller pin an edition the reference string omitted.
+        def pubid_match?(row_id, query, year)
+          wanted_year = (query.year || year)&.to_s
+          row_id.series == query.series &&
+            row_id.variant.to_s == query.variant.to_s &&
+            row_id.number.to_s == query.number.to_s &&
+            (wanted_year.nil? || row_id.year.to_s == wanted_year)
+        end
+      end
+    end
+  end
+end

data/lib/relaton/easc/docidentifier.rb

@@ -0,0 +1,100 @@
+module Relaton
+  module Easc
+    # Structured EASC document identifier. The docid string is the canonical
+    # citation form (e.g. "ПМГ 03-2025", "РМГ 151-2025"), parsed into a
+    # `Pubid::Easc::Identifier` kept in `@pubid` while the lutaml `content`
+    # attribute stays a plain string for serialization.
+    #
+    # Parsing is **soft**: `content=` lazily requires pubid and rescues
+    # `LoadError`/`StandardError`, so a missing gem or non-EASC content leaves
+    # `@pubid` nil rather than raising.
+    #
+    # This was an empty subclass, which meant it inherited
+    # `Bib::Docidentifier`'s abstract `remove_part!` / `remove_date!` /
+    # `to_all_parts!`. `Bib::ItemData` broadcasts all three to every
+    # docidentifier, so `#to_all_parts` and `#to_most_recent_reference` raised
+    # `NotImplementedError` on **every** EASC item — and it descends from
+    # `ScriptError`, so a caller's `rescue => e` did not catch it.
+    class Docidentifier < Bib::Docidentifier
+      attr_reader :pubid
+
+      # Capture the inherited content setter before overriding #content=, so
+      # #refresh_content! can write the re-rendered string back WITHOUT
+      # re-parsing (a re-parse would rebuild @pubid and discard in-place
+      # mutations such as `all_parts = true`).
+      alias_method :store_content, :content=
+
+      def initialize(attrs = {}, options = {})
+        pubid = attrs.is_a?(Hash) ? attrs.delete(:pubid) : nil
+        attrs[:content] ||= pubid.to_s if pubid
+        super
+        @pubid = pubid if pubid
+      end
+
+      def content=(value)
+        super
+        return unless value
+
+        @pubid = begin
+          require "pubid"
+          ::Pubid::Easc.parse(value)
+        rescue LoadError, StandardError
+          nil
+        end
+      end
+
+      # `Pubid::Easc::Identifier` models publisher/series/variant/number/year,
+      # so the mapping is EASC-specific:
+      #
+      # - **`remove_date!` → clears `year`.** EASC carries no separate date
+      #   component; the year is the edition discriminator, so clearing it
+      #   yields the undated ("most recent") reference: `ПМГ 03-2025` →
+      #   `ПМГ 03`.
+      # - **`remove_part!` → clears the (unused) `part`/`subpart`.** EASC models
+      #   no part, so this is a no-op for the rendered string; implemented so it
+      #   never raises, and it starts working if pubid-easc ever adds one.
+      # - **`to_all_parts!` → both, then wraps `@pubid` in pubid's `AllParts`.**
+      #   `content` stays the plain stripped id — EASC's own renderer has no
+      #   "(all parts)" marker, and `content` is cached from the pre-wrap
+      #   pubid on purpose. `#pubid` itself, read directly, now answers
+      #   `all_parts? == true` and renders WITH pubid's generic marker
+      #   (`#to_s`), since it's the wrapper.
+      #
+      # All three no-op safely when `@pubid` is nil.
+
+      def remove_part!
+        clear_attr!(:part)
+      end
+
+      def remove_date!
+        clear_attr!(:year)
+      end
+
+      def to_all_parts!
+        return if !@pubid || @pubid.all_parts?
+
+        # `#exclude` (no args) rebuilds a full independent copy — `remove_part!`
+        # / `remove_date!` mutate `@pubid` in place, so a bare reference here
+        # would lose the original year to that mutation too.
+        original = @pubid.exclude
+        remove_part!
+        remove_date!
+        @pubid = original.to_all_parts
+      end
+
+      private
+
+      def clear_attr!(attr)
+        return unless @pubid && @pubid.respond_to?("#{attr}=")
+
+        @pubid.public_send("#{attr}=", nil)
+        @pubid.subpart = nil if attr == :part && @pubid.respond_to?(:subpart=)
+        refresh_content!
+      end
+
+      def refresh_content!
+        store_content(@pubid.to_s) if @pubid
+      end
+    end
+  end
+end

data/lib/relaton/easc/doctype.rb

@@ -0,0 +1,14 @@
+module Relaton
+  module Easc
+    # EASC document types. Two series, both issued by the Eurasian
+    # Economic Standards Council:
+    #   * PMG — ПМГ (Правила по межгосударственной стандартизации)
+    #   * RMG — РМГ (Рекомендации по межгосударственной стандартизации)
+    class Doctype < Bib::Doctype
+      TYPES = %w[
+        pmg
+        rmg
+      ].freeze
+    end
+  end
+end

data/lib/relaton/easc/ext.rb

@@ -0,0 +1,44 @@
+module Relaton
+  module Easc
+    # EASC bibliographic item extension. Adds EASC-specific structured
+    # metadata on top of the shared Relaton::Bib::Ext so the fields
+    # round-trip through both XML and YAML without per-repo merge hacks.
+    #
+    # Fields:
+    #   * urn             — urn:easc:<series>:...
+    #   * webpage         — mgscatalog.by detail URL
+    #   * session         — МГС council session that adopted the doc
+    #                       (e.g. "67МГС", "19МГС")
+    #   * developer       — Разработчик (e.g. "Российская Федерация")
+    #   * joining_states  — country codes of states that joined
+    #                       (collection: e.g. ["АРМ", "БЕИ", "КАЗ"])
+    #   * assigned_to     — Закреплен за (e.g. "МТК 536 Методология...")
+    class Ext < Bib::Ext
+      attribute :doctype,        Doctype
+      attribute :urn,            :string
+      attribute :webpage,        :string
+      attribute :session,        :string
+      attribute :developer,      :string
+      attribute :joining_states, :string, collection: true, initialize_empty: true
+      attribute :assigned_to,    :string
+
+      xml do
+        map_element "urn",             to: :urn
+        map_element "webpage",         to: :webpage
+        map_element "session",         to: :session
+        map_element "developer",       to: :developer
+        map_element "joining_states",  to: :joining_states
+        map_element "assigned_to",     to: :assigned_to
+      end
+
+      key_value do
+        map_element "urn",             to: :urn
+        map_element "webpage",         to: :webpage
+        map_element "session",         to: :session
+        map_element "developer",       to: :developer
+        map_element "joining_states",  to: :joining_states
+        map_element "assigned_to",     to: :assigned_to
+      end
+    end
+  end
+end

data/lib/relaton/easc/item.rb

@@ -0,0 +1,13 @@
+module Relaton
+  module Easc
+    # EASC bibliographic item. Re-declares +ext+ to use the typed Ext
+    # subclass so EASC-specific fields round-trip natively.
+    class Item < Bib::Item
+      model ItemData
+
+      attribute :ext, Ext
+      attribute :docidentifier, Docidentifier, collection: true,
+                                               initialize_empty: true
+    end
+  end
+end

data/lib/relaton/easc/item_base.rb

@@ -0,0 +1,18 @@
+module Relaton
+  module Easc
+    class ItemBase < Lutaml::Model::Serializable
+      include Bib::NamespaceHelper
+
+      attr_accessor :type
+
+      model ItemData
+
+      instance_exec(&Bib::ItemShared::ATTRIBUTES)
+
+      xml do
+        map_attribute "type", to: :type
+        instance_exec(&Bib::ItemShared::XML_BODY)
+      end
+    end
+  end
+end

data/lib/relaton/easc/item_data.rb

@@ -0,0 +1,6 @@
+module Relaton
+  module Easc
+    class ItemData < Bib::ItemData
+    end
+  end
+end

data/lib/relaton/easc/processor.rb

@@ -0,0 +1,46 @@
+require "relaton/core/processor"
+
+module Relaton
+  module Easc
+    # Relaton processor for the EASC flavor. Registered by
+    # Relaton::Db::Registry when the unified gem loads (see
+    # lib/relaton/db/registry.rb). Supports `relaton fetch easc ...`
+    # once the relaton-data-easc dataset is installed.
+    class Processor < Core::Processor
+      attr_reader :idtype
+
+      def initialize
+        @short = :relaton_easc
+        @prefix = "EASC"
+        # Both Cyrillic and Latin series prefixes route here.
+        @defaultprefix = %r{^(?:ПМГ|РМГ|PMG|RMG)\b}
+        @idtype = "EASC"
+      end
+
+      def get(code, date, opts)
+        require_relative "../easc"
+        Bibliography.get(code, date, opts)
+      end
+
+      def from_xml(xml)
+        require_relative "../easc"
+        Item.from_xml xml
+      end
+
+      def from_yaml(yaml)
+        require_relative "../easc"
+        Item.from_yaml(yaml)
+      end
+
+      def grammar_hash
+        require_relative "../easc"
+        @grammar_hash ||= ::Relaton::Easc.grammar_hash
+      end
+
+      def remove_index_file
+        require_relative "../easc"
+        Relaton::Index.find_or_create(:easc, url: true, file: "#{INDEXFILE}.yaml").remove_file
+      end
+    end
+  end
+end

data/lib/relaton/easc/util.rb

@@ -0,0 +1,8 @@
+module Relaton
+  module Easc
+    module Util
+      extend Relaton::Bib::Util
+      PROGNAME = "relaton-easc".freeze
+    end
+  end
+end

data/lib/relaton/easc.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "relaton/bib"
+require "relaton/index"
+require "relaton/version"
+require "pubid"
+
+# Relaton::Easc is the EASC (Евразийский экономический совет /
+# Eurasian Economic Standards Council) flavor of the unified relaton
+# gem. Adds typed Ext fields (urn, webpage, session, developer,
+# joining_states) so they round-trip natively through YAML and XML
+# without per-repo merge hacks.
+module Relaton
+  module Easc
+    INDEXFILE = "index-v2".freeze
+
+    class Error < StandardError; end
+
+    autoload :Doctype,       "relaton/easc/doctype"
+    autoload :Ext,           "relaton/easc/ext"
+    autoload :ItemData,      "relaton/easc/item_data"
+    autoload :ItemBase,      "relaton/easc/item_base"
+    autoload :Item,          "relaton/easc/item"
+    autoload :Bibitem,       "relaton/easc/bibitem"
+    autoload :Bibdata,       "relaton/easc/bibdata"
+    autoload :Docidentifier, "relaton/easc/docidentifier"
+    autoload :Util,          "relaton/easc/util"
+    autoload :Bibliography,  "relaton/easc/bibliography"
+    autoload :Processor,     "relaton/easc/processor"
+
+    def self.grammar_hash
+      Digest::MD5.hexdigest Relaton::VERSION
+    end
+  end
+end

data/lib/relaton/ecma/bibdata.rb

@@ -0,0 +1,8 @@
+module Relaton
+  module Ecma
+    class Bibdata < Item
+      model ItemData
+      include Bib::BibdataShared
+    end
+  end
+end

data/lib/relaton/ecma/bibitem.rb

@@ -0,0 +1,8 @@
+module Relaton
+  module Ecma
+    class Bibitem < Item
+      model ItemData
+      include Bib::BibitemShared
+    end
+  end
+end

data/lib/relaton/ecma/bibliography.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal:true
+
+require "mechanize"
+
+module Relaton
+  module Ecma
+    # ECMA bibliography module
+    module Bibliography
+      ENDPOINT = "https://raw.githubusercontent.com/relaton/relaton-data-ecma/refs/heads/v2/"
+
+      class << self
+        # @return [Relaton::Index::Type]
+        def index
+          Relaton::Index.find_or_create(
+            :ECMA, url: "#{ENDPOINT}#{INDEXFILE}.zip", file: "#{INDEXFILE}.yaml",
+            pubid_class: ::Pubid::Ecma::Identifier
+          )
+        end
+
+        #
+        # Search the index for a reference.
+        #
+        # **The pubid is passed to `Index::Type#search`, not the string.**
+        # `search_candidates` narrows only when the argument is not a `String`,
+        # and a block alone never narrows — so the plain string this used to
+        # pass disabled the binary search however the index was built.
+        # `pubid_class:` on the index alone fixes nothing; both had to change
+        # together.
+        #
+        # A reference pubid cannot parse finds nothing. There is deliberately no
+        # substring-scan fallback here (the OGC idiom): an ECMA id renders as
+        # `ECMA-262 ed17`, so a substring scan would answer a truncated
+        # reference like `ECMA-26` with every ECMA-26x document — an ambiguous
+        # answer is worse than none. By the same trade-off, a reference must now
+        # parse WHOLE: the old regex was unanchored at the end, so
+        # `ECMA-6 (draft)` silently resolved to ECMA-6 and now does not. See
+        # lib/relaton/ecma/CLAUDE.md for the measured table.
+        #
+        # The rows are selected with pubid's subset match `pubid === row`, the
+        # default of `Index::Type#search`. An `edition` or a `volume` that the
+        # reference omits matches any value, so a bare `ECMA-269` reaches the
+        # edition rows. pubid declares `part` strict for ECMA, so a bare
+        # `ECMA-418` does not match `ECMA-418-1`. The class must be identical,
+        # which keeps `ECMA-100` and `ECMA TR/100` apart.
+        #
+        # @param ref [String] the ECMA reference (e.g. "ECMA-6", "ECMA-269 ed3 vol2")
+        #
+        # @return [Array<Hash>] matching index rows
+        #
+        def search(ref)
+          pubid = parse_ref ref
+          return [] unless pubid
+
+          index.search(pubid)
+        end
+
+        #
+        # Parse a user reference into a `Pubid::Ecma::Identifier`, or nil.
+        #
+        # `Pubid::Ecma` takes the space form (`ECMA 6`) as well as the hyphen
+        # one, and parses the ` ed<N>` / ` vol<N>` suffixes the old bespoke
+        # regex accepted, so every reference shape the flavor has to handle
+        # parses without normalization here.
+        #
+        # @param ref [String]
+        # @return [Pubid::Ecma::Identifier, nil]
+        #
+        # An unrecognized reference **raises**; like ISO, ETSI and 3GPP we let it
+        # propagate. relaton-cli rescues `Pubid::Errors::Error` and renders
+        # `"..." is not a recognized standards identifier`
+        # (`gems/relaton-cli/lib/relaton/cli/command.rb:324`), and `Db#fetch`
+        # logs it through the `StandardError` arm at `lib/relaton/db.rb:122`.
+        # Rescuing here would collapse "this identifier is malformed" into "no
+        # such document", leaving a caller unable to tell them apart.
+        def parse_ref(ref)
+          ::Pubid::Ecma::Identifier.parse ref.to_s.strip
+        end
+
+        # @param code [String] the ECMA standard Code to look up (e..g "ECMA-6")
+        # @param year [String] not used
+        # @param opts [Hash] not used
+        # @return [Relaton::Ecma::ItemData] Relaton of reference
+        def get(code, _year = nil, _opts = {})
+          Util.info "Fetching from Relaton repository ...", key: code
+          result = fetch_doc(code)
+          if result
+            Util.info "Found: `#{result.docidentifier.first.content}`", key: code
+          else
+            Util.info "Not found.", key: code
+          end
+          result
+        end
+
+        private
+
+        #
+        # The index row for a reference: latest edition, then lowest volume.
+        #
+        # That is the selection order the bespoke `compare_edition_volume` +
+        # `min` implemented, kept deliberately — but the edition is now compared
+        # segment-wise as INTEGERS. Comparing the rendered strings made "9" beat
+        # "17" and "5" beat "5.1", so 5 of the 421 document families returned an
+        # older document than the reference asked for: ECMA-262 answered ed9
+        # (2018-06) where ed17 (2026-06) exists, ECMA-74 ed9 (2005-12) where
+        # ed22 (2025-12) exists, and likewise 402, 328 and 109.
+        #
+        # `r[:file]` breaks the tie, because the index sort is not stable.
+        #
+        # @param ref [String]
+        # @return [Hash, nil]
+        #
+        def best_match(ref)
+          search(ref).max_by { |r| [edition_key(r[:id].edition), -r[:id].volume.to_i, r[:file]] }
+        end
+
+        #
+        # Order key for an ECMA edition: its dot-separated segments as integers.
+        #
+        # `[]` for an absent edition, which therefore sorts below every present
+        # one — right for the 64 edition-less rows (mementos, a few reports),
+        # none of which shares a document with an edition-bearing row.
+        #
+        # @param edition [String, nil]
+        # @return [Array<Integer>]
+        #
+        def edition_key(edition)
+          edition.to_s.split(".").map(&:to_i)
+        end
+
+        def fetch_doc(code)
+          row = best_match code
+          return unless row
+
+          url = "#{ENDPOINT}#{row[:file]}"
+          resp = Mechanize.new.get(url)
+          Item.from_yaml(resp.body).tap { |item| item.fetched = Date.today.to_s }
+        rescue Mechanize::ResponseCodeError => e
+          return if e.response_code == "404"
+
+          raise Relaton::RequestError, "No document found for #{code} reference. #{e.message}"
+        rescue Mechanize::RedirectLimitReachedError, Timeout::Error,
+            Mechanize::UnauthorizedError, Mechanize::UnsupportedSchemeError,
+            Mechanize::ResponseReadError, Mechanize::ChunkedTerminationError => e
+          raise Relaton::RequestError, "No document found for #{code} reference. #{e.message}"
+        end
+      end
+    end
+  end
+end