tarantool 0.4.2.1 → 0.4.3

data/lib/tarantool/request.rb

@@ -83,7 +83,7 @@ module Tarantool
         if index_no != :space && nili = key.index(nil)
           key = key.slice(0, nili)
         end
-        body << [key_size = key.size].pack(INT32)
+        ::BinUtils.append_int32_le!(body, key_size = key.size)
         i = 0
         while i < key_size
           field = types[i] || get_tail_item(types, i, tail)
@@ -110,50 +110,50 @@ module Tarantool
       when :int, :integer
         value = value.to_i
         _raise_integer_overflow(value, MIN_INT, MAX_INT32)  if value > MAX_INT32 or value < 0
-        append_ber_int32!(body, value)
+        ::BinUtils.append_bersize_int32_le!(body, value)
       when :string, :bytes, :str
         value = value.to_s
         value = ZERO + value  if value < ONE
         raise StringTooLong  if value.bytesize >= MAX_BYTE_SIZE
-        body << [value.bytesize, value].pack(PACK_STRING)
+        ::BinUtils.append_bersize_string!(body, value)
       when :bytes
         value = value.to_s
         raise StringTooLong  if value.bytesize >= MAX_BYTE_SIZE
-        body << [value.bytesize, value].pack(PACK_STRING)
+        ::BinUtils.append_bersize_string!(body, value)
       when :int64
         value = value.to_i
         _raise_integer_overflow(value, MIN_INT, MAX_INT64)  if value > MAX_INT64 or value < 0
-        append_ber_int64!(body, value)
+        ::BinUtils.append_bersize_int64_le!(body, value)
       when :int16
         value = value.to_i
         _raise_integer_overflow(value, MIN_INT, MAX_INT16)  if value > MAX_INT16 or value < 0
-        append_ber_int16!(body, value)
+        ::BinUtils.append_bersize_int16_le!(body, value)
       when :int8
         value = value.to_i
         _raise_integer_overflow(value, MIN_INT, MAX_INT8)  if value > MAX_INT8 or value < 0
-        append_ber_int8!(body, value)
+        ::BinUtils.append_bersize_int8!(body, value)
       when :sint
         value = value.to_i
         _raise_integer_overflow(value, MIN_SINT32, MAX_SINT32)  if value > MAX_SINT32 or value < MIN_SINT32
-        append_ber_sint32!(body, value)
+        ::BinUtils.append_bersize_sint32_le!(body, value)
       when :sint64
         value = value.to_i
         _raise_integer_overflow(value, MIN_SINT64, MAX_SINT64)  if value > MAX_SINT64 or value < MIN_SINT64
-        append_ber_sint64!(body, value)
+        ::BinUtils.append_bersize_sint64_le!(body, value)
       when :sint16
         value = value.to_i
         _raise_integer_overflow(value, MIN_SINT16, MAX_SINT16)  if value > MAX_SINT16 or value < MIN_SINT16
-        append_ber_sint16!(body, value)
+        ::BinUtils.append_bersize_sint16_le!(body, value)
       when :sint8
         value = value.to_i
         _raise_integer_overflow(value, MIN_SINT8, MAX_SINT8)  if value > MAX_SINT8 or value < MIN_SINT8
-        append_ber_sint8!(body, value)
+        ::BinUtils.append_bersize_sint8!(body, value)
       when :varint
         value = value.to_i
         if 0 <= value && value < MAX_INT32
-          append_ber_int32!(body, value)
+          ::BinUtils.append_bersize_int32_le!(body, value)
         else
-          append_ber_sint64!(body, value)
+          ::BinUtils.append_bersize_sint64_le!(body, value)
         end
       when :error
         raise IndexIndexError
@@ -171,7 +171,7 @@ module Tarantool
       else
         value = get_serializer(field_kind).encode(value).to_s
         raise StringTooLong  if value.bytesize > MAX_BYTE_SIZE
-        body << [value.bytesize, value].pack(PACK_STRING)
+        ::BinUtils.append_bersize_string!(body, value)
       end
     end
 
@@ -206,7 +206,7 @@ module Tarantool
 
       body = [space_no, flags].pack(UPDATE_HEADER)
       pack_tuple(body, pk, pk_fields, 0)
