ed-precompiled_msgpack 1.8.0-arm64-darwin

data/ext/msgpack/unpacker_ext_registry.h

@@ -0,0 +1,62 @@
+/*
+ * MessagePack for Ruby
+ *
+ * Copyright (C) 2008-2015 Sadayuki Furuhashi
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *        http://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License is distributed on an "AS IS" BASIS,
+ *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ *    See the License for the specific language governing permissions and
+ *    limitations under the License.
+ */
+#ifndef MSGPACK_RUBY_UNPACKER_EXT_REGISTRY_H__
+#define MSGPACK_RUBY_UNPACKER_EXT_REGISTRY_H__
+
+#include "compat.h"
+#include "ruby.h"
+
+#define MSGPACK_EXT_RECURSIVE 0b0001
+
+struct msgpack_unpacker_ext_registry_t;
+typedef struct msgpack_unpacker_ext_registry_t msgpack_unpacker_ext_registry_t;
+
+struct msgpack_unpacker_ext_registry_t {
+    unsigned int borrow_count;
+    VALUE array[256];
+};
+
+void msgpack_unpacker_ext_registry_release(msgpack_unpacker_ext_registry_t* ukrg);
+
+static inline void msgpack_unpacker_ext_registry_borrow(msgpack_unpacker_ext_registry_t* src, msgpack_unpacker_ext_registry_t** dst)
+{
+    if (src) {
+        src->borrow_count++;
+        *dst = src;
+    }
+}
+
+void msgpack_unpacker_ext_registry_mark(msgpack_unpacker_ext_registry_t* ukrg);
+
+void msgpack_unpacker_ext_registry_put(VALUE owner, msgpack_unpacker_ext_registry_t** ukrg,
+        VALUE ext_module, int ext_type, int flags, VALUE proc);
+
+static inline VALUE msgpack_unpacker_ext_registry_lookup(msgpack_unpacker_ext_registry_t* ukrg,
+        int ext_type, int* ext_flags_result)
+{
+    if (ukrg) {
+        VALUE entry = ukrg->array[ext_type + 128];
+        if (entry != Qnil) {
+            *ext_flags_result = FIX2INT(rb_ary_entry(entry, 2));
+            return rb_ary_entry(entry, 1);
+        }
+    }
+    return Qnil;
+}
+
+#endif

data/lib/msgpack/bigint.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module MessagePack
+  module Bigint
+    # We split the bigint in 32bits chunks so that individual part fits into
+    # a MRI immediate Integer.
+    CHUNK_BITLENGTH = 32
+    FORMAT = 'CL>*'
+
+    if Integer.instance_method(:[]).arity != 1 # Ruby 2.7 and newer
+      # Starting from Ruby 2.7 we can address arbitrary bitranges inside an Integer with Integer#[]
+      # This allows to not allocate any Integer.
+      def self.to_msgpack_ext(bigint)
+        members = []
+
+        if bigint < 0
+          bigint = -bigint
+          members << 1
+        else
+          members << 0
+        end
+
+        offset = 0
+        length = bigint.bit_length
+        while offset < length
+          members << bigint[offset, CHUNK_BITLENGTH]
+          offset += CHUNK_BITLENGTH
+        end
+
+        members.pack(FORMAT)
+      end
+    else
+      # On 2.6 and older since we can't address arbitrary bitranges, so we fallback to shifting the bigint.
+      # This means that after each shift, we may allocate another Integer instance.
+      BASE = (2**CHUNK_BITLENGTH) - 1
+      def self.to_msgpack_ext(bigint)
+        members = []
+
+        if bigint < 0
+          bigint = -bigint
+          members << 1
+        else
+          members << 0
+        end
+
+        while bigint > 0
+          members << (bigint & BASE)
+          bigint = bigint >> CHUNK_BITLENGTH
+        end
+
+        members.pack(FORMAT)
+      end
+    end
+
+    def self.from_msgpack_ext(data)
+      parts = data.unpack(FORMAT)
+
+      sign = parts.shift
+      sum = parts.pop.to_i
+
+      parts.reverse_each do |part|
+        sum = sum << CHUNK_BITLENGTH
+        sum += part
+      end
+
+      sign == 0 ? sum : -sum
+    end
+  end
+end

data/lib/msgpack/buffer.rb

@@ -0,0 +1,9 @@
+module MessagePack
+  class Buffer
+    # see ext for other methods
+
+    # The semantic of duping a buffer is just too weird.
+    undef_method :dup
+    undef_method :clone
+  end
+end

data/lib/msgpack/core_ext.rb

