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

data/lib/relaton/un/wasm/memory.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Un
+    module Wasm
+      class Memory
+        PAGE = 65_536
+
+        attr_reader :max_pages
+
+        def initialize(initial_pages:, max_pages: nil)
+          @pages = initial_pages
+          @max_pages = max_pages
+          @buf = String.new("\x00".b * (initial_pages * PAGE), encoding: Encoding::ASCII_8BIT)
+        end
+
+        def size_pages
+          @pages
+        end
+
+        def grow(delta)
+          new_pages = @pages + delta
+          return -1 if @max_pages && new_pages > @max_pages
+
+          old = @pages
+          @pages = new_pages
+          @buf << ("\x00".b * (delta * PAGE))
+          old
+        end
+
+        def read(addr, len)
+          bounds!(addr, len)
+          @buf.byteslice(addr, len)
+        end
+
+        def write(addr, bytes)
+          bytes = bytes.b
+          bounds!(addr, bytes.bytesize)
+          @buf.bytesplice(addr, bytes.bytesize, bytes)
+        end
+
+        def load_u8(addr)
+          bounds!(addr, 1)
+          @buf.getbyte(addr)
+        end
+
+        def load_i8(addr)
+          v = load_u8(addr)
+          v >= 0x80 ? v - 0x100 : v
+        end
+
+        def load_u16(addr)
+          bounds!(addr, 2)
+          @buf.byteslice(addr, 2).unpack1("v")
+        end
+
+        def load_i16(addr)
+          v = load_u16(addr)
+          v >= 0x8000 ? v - 0x10000 : v
+        end
+
+        def load_u32(addr)
+          bounds!(addr, 4)
+          @buf.byteslice(addr, 4).unpack1("V")
+        end
+
+        def load_i32(addr)
+          v = load_u32(addr)
+          v >= 0x8000_0000 ? v - 0x1_0000_0000 : v
+        end
+
+        def load_u64(addr)
+          bounds!(addr, 8)
+          @buf.byteslice(addr, 8).unpack1("Q<")
+        end
+
+        def load_i64(addr)
+          v = load_u64(addr)
+          v >= 0x8000_0000_0000_0000 ? v - 0x1_0000_0000_0000_0000 : v
+        end
+
+        def store_u8(addr, val)
+          bounds!(addr, 1)
+          @buf.setbyte(addr, val & 0xff)
+        end
+
+        def store_u16(addr, val)
+          bounds!(addr, 2)
+          @buf.bytesplice(addr, 2, [val & 0xffff].pack("v"))
+        end
+
+        def store_u32(addr, val)
+          bounds!(addr, 4)
+          @buf.bytesplice(addr, 4, [val & 0xffff_ffff].pack("V"))
+        end
+
+        def store_u64(addr, val)
+          bounds!(addr, 8)
+          @buf.bytesplice(addr, 8, [val & 0xffff_ffff_ffff_ffff].pack("Q<"))
+        end
+
+        private
+
+        def bounds!(addr, len)
+          return if addr >= 0 && addr + len <= @buf.bytesize
+
+          raise Trap, "out of bounds memory access (addr=#{addr}, len=#{len}, size=#{@buf.bytesize})"
+        end
+      end
+    end
+  end
+end

data/lib/relaton/un/wasm/module.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Un
+    module Wasm
+      FuncType = Struct.new(:params, :results)
+      Import   = Struct.new(:mod, :field, :kind, :desc)
+      Export   = Struct.new(:name, :kind, :index)
+      Global   = Struct.new(:type, :mutable, :init_expr)
+      Element  = Struct.new(:table_idx, :offset_expr, :func_indices)
+      Data     = Struct.new(:mem_idx, :offset_expr, :bytes)
+      Code     = Struct.new(:locals, :body)
+
+      MemoryType = Struct.new(:initial, :max)
+      TableType  = Struct.new(:elem_type, :initial, :max)
+
+      class Module
+        attr_reader :types, :imports, :function_type_indices, :tables, :memories,
+                    :globals, :exports, :elements, :code, :data, :start
+
+        def initialize
+          @types = []
+          @imports = []
+          @function_type_indices = []
+          @tables = []
+          @memories = []
+          @globals = []
+          @exports = []
+          @elements = []
+          @code = []
+          @data = []
+          @start = nil
+        end
+
+        def self.parse(bytes)
+          Decoder.new(bytes).decode
+        end
+
+        # Number of imported functions (they precede module-defined functions
+        # in the funcidx space).
+        def imported_function_count
+          @imports.count { |i| i.kind == :func }
+        end
+      end
+    end
+  end
+end