-      append_int32!(body, operations.size)
+      ::BinUtils.append_int32_le!(body, operations.size)
 
       _pack_operations(body, operations, fields)
 
@@ -276,10 +276,10 @@ module Tarantool
           end
 
           str = operation[4].to_s
-          body << [ 10 + ber_size(str.bytesize) + str.bytesize ].pack('w')
-          append_ber_sint32!(body, operation[2].to_i)
-          append_ber_sint32!(body, operation[3].to_i)
-          body << [str.bytesize, str.to_s].pack(PACK_STRING)
+          ::BinUtils.append_ber!(body, 10 + ber_size(str.bytesize) + str.bytesize)
+          ::BinUtils.append_bersize_sint32_le!(body, operation[2].to_i)
+          ::BinUtils.append_bersize_sint32_le!(body, operation[3].to_i)
+          ::BinUtils.append_bersize_string!(body, str.to_s)
         when 7
           old_field_no = field_no + 
             (inserted ||= []).count{|i| i <= field_no} -

data/lib/tarantool/response.rb

@@ -8,7 +8,7 @@ module Tarantool
     def _parse_iproto(data)
       if Exception === data || data == ''
         data
-      elsif (ret = unpack_int32!(data)) == 0
+      elsif (ret = ::BinUtils.slice_int32_le!(data)) == 0
         data
       else
         data.gsub!("\x00", "")
@@ -47,7 +47,7 @@ module Tarantool
     def parse_response(data)
       return data  if Exception === data
       unless get_tuples
-        unpack_int32(data)
+        ::BinUtils.get_int32_le(data)
       else
         tuples = unpack_tuples(data)
         if translators
@@ -60,7 +60,7 @@ module Tarantool
     end
 
     def unpack_tuples(data)
-      tuples_affected = unpack_int32!(data)
+      tuples_affected = ::BinUtils.slice_int32_le!(data)
       tuples = []
       fields = fields()
       if Integer === fields.last
@@ -70,13 +70,13 @@ module Tarantool
       end
 
       while tuples_affected > 0
-        byte_size = unpack_int32!(data)
-        fields_num = unpack_int32!(data)
+        byte_size = ::BinUtils.slice_int32_le!(data)
+        fields_num = ::BinUtils.slice_int32_le!(data)
         tuple_str = data.slice!(0, byte_size)
         i = 0
         tuple = []
         while i < fields_num
-          field_size = unpack_ber!(tuple_str)
+          field_size = ::BinUtils.slice_ber!(tuple_str)
 
           field = fields[i] || get_tail_item(fields, i, tail)
 
@@ -86,7 +86,7 @@ module Tarantool
               if field_size != 4
                 raise ValueError, "Bad field size #{field_size} for integer field ##{i}"
               end
-              unpack_int32!(tuple_str)
+              ::BinUtils.slice_int32_le!(tuple_str)
             when :string, :str
               str = tuple_str.slice!(0, field_size)
               str[0,1] = EMPTY  if str < ONE
@@ -95,47 +95,47 @@ module Tarantool
               if field_size != 8
                 raise ValueError, "Bad field size #{field_size} for 64bit integer field ##{i}"
               end
-              unpack_int64!(tuple_str)
+              ::BinUtils.slice_int64_le!(tuple_str)
             when :bytes
               tuple_str.slice!(0, field_size)
             when :int16
               if field_size != 2
                 raise ValueError, "Bad field size #{field_size} for 16bit integer field ##{i}"
               end
-              unpack_int16!(tuple_str)
+              ::BinUtils.slice_int16_le!(tuple_str)
             when :int8
               if field_size != 1
                 raise ValueError, "Bad field size #{field_size} for 8bit integer field ##{i}"
               end
-              unpack_int8!(tuple_str)
+              ::BinUtils.slice_int8!(tuple_str)
             when :sint
               if field_size != 4
                 raise ValueError, "Bad field size #{field_size} for integer field ##{i}"
               end
-              unpack_sint32!(tuple_str)
+              ::BinUtils.slice_sint32_le!(tuple_str)
             when :sint64
               if field_size != 8
                 raise ValueError, "Bad field size #{field_size} for 64bit integer field ##{i}"
               end