@@ -0,0 +1,139 @@
+module MessagePack
+  module CoreExt
+    def to_msgpack(packer_or_io = nil)
+      if packer_or_io
+        if packer_or_io.is_a?(MessagePack::Packer)
+          to_msgpack_with_packer packer_or_io
+        else
+          MessagePack.pack(self, packer_or_io)
+        end
+      else
+        MessagePack.pack(self)
+      end
+    end
+  end
+end
+
+class NilClass
+  include MessagePack::CoreExt
+
+  private
+  def to_msgpack_with_packer(packer)
+    packer.write_nil
+    packer
+  end
+end
+
+class TrueClass
+  include MessagePack::CoreExt
+
+  private
+  def to_msgpack_with_packer(packer)
+    packer.write_true
+    packer
+  end
+end
+
+class FalseClass
+  include MessagePack::CoreExt
+
+  private
+  def to_msgpack_with_packer(packer)
+    packer.write_false
+    packer
+  end
+end
+
+class Float
+  include MessagePack::CoreExt
+
+  private
+  def to_msgpack_with_packer(packer)
+    packer.write_float self
+    packer
+  end
+end
+
+class String
+  include MessagePack::CoreExt
+
+  private
+  def to_msgpack_with_packer(packer)
+    packer.write_string self
+    packer
+  end
+end
+
+class Array
+  include MessagePack::CoreExt
+
+  private
+  def to_msgpack_with_packer(packer)
+    packer.write_array self
+    packer
+  end
+end
+
+class Hash
+  include MessagePack::CoreExt
+
+  private
+  def to_msgpack_with_packer(packer)
+    packer.write_hash self
+    packer
+  end
+end
+
+class Symbol
+  include MessagePack::CoreExt
+
+  private
+  def to_msgpack_with_packer(packer)
+    packer.write_symbol self
+    packer
+  end
+end
+
+if 1.class.name == "Integer"
+  class Integer
+    include MessagePack::CoreExt
+
+    private
+    def to_msgpack_with_packer(packer)
+      packer.write_int self
+      packer
+    end
+  end
+else
+  class Fixnum
+    include MessagePack::CoreExt
+
+    private
+    def to_msgpack_with_packer(packer)
+      packer.write_int self
+      packer
+    end
+  end
+
+  class Bignum
+    include MessagePack::CoreExt
+
+    private
+    def to_msgpack_with_packer(packer)
+      packer.write_int self
+      packer
+    end
+  end
+end
+
+module MessagePack
+  class ExtensionValue
+    include CoreExt
+
+    private
+    def to_msgpack_with_packer(packer)
+      packer.write_extension self
+      packer
+    end
+  end
+end

data/lib/msgpack/factory.rb