data/lib/relaton/un/wasm.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Relaton
+  module Un
+    module Wasm
+      class Trap < StandardError; end
+      class DecodeError < StandardError; end
+      class LinkError < StandardError; end
+    end
+  end
+end
+
+require_relative "wasm/memory"
+require_relative "wasm/decoder"
+require_relative "wasm/module"
+require_relative "wasm/interpreter"
+require_relative "wasm/instance"

data/lib/relaton/un.rb

@@ -0,0 +1,28 @@
+require "addressable"
+require "relaton/bib"
+require_relative "version"
+require_relative "un/util"
+require_relative "un/item_data"
+require_relative "un/item"
+require_relative "un/bibitem"
+require_relative "un/bibdata"
+require_relative "un/token_generator"
+require_relative "un/parser"
+require_relative "un/hit"
+require_relative "un/hit_collection"
+require_relative "un/bibliography"
+
+module Relaton
+  module Un
+    class Error < StandardError; end
+
+    # Returns hash of XML reammar
+    # @return [String]
+    def self.grammar_hash
+      # gem_path = File.expand_path "..", __dir__
+      # grammars_path = File.join gem_path, "grammars", "*"
+      # grammars = Dir[grammars_path].sort.map { |gp| File.read gp }.join
+      Digest::MD5.hexdigest Relaton::VERSION # grammars
+    end
+  end
+end

data/lib/relaton/version.rb

@@ -1,3 +1,3 @@
 module Relaton
-  VERSION = "2.2.0.pre.alpha.1".freeze
+  VERSION = "3.0.0.pre.alpha.2".freeze
 end

data/lib/relaton/w3c/bibdata.rb

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

data/lib/relaton/w3c/bibitem.rb

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