-              unpack_sint64!(tuple_str)
+              ::BinUtils.slice_sint64_le!(tuple_str)
             when :sint16
               if field_size != 2
                 raise ValueError, "Bad field size #{field_size} for 16bit integer field ##{i}"
               end
-              unpack_sint16!(tuple_str)
+              ::BinUtils.slice_sint16_le!(tuple_str)
             when :sint8
               if field_size != 1
                 raise ValueError, "Bad field size #{field_size} for 8bit integer field ##{i}"
               end
-              unpack_sint8!(tuple_str)
+              ::BinUtils.slice_sint8!(tuple_str)
             when :varint
               case field_size
               when 8
-                unpack_int64!(tuple_str)
+                ::BinUtils.slice_int64_le!(tuple_str)
               when 4
-                unpack_int32!(tuple_str)
+                ::BinUtils.slice_int32_le!(tuple_str)
               when 2
-                unpack_int16!(tuple_str)
+                ::BinUtils.slice_int16_le!(tuple_str)
               else
                 raise ValueError, "Bad field size #{field_size} for integer field ##{i}"
               end
@@ -159,7 +159,7 @@ module Tarantool
     end
 
     def return_code(data)
-      unpack_int32!(data)
+      ::BinUtils.slice_int32_le!(data)
     end
   end
 

data/lib/tarantool/util.rb

@@ -1,3 +1,4 @@
+require 'bin_utils'
 module Tarantool
   module Util
     module Packer
@@ -25,131 +26,12 @@ module Tarantool
     private
       EMPTY = ''.freeze
       ONE = "\x01".freeze
-      def unpack_int8!(data)
-        int = data.getbyte(0)
-        data[0, 1] = EMPTY
-        int
-      end
-
-      def unpack_int16(data)
-        data.getbyte(0) + data.getbyte(1) * 256
-      end
-
-      def unpack_int16!(data)
-        int = data.getbyte(0) + data.getbyte(1) * 256
-        data[0, 2] = EMPTY
-        int
-      end
-
-      def unpack_int32(int)
-        (int.getbyte(0) + int.getbyte(1) * 256 +
-         int.getbyte(2) * 65536 + int.getbyte(3) * 16777216)
-      end
-
-      def unpack_int32!(data)
-        int = (data.getbyte(0) + data.getbyte(1) * 256 +
-               data.getbyte(2) * 65536 + data.getbyte(3) * 16777216)
-        data[0, 4] = EMPTY
-        int
-      end
-
-      def unpack_int64!(data)
-        int = data.unpack(INT64)[0]
-        data[0, 8] = EMPTY
-        int
-      end
-
-      def unpack_int64(data)
-        data.unpack(INT64)[0]
-      end
-
-      def unpack_sint8!(data)
-        i = unpack_int8!(data)
-        i - ((i & 128) << 1)
-      end
-
-      def unpack_sint16!(data)
-        i = unpack_int16!(data)
-        i - ((i & 32768) << 1)
-      end
-
-      def unpack_sint32!(data)
-        i = unpack_int32!(data)
-        i - ((i >> 31) << 32)
-      end
-
-      def unpack_sint64!(data)
-        i = unpack_int64!(data)
-        i - ((i >> 63) << 64)
-      end
-
       def ber_size(int)
         int < 128 ? 1 :
         int < 16384 ? 2 :
         int < 2097153 ? 3 :
         int < 268435456 ? 4 : 5
       end