@@ -0,0 +1,211 @@
+module MessagePack
+  class Factory
+    # see ext for other methods
+
+    def register_type(type, klass, options = { packer: :to_msgpack_ext, unpacker: :from_msgpack_ext })
+      raise FrozenError, "can't modify frozen MessagePack::Factory" if frozen?
+
+      if options
+        options = options.dup
+        case packer = options[:packer]
+        when nil, Proc
+          # all good
+        when String, Symbol
+          options[:packer] = packer.to_sym.to_proc
+        when Method
+          options[:packer] = packer.to_proc
+        when packer.respond_to?(:call)
+          options[:packer] = packer.method(:call).to_proc
+        else
+          raise ::TypeError, "expected :packer argument to be a callable object, got: #{packer.inspect}"
+        end
+
+        case unpacker = options[:unpacker]
+        when nil, Proc
+          # all good
+        when String, Symbol
+          options[:unpacker] = klass.method(unpacker).to_proc
+        when Method
+          options[:unpacker] = unpacker.to_proc
+        when packer.respond_to?(:call)
+          options[:unpacker] = unpacker.method(:call).to_proc
+        else
+          raise ::TypeError, "expected :unpacker argument to be a callable object, got: #{unpacker.inspect}"
+        end
+      end
+
+      register_type_internal(type, klass, options)
+    end
+
+    # [ {type: id, class: Class(or nil), packer: arg, unpacker: arg}, ... ]
+    def registered_types(selector=:both)
+      packer, unpacker = registered_types_internal
+      # packer: Class -> [tid, proc, _flags]
+      # unpacker: tid -> [klass, proc, _flags]
+
+      list = []
+
+      case selector
+      when :both
+        packer.each_pair do |klass, ary|
+          type = ary[0]
+          packer_proc = ary[1]
+          unpacker_proc = nil
+          if unpacker.has_key?(type)
+            unpacker_proc = unpacker.delete(type)[1]
+          end
+          list << {type: type, class: klass, packer: packer_proc, unpacker: unpacker_proc}
+        end
+
+        # unpacker definition only
+        unpacker.each_pair do |type, ary|
+          list << {type: type, class: ary[0], packer: nil, unpacker: ary[1]}
+        end
+
+      when :packer
+        packer.each_pair do |klass, ary|
+          if ary[1]
+            list << {type: ary[0], class: klass, packer: ary[1]}
+          end
+        end
+
+      when :unpacker
+        unpacker.each_pair do |type, ary|
+          if ary[1]
+            list << {type: type, class: ary[0], unpacker: ary[1]}
+          end
+        end
+
+      else
+        raise ArgumentError, "invalid selector #{selector}"
+      end
+
+      list.sort{|a, b| a[:type] <=> b[:type] }
+    end
+
+    def type_registered?(klass_or_type, selector=:both)
+      case klass_or_type
+      when Class
+        klass = klass_or_type
+        registered_types(selector).any?{|entry| klass <= entry[:class] }
+      when Integer
+        type = klass_or_type
+        registered_types(selector).any?{|entry| type == entry[:type] }
+      else
+        raise ArgumentError, "class or type id"
+      end
+    end
+
+    def load(src, param = nil)
+      unpacker = nil
+
+      if src.is_a? String
+        unpacker = unpacker(param)
+        unpacker.feed(src)
+      else
+        unpacker = unpacker(src, param)
+      end
+
+      unpacker.full_unpack
+    end
+    alias :unpack :load
+
+    def dump(v, *rest)
+      packer = packer(*rest)
+      packer.write(v)
+      packer.full_pack
+    end
+    alias :pack :dump
+
+    def pool(size = 1, **options)
+      Pool.new(
+        frozen? ? self : dup.freeze,
+        size,
+        options.empty? ? nil : options,
+      )
+    end
+
+    class Pool
+      if RUBY_ENGINE == "ruby"
+        class MemberPool
+          def initialize(size, &block)
+            @size = size
+            @new_member = block
+            @members = []
+          end
+
+          def with
+            member = @members.pop || @new_member.call
+            begin
+              yield member
+            ensure
+              # If the pool is already full, we simply drop the extra member.
+              # This is because contrary to a connection pool, creating an extra instance
+              # is extremely unlikely to cause some kind of resource exhaustion.
+              #
+              # We could cycle the members (keep the newer one) but first It's more work and second
+              # the older member might have been created pre-fork, so it might be at least partially
+              # in shared memory.
+              if member && @members.size < @size
+                member.reset
+                @members << member
+              end
+            end
+          end
+        end
+      else
+        class MemberPool
+          def initialize(size, &block)
+            @size = size
+            @new_member = block
+            @members = []
+            @mutex = Mutex.new
+          end
+
+          def with
+            member = @mutex.synchronize { @members.pop } || @new_member.call
+            begin
+              yield member
+            ensure
+              member.reset
+              @mutex.synchronize do
+                if member && @members.size < @size
+                  @members << member
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def initialize(factory, size, options = nil)
+        options = nil if !options || options.empty?
+        @factory = factory
+        @packers = MemberPool.new(size) { factory.packer(options).freeze }
+        @unpackers = MemberPool.new(size) { factory.unpacker(options).freeze }
+      end
+
+      def load(data)
+        @unpackers.with do |unpacker|
+          unpacker.feed(data)
+          unpacker.full_unpack
+        end
+      end
+
+      def dump(object)
+        @packers.with do |packer|
+          packer.write(object)
+          packer.full_pack
+        end
+      end
+
+      def unpacker(&block)
+        @unpackers.with(&block)
+      end
+
+      def packer(&block)
+        @packers.with(&block)
+      end
+    end
+  end
+end

data/lib/msgpack/packer.rb

@@ -0,0 +1,37 @@
+module MessagePack
+  class Packer
+    # see ext for other methods
+
+    # The semantic of duping a packer is just too weird.
+    undef_method :dup
+    undef_method :clone
+
+    def register_type(type, klass, method_name = nil, &block)
+      raise ArgumentError, "expected Module/Class got: #{klass.inspect}" unless klass.is_a?(Module)
+      register_type_internal(type, klass, block || method_name.to_proc)
+    end
+
+    def registered_types
+      list = []
+
+      registered_types_internal.each_pair do |klass, ary|
+        list << {type: ary[0], class: klass, packer: ary[1]}
+      end
+
+      list.sort{|a, b| a[:type] <=> b[:type] }
+    end
+
+    def type_registered?(klass_or_type)
+      case klass_or_type
+      when Class
+        klass = klass_or_type
+        registered_types.any?{|entry| klass <= entry[:class] }
+      when Integer
+        type = klass_or_type
+        registered_types.any?{|entry| type == entry[:type] }
+      else
+        raise ArgumentError, "class or type id"
+      end
+    end
+  end
+end

data/lib/msgpack/symbol.rb