data/lib/relaton/w3c/bibliography.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "relaton/bib/hash_parser_v1"
+
+module Relaton
+  module W3c
+    # Class methods for search W3C standards.
+    class Bibliography
+      SOURCE = "https://raw.githubusercontent.com/relaton/relaton-data-w3c/v2/"
+      # The Pages site of the data repo: it serves the machine index (manifest
+      # and shards) that `#index` reads. The documents still come from SOURCE.
+      PAGES_URL = "https://relaton.github.io/relaton-data-w3c/"
+
+      class << self
+        # @param ref [String, Pubid::W3c::Identifier] a reference, or one
+        #   already parsed (relaton#189: `Relaton::Db` parses it once)
+        # @return [Relaton::W3c::ItemData]
+        def search(ref)
+          # A reference pubid rejects raises `Pubid::Errors::ParseError`, which
+          # the transport rescue below does not catch.
+          pubid = ref.is_a?(::Pubid::W3c::Identifier) ? ref : parse_ref(ref)
+
+          row = best_match pubid
+          return unless row
+
+          url = "#{SOURCE}#{row[:file]}"
+          resp = Net::HTTP.get_response(URI.parse(url))
+          return unless resp.code == "200"
+
+          Item.from_yaml(resp.body).tap { |i| i.fetched = Date.today.to_s }
+        rescue SocketError, Timeout::Error, Errno::EINVAL, Errno::ECONNRESET,
+               EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError,
+               Net::ProtocolError, Errno::ETIMEDOUT => e
+          raise Relaton::RequestError, "Could not access #{url}: #{e.message}"
+        end
+
+        #
+        # Find the index row for a reference, newest edition first.
+        #
+        # Passing the pubid to `Index::Type#search` is what enables the binary
+        # search on `id.root.number` — with a block alone the whole index is
+        # scanned. Selection is `Type#search`'s default with no block — pubid's
+        # asymmetric subset match (`Pubid::SubsetMatch`): the reference on the
+        # left, the row on the right, and a component it omits matches any
+        # value. `date`
+        # is W3C's only optional component, so an undated `REC-xml-names` still
+        # finds the dated row, while a dated reference reaches only its own.
+        # The maturity level is deliberately NOT a wildcard: it is the
+        # identifier's class, and `===` requires the same class, so `WD-`,
+        # `REC-` and a bare slug never match each other — the same contract the
+        # bespoke `PubId#==` had for its `stage`/`type`.
+        #
+        # @param pubid [Pubid::W3c::Identifier]
+        # @return [Hash, nil]
+        #
+        def best_match(pubid)
+          rows = index.search(pubid)
+          rows = index.search { |r| loose_match? r[:id], pubid } if rows.empty?
+
+          # Newest edition wins. Undated rows all score 0, so the file path
+          # breaks the tie and a repeated lookup returns the same document
+          # (the index sort is not stable).
+          rows.max_by { |r| [date_key(r[:id].date), r[:file]] }
+        end
+
+        #
+        # Order key for a W3C publication date.
+        #
+        # The dates are opaque digit runs of varying width, so a plain `to_i`
+        # does not order them: a legacy 6-digit `YYMMDD` always loses to an
+        # 8-digit `YYYYMMDD`, however much later it is (`980619` is June 1998,
+        # `19980512` is May). Restoring the century fixes that — all 63
+        # 6-digit dates in the corpus are 1990s.
+        #
+        # Everything else keeps `to_i`, deliberately. The 21 legacy 4-digit
+        # `MMDD` dates carry no year and cannot be ordered against a real one
+        # at all; as small integers they land below every dated row and above
+        # an undated one, which is where `to_i` already put them.
+        #
+        # @param date [String, nil]
+        # @return [Integer]
+        #
+        def date_key(date)
+          str = date.to_s
+          str.length == 6 ? "19#{str}".to_i : str.to_i
+        end
+
+        #
+        # The narrowed range cannot serve a reference whose slug differs from
+        # the row's only by case: the bsearch key is case-sensitive. The
+        # bespoke `PubId#==` compared its `code` with `casecmp?`, so a full
+        # scan repeats the match case-insensitively rather than lose that.
+        # (The BIPM `search_index` precedent.)
+        #
+        # @param row_id [Pubid::W3c::Identifier]
+        # @param pubid [Pubid::W3c::Identifier]
+        # @return [Boolean]
+        #
+        def loose_match?(row_id, pubid)
+          row_id.instance_of?(pubid.class) &&
+            row_id.number.to_s.casecmp?(pubid.number.to_s) &&
+            (pubid.date.nil? || row_id.date == pubid.date)
+        end
+
+        #
+        # The machine index on the Pages site (relaton#189, W3C is the pilot).
+        # A parsed query reads only its own shard; the whole index is read, in
+        # memory, only by the case-insensitive fallback in `#best_match`.
+        # A Pages failure raises `Relaton::RequestError`, with no fallback to
+        # the `index-v2.zip` in the data repo.
+        #
+        def index
+          Relaton::Index.find_or_create(
+            :W3C, pages_url: PAGES_URL, pubid_class: ::Pubid::W3c::Identifier
+          )
+        end
+
+        #
+        # Parse a user reference into a `Pubid::W3c::Identifier`, or nil.
+        #
+        # A search string is a query, not a document identifier field, so it
+        # does not go through `Docidentifier`: it has to absorb two forms the
+        # bespoke regex accepted and a pubid grammar should not. A URL is not
+        # an identifier (`https://www.w3.org/TR/xml-names/`), and `TR` is a
+        # path segment of that URL rather than a maturity level, so
+        # `TR-vocab-adms` means the document `vocab-adms`. The publisher
+        # prefix is added when absent, because `Pubid::W3c` requires it.
+        #
+        # @param text [String]
+        # @return [Pubid::W3c::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(text)
+          ::Pubid::W3c::Identifier.parse normalize_ref(text)
+        end
+
+        def normalize_ref(text)
+          ref = text.to_s.strip
+            .sub(%r{\Ahttps?://[^/]+/}i, "") # a URL is not an identifier
+            .sub(/\AW3C\s+/i, "")
+            .sub(%r{\ATR[/-]}i, "")          # URL path segment, not a stage
+            .sub(%r{/\z}, "")
+          "W3C #{ref}"
+        end
+
+        # @param ref [String, Pubid::W3c::Identifier] the W3C standard Code
+        #   to look up, or its parsed identifier
+        # @param year [String, NilClass] not used
+        # @param opts [Hash] options
+        # @return [Relaton::W3c::ItemData]
+        def get(ref, _year = nil, _opts = {})
+          key = ref.to_s
+          Util.info "Fetching from Relaton repository ...", key: key
+          result = search(ref)
+          unless result
+            Util.info "Not found.", key: key
+            return
+          end
+
+          found = result.docidentifier.first.content
+          Util.info "Found: `#{found}`", key: key
+          result
+        end
+      end
+    end
+  end
+end