-
-      def unpack_ber!(data)
-        res = 0
-        pos = 0
-        while true
-          if (byte = data.getbyte(pos)) <= 127
-            res += byte
-            break
-          else
-            res = (res + (byte - 128)) * 128
-            pos += 1
-          end
-        end
-        data[0, pos+1] = EMPTY
-        res
-      end
-
-      def append_int8!(str, int)
-        str << (int & 255)
-      end
-
-      def append_int16!(str, int)
-        str << (int & 255) << ((int>>8) & 255)
-      end
-
-      def append_int32!(str, int)
-        str << (int & 255) << ((int>>8) & 255) <<
-               ((int>>16) & 255) << ((int>>24) & 255)
-      end
-
-      def append_int64!(str, int)
-        str << [int].pack(INT64)
-      end
-
-      alias append_sint8! append_int8!
-      alias append_sint16! append_int16!
-      alias append_sint32! append_int32!
-      alias append_sint64! append_int64!
-
-      def append_ber_int8!(str, int)
-        str << 1 << (int & 255)
-      end
-
-      def append_ber_int16!(str, int)
-        str << 2 << (int & 255) << ((int>>8) & 255)
-      end
-
-      def append_ber_int32!(str, int)
-        str << 4 <<
-                (int & 255) << ((int>>8) & 255) <<
-               ((int>>16) & 255) << ((int>>24) & 255)
-      end
-
-      def append_ber_int64!(str, int)
-        str << 8 << [int].pack(INT64)
-      end
-
-      alias append_ber_sint8! append_ber_int8!
-      alias append_ber_sint16! append_ber_int16!
-      alias append_ber_sint32! append_ber_int32!
-      alias append_ber_sint64! append_ber_int64!
     end
 
     module TailGetter
@@ -179,11 +61,11 @@ module Tarantool
       def to_int
         case @data.bytesize
         when 8
-          unpack_int64(@data)
+          ::BinUtils.get_int64_le(@data)
         when 4
-          unpack_int32(@data)
+          ::BinUtils.get_int32_le(@data)
         when 2
-          unpack_int16(@data)
+          ::BinUtils.get_int16_le(@data)
         else
           raise ValueError, "Bad field size #{field_size} for integer field ##{i}"
         end

data/lib/tarantool/version.rb

@@ -1,4 +1,4 @@
 module Tarantool
-  VERSION = "0.4.2.1"
-  RECORD_VERSION = "0.4.1.1"
+  VERSION = "0.4.3"
+  RECORD_VERSION = "0.4.1.2"
 end

data/test/shared_record.rb

@@ -3,12 +3,13 @@ require 'yajl'
 require 'tarantool/serializers/bson'
 
 shared_examples_for :record do
-  DB = Tarantool.new(TCONFIG.merge(type: :block))
+  let(:db){ Tarantool.new(TCONFIG.merge(type: :block)) }
   before{ truncate }
 
   let(:user_class) do
+    db = db()
     Class.new(base_class) do
-      set_tarantool DB
+      set_tarantool db
       set_space_no 0
 
       def self.name # For naming
@@ -24,8 +25,9 @@ shared_examples_for :record do
   end
 
   let(:second_class) do
+    db = db()
     Class.new(base_class) do
-      set_tarantool DB
+      set_tarantool db
       set_space_no 1
 
       def self.name # For naming
@@ -360,13 +362,13 @@ shared_examples_for :record do
       second_class.insert(id: 100).must_equal 1
       obj = second_class.by_pk(100)
       obj.attributes.must_equal({id: 100, count1: nil, count2: nil})
-      tuple = DB.space(1, [:int, :int, :int], keys: 0).by_pk(100)
+      tuple = db.space(1, [:int, :int, :int], keys: 0).by_pk(100)
       tuple.must_equal([100, nil, nil])
 
       second_class.insert(id: 101, count2: 102).must_equal 1
       obj = second_class.by_pk(101)
       obj.attributes.must_equal({id: 101, count1: nil, count2: 102})
-      tuple = DB.space(1, [:int, :int, :int], keys: 0).by_pk(101)
+      tuple = db.space(1, [:int, :int, :int], keys: 0).by_pk(101)
       tuple.must_equal([101, nil, 102])
     end
 
@@ -474,8 +476,9 @@ shared_examples_for :record do
 
   describe "composite primary key" do
     let(:address_class) do
+      db = db()
       Class.new(base_class) do
-        set_tarantool DB
+        set_tarantool db
         set_space_no 2
 
         def self.name # For naming

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tarantool
 version: !ruby/object:Gem::Version
-  version: 0.4.2.1
+  version: 0.4.3
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-04 00:00:00.000000000 Z
+date: 2012-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: iproto
@@ -60,6 +60,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 0.0.2
+- !ruby/object:Gem::Dependency
+  name: bin_utils
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.1
 description: Tarantool KV-storage client.
 email:
 - ceo@prepor.ru