@@ -0,0 +1,26 @@
+class Symbol
+  # to_msgpack_ext is supposed to return a binary string.
+  # The canonical way to do it for symbols would be:
+  #  [to_s].pack('A*')
+  # However in this instance we can take a shortcut
+  if method_defined?(:name)
+    alias_method :to_msgpack_ext, :name
+  else
+    alias_method :to_msgpack_ext, :to_s
+  end
+
+  def self.from_msgpack_ext(data)
+    # from_msgpack_ext is supposed to parse a binary string.
+    # The canonical way to do it for symbols would be:
+    #  data.unpack1('A*').to_sym
+    # However in this instance we can take a shortcut
+
+    # We assume the string encoding is UTF-8, and let Ruby create either
+    # an ASCII symbol or UTF-8 symbol.
+    data.force_encoding(Encoding::UTF_8).to_sym
+  rescue EncodingError
+    # If somehow the string wasn't valid UTF-8 not valid ASCII, we fallback
+    # to what has been the historical behavior of creating a binary symbol
+    data.force_encoding(Encoding::BINARY).to_sym
+  end
+end

data/lib/msgpack/time.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# MessagePack extention packer and unpacker for built-in Time class
+module MessagePack
+  module Time
+    # 3-arg Time.at is available Ruby >= 2.5
+    TIME_AT_3_AVAILABLE = begin
+                            !!::Time.at(0, 0, :nanosecond)
+                          rescue ArgumentError
+                            false
+                          end
+
+    Unpacker = if TIME_AT_3_AVAILABLE
+                 lambda do |payload|
+                   tv = MessagePack::Timestamp.from_msgpack_ext(payload)
+                   ::Time.at(tv.sec, tv.nsec, :nanosecond)
+                 end
+               else
+                 lambda do |payload|
+                   tv = MessagePack::Timestamp.from_msgpack_ext(payload)
+                   ::Time.at(tv.sec, tv.nsec / 1000.0r)
+                 end
+               end
+
+    Packer = lambda { |time|
+      MessagePack::Timestamp.to_msgpack_ext(time.tv_sec, time.tv_nsec)
+    }
+  end
+end

data/lib/msgpack/timestamp.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module MessagePack
+  class Timestamp # a.k.a. "TimeSpec"
+    # Because the byte-order of MessagePack is big-endian in,
+    # pack() and unpack() specifies ">".
+    # See https://docs.ruby-lang.org/en/trunk/Array.html#method-i-pack for details.
+
+    # The timestamp extension type defined in the MessagePack spec.
+    # See https://github.com/msgpack/msgpack/blob/master/spec.md#timestamp-extension-type for details.
+    TYPE = -1
+
+    TIMESTAMP32_MAX_SEC = (1 << 32) - 1
+    TIMESTAMP64_MAX_SEC = (1 << 34) - 1
+
+    # @return [Integer]
+    attr_reader :sec
+
+    # @return [Integer]
+    attr_reader :nsec
+
+    # @param [Integer] sec
+    # @param [Integer] nsec
+    def initialize(sec, nsec)
+      @sec = sec
+      @nsec = nsec
+    end
+
+    def self.from_msgpack_ext(data)
+      case data.length
+      when 4
+        # timestamp32 (sec: uint32be)
+        sec, = data.unpack('L>')
+        new(sec, 0)
+      when 8
+        # timestamp64 (nsec: uint30be, sec: uint34be)
+        n, s = data.unpack('L>2')
+        sec = ((n & 0b11) << 32) | s
+        nsec = n >> 2
+        new(sec, nsec)
+      when 12
+        # timestam96 (nsec: uint32be, sec: int64be)
+        nsec, sec = data.unpack('L>q>')
+        new(sec, nsec)
+      else
+        raise MalformedFormatError, "Invalid timestamp data size: #{data.length}"
+      end
+    end
+
+    def self.to_msgpack_ext(sec, nsec)
+      if sec >= 0 && nsec >= 0 && sec <= TIMESTAMP64_MAX_SEC
+        if nsec === 0 && sec <= TIMESTAMP32_MAX_SEC
+          # timestamp32 = (sec: uint32be)
+          [sec].pack('L>')
+        else
+          # timestamp64 (nsec: uint30be, sec: uint34be)
+          nsec30 = nsec << 2
+          sec_high2 = sec >> 32 # high 2 bits (`x & 0b11` is redandunt)
+          sec_low32 = sec & 0xffffffff # low 32 bits
+          [nsec30 | sec_high2, sec_low32].pack('L>2')
+        end
+      else
+        # timestamp96 (nsec: uint32be, sec: int64be)
+        [nsec, sec].pack('L>q>')
+      end
+    end
+
+    def to_msgpack_ext
+      self.class.to_msgpack_ext(sec, nsec)
+    end
+
+    def ==(other)
+      other.class == self.class && sec == other.sec && nsec == other.nsec
+    end
+  end
+end