relaton 2.1.0 → 3.0.0.pre.alpha.1

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

data/lib/relaton/un/session.rb

@@ -0,0 +1,25 @@
+module Relaton
+  module Un
+    class Session < Lutaml::Model::Serializable
+      attribute :number, :string
+      attribute :session_date, :date
+      attribute :item_number, :string, collection: true
+      attribute :item_name, :string, collection: true
+      attribute :subitem_name, :string, collection: true
+      attribute :collaborator, :string
+      attribute :agenda_id, :string
+      attribute :item_footnote, :string
+
+      xml do
+        map_element "number", to: :number
+        map_element "session-date", to: :session_date
+        map_element "item-number", to: :item_number
+        map_element "item-name", to: :item_name
+        map_element "subitem-name", to: :subitem_name
+        map_element "collaborator", to: :collaborator
+        map_element "agenda-id", to: :agenda_id
+        map_element "item-footnote", to: :item_footnote
+      end
+    end
+  end
+end

data/lib/relaton/un/token_generator.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative "wasm"
+
+module Relaton
+  module Un
+    module TokenGenerator
+      WASM_PATH = File.join(__dir__, "wasm_v_bg.wasm")
+      DOMAIN = "documents.un.org"
+
+      # Generates an auth token for the UN documents API.
+      # Tokens are cached per-minute since the WASM output changes each minute.
+      # @return [String] decimal string representation of the i64 token
+      def self.generate
+        now = Time.now.utc
+        key = [now.year, now.month, now.day, now.hour, now.min]
+        return @cached_token if @cached_key == key && @cached_token
+
+        @cached_key = key
+        @cached_token = call_wasm(*key)
+      end
+
+      def self.call_wasm(year, month, day, hour, minute)
+        mod = (@module ||= Wasm::Module.parse(File.binread(WASM_PATH)))
+        heap = Heap.new
+        fake_window = Object.new
+        fake_location = Object.new
+        heap.alloc(fake_window)   # index 4
+        heap.alloc(fake_location) # index 5
+
+        imports = { "wbg" => build_imports(heap, fake_window, fake_location) }
+        instance = Wasm::Instance.new(mod, imports)
+        instance.invoke("check", year, month, day, hour, minute).to_s
+      end
+
+      def self.build_imports(heap, fake_window, fake_location) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        w = {}
+        w["__wbindgen_object_drop_ref"] = ->(_c, idx) { heap.drop(idx); nil }
+        w["__wbg_instanceof_Window_acc97ff9f5d2c7b4"] = ->(_c, _idx) { 1 }
+        w["__wbg_location_8cc8ccf27e342c0a"] = ->(_c, _idx) { heap.alloc(fake_location) }
+        w["__wbg_newnoargs_b5b063fc6c2f0376"] = ->(_c, _ptr, _len) { heap.alloc(Object.new) }
+        w["__wbg_call_97ae9d8645dc388b"] = ->(_c, _f, _t) { heap.alloc(fake_window) }
+        w["__wbindgen_object_clone_ref"] = ->(_c, idx) { heap.alloc(heap.get(idx)) }
+        %w[
+          __wbg_self_6d479506f72c6a71
+          __wbg_window_f2557cc78490aceb
+          __wbg_globalThis_7f206bda628d5286
+          __wbg_global_ba75c50d1cf384f4
+        ].each { |name| w[name] = ->(_c) { heap.alloc(fake_window) } }
+        w["__wbindgen_is_undefined"] = ->(_c, idx) { heap.get(idx) == :undefined ? 1 : 0 }
+        w["__wbindgen_debug_string"] = ->(_c, _ret_ptr, _idx) { nil }
+        w["__wbindgen_throw"] = lambda do |caller, ptr, len|
+          mem = caller.export("memory").to_memory
+          raise mem.read(ptr, len)
+        end
+        w["__wbg_host_f82dbbd8bb5ef24a"] = lambda do |caller, ret_ptr, _loc_idx|
+          mem = caller.export("memory").to_memory
+          malloc = caller.export("__wbindgen_malloc").to_func
+          host_bytes = DOMAIN.encode("utf-8")
+          ptr = malloc.call(host_bytes.bytesize)
+          mem.write(ptr, host_bytes)
+          mem.write(ret_ptr, [ptr, host_bytes.bytesize].pack("V2"))
+          nil
+        end
+        w
+      end
+
+      # Manages a slab-allocated heap of Ruby objects indexed by i32,
+      # mirroring wasm-bindgen's JS object heap.
+      class Heap
+        BUILTINS = 36
+
+        def initialize
+          # Indices 0-3 mirror wasm-bindgen's builtin slots:
+          # 0 = undefined, 1 = null, 2 = true, 3 = false
+          @slab = [:undefined, nil, true, false]
+          @free_head = @slab.length
+        end
+
+        def get(idx)
+          @slab[idx]
+        end
+
+        def alloc(obj)
+          if @free_head >= @slab.length
+            @slab << (@slab.length + 1)
+          end
+          idx = @free_head
+          @free_head = @slab[idx]
+          @slab[idx] = obj
+          idx
+        end
+
+        def drop(idx)
+          return if idx < BUILTINS
+
+          @slab[idx] = @free_head
+          @free_head = idx
+        end
+      end
+
+      private_class_method :call_wasm, :build_imports
+    end
+  end
+end

data/lib/relaton/un/util.rb

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