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

data/lib/relaton/sdo/logo.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Sdo
+    # One logo variant for an organization. Variants are differentiated by
+    # `style` (the primary discriminator — e.g. "default", "red", "iso_1972"),
+    # `format` (file suffix) and `size`. `applicability` is opaque, informational
+    # text (e.g. "stage>=60"); the store never interprets it — consumers do.
+    class Logo
+      MIME_TYPES = {
+        "png" => "image/png",
+        "jpg" => "image/jpeg",
+        "jpeg" => "image/jpeg",
+        "gif" => "image/gif",
+        "svg" => "image/svg+xml",
+        "webp" => "image/webp",
+        "eps" => "application/postscript",
+        "pdf" => "application/pdf",
+      }.freeze
+
+      attr_reader :style, :format, :size, :url, :applicability
+
+      def initialize(style: nil, format: nil, size: nil, url: nil, applicability: nil)
+        @style = style
+        @format = format
+        @size = size
+        @url = url
+        @applicability = applicability
+      end
+
+      def self.from_hash(hash)
+        new(style: hash["style"], format: hash["format"], size: hash["size"],
+            url: hash["url"], applicability: hash["applicability"])
+      end
+
+      # Raw binary content of the logo, fetched lazily from `url` and memoized.
+      # Raises Sdo::Error (naming the URL) if the fetch fails, rather than
+      # returning nil and crashing cryptically inside data_uri/save downstream.
+      def content
+        @content ||= begin
+          data = Fetcher.download(url)
+          raise Error, "could not fetch logo from #{url.inspect}" if data.nil?
+
+          data
+        end
+      end
+
+      # The logo as a base64-encoded data URI, ready to embed in XML/HTML.
+      def data_uri
+        "data:#{mimetype};base64,#{Base64.strict_encode64(content)}"
+      end
+
+      def mimetype
+        MIME_TYPES[format.to_s.downcase] || "application/octet-stream"
+      end
+
+      # Write the logo to disk. With no argument, uses a filename derived from
+      # the source URL (or from style/size/format); returns the path written.
+      def save(path = nil)
+        path ||= default_filename
+        File.binwrite(path, content)
+        path
+      end
+
+      def to_h
+        { style: style, format: format, size: size, url: url,
+          applicability: applicability }.compact
+      end
+
+      def describe
+        to_h.map { |k, v| "#{k}=#{v}" }.join(", ")
+      end
+
+      private
+
+      def default_filename
+        base = File.basename(url_path)
+        return base unless base.empty? || File.extname(base).empty?
+
+        stem = [style, size].reject { |s| s.to_s.empty? }.join("-")
+        stem = "logo" if stem.empty?
+        ext = format.to_s.empty? ? "bin" : format
+        "#{stem}.#{ext}"
+      end
+
+      # The URL's path component, tolerating URLs that URI can't parse (e.g. a
+      # stray space) by falling back to the raw string sans query/fragment.
+      def url_path
+        URI.parse(url.to_s).path
+      rescue URI::InvalidURIError
+        url.to_s.split(/[?#]/, 2).first
+      end
+    end
+  end
+end

data/lib/relaton/sdo/name.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Sdo
+    # A single organization name, optionally tagged with a language. A name with
+    # no language is the default (untranslated) name.
+    class Name
+      attr_reader :content, :language
+
+      def initialize(content:, language: nil)
+        @content = content
+        @language = language
+      end
+
+      def self.from_hash(hash)
+        return new(content: hash) unless hash.is_a?(Hash)
+
+        new(content: hash["content"], language: hash["language"])
+      end
+
+      def default?
+        language.nil? || language.to_s.empty?
+      end
+    end
+  end
+end

data/lib/relaton/sdo/organization.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Sdo
+    # A standards-development organization: its names (with translations) and its
+    # logo variants. Built from one entry of the index manifest.
+    class Organization
+      attr_reader :abbreviation, :names, :logos
+
+      def initialize(abbreviation:, names: [], logos: [])
+        @abbreviation = abbreviation
+        @names = names
+        @logos = logos
+      end
+
+      def self.from_hash(abbreviation, hash)
+        hash ||= {}
+        new(
+          abbreviation: abbreviation,
+          names: Array(hash["name"]).map { |n| Name.from_hash(n) },
+          logos: Array(hash["logo"]).map { |l| Logo.from_hash(l) },
+        )
+      end
+
+      # The organization's name. With no argument (or a nil language) returns the
+      # default, untranslated name; otherwise the translation for the requested
+      # language — passed positionally (`name("fr")`) or as the `language:`
+      # keyword (`name(language: "fr")`) — or nil if there is none. The keyword
+      # wins if both are given.
+      def name(lang = nil, language: nil)
+        language ||= lang
+        selected =
+          if language.nil?
+            names.find(&:default?) || names.first
+          else
+            names.find { |n| n.language == language }
+          end
+        selected&.content
+      end
+
+      # All logo variants matching the given filters. Every argument is optional;
+      # omitting one matches any value for it. Returns an array (possibly empty).
+      def logo_query(format: nil, size: nil, style: nil)
+        logos.select do |logo|
+          match?(logo.format, format) &&
+            match?(logo.size, size) &&
+            match?(logo.style, style)
+        end
+      end
+
+      # A single logo matching the filters. Returns nil when nothing matches; the
+      # sole match when exactly one does; raises when the filter is ambiguous so
+      # the caller narrows it by format/size/style.
+      def logo(format: nil, size: nil, style: nil)
+        matches = logo_query(format: format, size: size, style: style)
+        return matches.first if matches.size <= 1
+
+        raise Error, "#{matches.size} logos match #{abbreviation}; narrow by " \
+                     "format/size/style: #{matches.map(&:describe).join('; ')}"
+      end
+
+      private
+
+      def match?(value, query)
+        return true if query.nil?
+
+        !value.nil? && value.to_s.casecmp?(query.to_s)
+      end
+    end
+  end
+end

data/lib/relaton/sdo/store.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Sdo
+    # Singleton registry of organizations, built lazily from the index manifest
+    # and memoized for the process. `reset!` drops the memo (mainly for specs).
+    class Store
+      include Singleton
+
+      def initialize
+        @mutex = Mutex.new
+      end
+
+      # Look up an organization by abbreviation (case-insensitive). Returns an
+      # Organization or nil.
+      def organization(abbreviation)
+        index[normalize(abbreviation)]
+      end
+
+      # Lazily built and memoized; the mutex keeps a concurrent first access from
+      # downloading/parsing the index twice.
+      def index
+        @index || @mutex.synchronize { @index ||= build_index }
+      end
+
+      def reset!
+        @mutex.synchronize { @index = nil }
+      end
+
+      private
+
+      def normalize(abbreviation)
+        abbreviation.to_s.strip.upcase
+      end
+
+      def build_index
+        yaml = Fetcher.fetch_index
+        data = yaml.nil? || yaml.empty? ? {} : YAML.safe_load(yaml)
+        # A corrupt/unexpected index (non-mapping YAML) degrades to "no orgs"
+        # rather than crashing every lookup with a TypeError.
+        organizations = data.is_a?(Hash) ? (data["organizations"] || {}) : {}
+        organizations.each_with_object({}) do |(abbreviation, attrs), acc|
+          acc[normalize(abbreviation)] =
+            Organization.from_hash(abbreviation, attrs)
+        end
+      end
+    end
+  end
+end

data/lib/relaton/sdo.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Relaton::Sdo — the standards-body organization & logo store (metanorma#346,
+# relaton-db#132). A NON-flavor, lazily-autoloaded top-level component: it has
+# no processor and no Db::Registry entry. It fetches a small `index.yaml`
+# manifest published by the `relaton-data-sdo` data repo, caches it under
+# `~/.relaton/sdo/`, and exposes org names/translations and logo variants
+# (differentiated by style/format/size) via `Relaton.organization`.
+
+require "net/http"
+require "uri"
+require "yaml"
+require "base64"
+require "fileutils"
+require "singleton"
+
+require_relative "index/file_storage"
+require_relative "sdo/config"
+require_relative "sdo/name"
+require_relative "sdo/logo"
+require_relative "sdo/organization"
+require_relative "sdo/fetcher"
+require_relative "sdo/store"
+
+module Relaton
+  module Sdo
+    class Error < StandardError; end
+  end
+end

data/lib/relaton/un/bibdata.rb

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

data/lib/relaton/un/bibitem.rb

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

data/lib/relaton/un/bibliography.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Un
+    # Class methods for search UN standards.
+    class Bibliography
+      class << self
+        # @param text [String]
+        # @return [Relaton::Un::HitCollection]
+        def search(text)
+          HitCollection.search text
+        rescue Faraday::ConnectionFailed, Faraday::TimeoutError,
+               Faraday::SSLError => e
+          raise Relaton::RequestError,
+                "Could not access #{HitCollection::API_BASE}: #{e.message}"
+        end
+
+        # @param ref [String] document reference
+        # @param year [String, NilClass]
+        # @param opts [Hash] options
+        # @return [Relaton::Bib::ItemData]
+        def get(ref, _year = nil, _opts = {})
+          Util.info "Fetching from documents.un.org ...", key: ref
+          /^(?:UN\s)?(?<code>.*)/ =~ ref
+          result = isobib_search_filter(code)
+          if result
+            Util.info "Found: `#{result.item.docidentifier[0].content}`", key: ref
+            result.item
+          else
+            Util.info "Not found.", key: ref
+            nil
+          end
+        end
+
+        private
+
+        # Search for hits.
+        #
+        # @param code [String] reference without correction
+        # @return [Relaton::Un::Hit, nil]
+        def isobib_search_filter(code)
+          result = search(code)
+          result.select { |i| i.hit["symbols"]&.compact&.include?(code) }.first
+        end
+      end
+    end
+  end
+end

data/lib/relaton/un/doctype.rb

@@ -0,0 +1,10 @@
+module Relaton
+  module Un
+    class Doctype < Bib::Doctype
+      attribute :content, :string, values: %w[
+        recommendation plenary addendum communication corrigendum
+        reissue agenda budgetary sec-gen-notes expert-report resolution
+      ]
+    end
+  end
+end

data/lib/relaton/un/ext.rb

@@ -0,0 +1,30 @@
+require_relative "doctype"
+require_relative "session"
+
+module Relaton
+  module Un
+    class Ext < Bib::Ext
+      attribute :doctype, Doctype
+      attribute :submissionlanguage, :string, collection: true
+      attribute :distribution, :string, values: %w[general limited restricted provisional]
+      attribute :session, Session
+      attribute :job_number, :string
+
+      xml do
+        map_element "submissionlanguage", to: :submissionlanguage
+        map_element "distribution", to: :distribution
+        map_element "session", to: :session
+        map_element "job_number", to: :job_number
+      end
+
+      key_value do
+        map "submissionlanguage", to: :submissionlanguage
+        map "distribution", to: :distribution
+        map "session", to: :session
+        map "job_number", to: :job_number
+      end
+
+      def get_schema_version = Relaton.schema_versions["relaton-model-un"]
+    end
+  end
+end

data/lib/relaton/un/hit.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Un
+    class Hit < Core::Hit
+      # rubocop:disable Layout/LineLength
+      BODY = {
+        "A" => "General Assembly",
+        "E" => "Economic and Social Council",
+        "S" => "Security Council",
+        "T" => "Trusteeship Council",
+        "ACC" => "Administrative Committee on Coordination",
+        "AT" => "United Nations Administrative Tribunal",
+        "CAT" => "Committee against Torture",
+        "CCPR" => "Human Rights Committee",
+        "CD" => "Conference on Disarmament",
+        "CEDAW" => "Committee on the Elimination of All Forms of Discrimination against Women",
+        "CERD" => "Committee on the Elimination of Racial Discrimination",
+        "CRC" => "Committee on the Rights of the Child",
+        "DC" => "Disarmament Commission",
+        "DP" => "United Nations Development Programme",
+        "HS" => "United Nations Centre for Human Settlements (HABITAT)",
+        "TD" => "United Nations Conference on Trade and Development",
+        "UNEP" => "United Nations Environment Programme",
+        "TRADE" => "Committee on Trade",
+        "CEFACT" => "Centre for Trade Facilitation and Electronic Business",
+        "C.1" => "Disarmament and International Security Committee",
+        "C.2" => "Economic and Financial Committee",
+        "C.3" => "Social, Humanitarian & Cultural Issues",
+        "C.4" => "Special Political and Decolonization Committee",
+        "C.5" => "Administrative and Budgetary Committee",
+        "C.6" => "Sixth Committee (Legal)",
+        "PC" => "Preparatory Committee",
+        "AEC" => "Atomic Energy Commission",
+        "AGRI" => "Committee on Agriculture",
+        "AMCEN" => "African Ministerial Conference on the Environment",
+        "AMCOW" => "African Ministers' Council on Water",
+        "ECA" => "Economic Commission for Africa",
+        "ESCAP" => "Economic and Social Commission for Asia and Pacific",
+        "ECE" => "Economic Commission for Europe",
+        "ECWA" => "Economic Commission for Western Asia",
+        "UNFF" => "United Nations Forum on Forests",
+        "ENERGY" => "Committee on Sustainable Energy",
+        "FAO" => "Food and Agriculture Organization",
+        "UNCTAD" => "United Nations Conference on Trade and Development",
+      }.freeze
+      # rubocop:enable Layout/LineLength
+
+      # Parse page.
+      # @return [Relaton::Un::Item]
+      def item
+        @item ||= Parser.new(hit).parse
+      end
+    end
+  end
+end

data/lib/relaton/un/hit_collection.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+require "securerandom"
+
+module Relaton
+  module Un
+    class HitCollection < Core::HitCollection
+      API_BASE = "https://documents.un.org/api"
+
+      # Factory method — performs the API search and populates hits.
+      # @param text [String] symbol to search for
+      # @return [HitCollection]
+      def self.search(text)
+        hc = new(text)
+        hc.send(:fetch_hits)
+        hc
+      end
+
+      private
+
+      def fetch_hits
+        response = search_api(@ref)
+        response&.each { |data| @array << Hit.new(data, self) }
+      end
+
+      def search_api(text) # rubocop:disable Metrics/MethodLength
+        resp = connection.post("search?l=en&rid=#{SecureRandom.uuid}") do |req|
+          req.headers["Content-Type"] = "application/json"
+          req.body = JSON.generate(search_body(text))
+        end
+        return unless resp.success?
+
+        body = JSON.parse(resp.body)
+        return unless body["status"] == 1
+
+        body.dig("body", "data")
+      end
+
+      def search_body(text) # rubocop:disable Metrics/MethodLength
+        {
+          symbol: text, jobNumber: "", publicationDate: "* TO *",
+          releaseDate: "* TO *", title: "", subject: "", session: "",
+          agenda: "", truncation: false,
+          fullTextSearch: { language: "en", searchText: "" },
+          sortOptions: { sortField: "Sort by relevance" },
+          pagination: { currentPage: 1, itemsPerPage: 20 },
+          screenLanguage: "en", tcodes: [],
+        }
+      end
+
+      def connection
+        @connection ||= Faraday.new(url: API_BASE) do |f|
+          f.headers["Authorization"] = "Access #{TokenGenerator.generate}"
+          f.headers["Cache-Control"] = "public, max-age=0"
+        end
+      end
+    end
+  end
+end

data/lib/relaton/un/item.rb

@@ -0,0 +1,11 @@
+require_relative "ext"
+
+module Relaton
+  module Un
+    class Item < Bib::Item
+      model ItemData
+
+      attribute :ext, Ext
+    end
+  end
+end

data/lib/relaton/un/item_data.rb

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

data/lib/relaton/un/parser.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Un
+    class Parser
+      DISTRIBUTIONS = { "GEN" => "general", "LTD" => "limited",
+                        "DER" => "restricted", "PRO" => "provisional" }.freeze
+
+      def initialize(hit)
+        @hit = hit
+      end
+
+      # @return [Relaton::Un::ItemData]
+      def parse # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        ItemData.new(
+          type: "standard",
+          fetched: Date.today.to_s,
+          docidentifier: fetch_docid,
+          docnumber: @hit["symbol"],
+          language: ["en"],
+          script: ["Latn"],
+          title: fetch_title,
+          date: fetch_date,
+          source: fetch_link,
+          keyword: fetch_keyword,
+          ext: Ext.new(
+            session: fetch_session,
+            distribution: fetch_distribution,
+            job_number: fetch_job_number,
+          ),
+        )
+      end
+
+      private
+
+      # @return [Array<Relaton::Bib::Docidentifier>]
+      def fetch_docid
+        symbols = @hit["symbols"]&.compact&.reject(&:empty?) || []
+        dids = symbols.map { |s| Bib::Docidentifier.new(content: s, type: "UN") }
+        dids.first.primary = true unless dids.empty?
+        dids
+      end
+
+      # @return [Array<Relaton::Bib::Title>]
+      def fetch_title
+        title = english_data&.dig("title") || ""
+        Bib::Title.from_string title, "en", "Latn"
+      end
+
+      # @return [Array<Relaton::Bib::Date>]
+      def fetch_date
+        d = []
+        if (pub = @hit["publication_date"])
+          d << Bib::Date.new(type: "published", at: pub[0, 10])
+        end
+        if (rel = english_data&.dig("release_date"))
+          d << Bib::Date.new(type: "issued", at: rel[0, 10])
+        end
+        d
+      end
+
+      # @return [Array<Relaton::Bib::Uri>]
+      def fetch_link
+        jn = fetch_job_number
+        return [] unless jn && !jn.empty?
+
+        [Bib::Uri.new(
+          content: "https://documents.un.org/api/symbol/access?j=#{jn}&t=pdf",
+          type: "pdf",
+        )]
+      end
+
+      # @return [Array<Relaton::Bib::Keyword>]
+      def fetch_keyword
+        subjects = english_data&.dig("subjects") || []
+        subjects.map do |kw|
+          Bib::Keyword.new(vocab: Bib::LocalizedString.new(content: kw))
+        end
+      end
+
+      # @return [Relaton::Un::Session]
+      def fetch_session
+        session_num = @hit["sessions"]&.compact&.reject(&:empty?)&.first
+        agenda = @hit["agendas"]&.compact&.reject(&:empty?)&.first
+        Session.new(number: session_num, agenda_id: agenda)
+      end
+
+      # @return [String, nil]
+      def fetch_distribution
+        DISTRIBUTIONS[@hit["distribution"]]
+      end
+
+      # @return [String, nil]
+      def fetch_job_number
+        en = english_data
+        jn = en&.dig("job_number")
+        return jn if jn && !jn.empty?
+
+        @hit["job_numbers"]&.compact&.reject(&:empty?)&.first
+      end
+
+      # @return [Hash, nil] the English perLanguage entry
+      def english_data
+        @english_data ||= @hit["perLanguage"]&.find { |pl| pl["language"] == "English" }
+      end
+    end
+  end
+end

data/lib/relaton/un/processor.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "relaton/core/processor"
+
+module Relaton
+  module Un
+    class Processor < Core::Processor
+      attr_reader :idtype
+
+      def initialize
+        @short = :relaton_un
+        @prefix = "UN"
+        @defaultprefix = %r{^UN\s}
+        @idtype = "UN"
+      end
+
+      def get(code, date, opts)
+        require_relative "../un"
+        Bibliography.get(code, date, opts)
+      end
+
+      def from_xml(xml)
+        require_relative "../un"
+        Bibdata.from_xml(xml)
+      end
+
+      def from_yaml(yaml)
+        require_relative "../un"
+        Item.from_yaml(yaml)
+      end
+
+      def grammar_hash
+        require_relative "../un"
+        @grammar_hash ||= Relaton::Un.grammar_hash
+      end
+    end
+  end
+end