cql-rb 1.0.0.pre5 → 1.0.0.pre6

data/lib/cql/protocol/encoding.rb

@@ -16,15 +16,13 @@ module Cql
       def write_string(buffer, str)
         str = str.to_s
         buffer << [str.bytesize].pack(Formats::SHORT_FORMAT)
-        buffer << binary_cast(str)
-        buffer.force_encoding(::Encoding::BINARY)
+        buffer << str
         buffer
       end
 
       def write_long_string(buffer, str)
         buffer << [str.bytesize].pack(Formats::INT_FORMAT)
-        buffer << binary_cast(str)
-        buffer.force_encoding(::Encoding::BINARY)
+        buffer << str
         buffer
       end
 
@@ -43,22 +41,20 @@ module Cql
       def write_bytes(buffer, bytes)
         if bytes
           write_int(buffer, bytes.bytesize)
-          buffer << binary_cast(bytes)
+          buffer << bytes
         else
           write_int(buffer, -1)
         end
-        buffer.force_encoding(::Encoding::BINARY)
         buffer
       end
 
       def write_short_bytes(buffer, bytes)
         if bytes
           write_short(buffer, bytes.bytesize)
-          buffer << binary_cast(bytes)
+          buffer << bytes
         else
           write_short(buffer, -1)
         end
-        buffer.force_encoding(::Encoding::BINARY)
         buffer
       end
 
@@ -109,13 +105,6 @@ module Cql
       def write_float(buffer, n)
         buffer << [n].pack(Formats::FLOAT_FORMAT)
       end
-
-      private
-
-      def binary_cast(str)
-        return str if str.ascii_only?
-        str.dup.force_encoding(::Encoding::BINARY)
-      end
     end
   end
 end

data/lib/cql/protocol/request_frame.rb

@@ -10,9 +10,9 @@ module Cql
       end
 
       def write(io)
-        buffer = [1, 0, @stream_id, @body.opcode, 0].pack(Formats::HEADER_FORMAT)
-        buffer = @body.write(buffer)
-        buffer[4, 4] = [buffer.length - 8].pack(Formats::INT_FORMAT)
+        buffer = @body.write(ByteBuffer.new)
+        io << [1, 0, @stream_id, @body.opcode].pack(Formats::HEADER_FORMAT)
+        io << [buffer.length].pack(Formats::INT_FORMAT)
         io << buffer
       end
     end

data/lib/cql/protocol/response_frame.rb

@@ -8,7 +8,7 @@ require 'set'
 module Cql
   module Protocol
     class ResponseFrame
-      def initialize(buffer='')
+      def initialize(buffer=ByteBuffer.new)
         @headers = FrameHeaders.new(buffer)
         check_complete!
       end
@@ -87,7 +87,11 @@ module Cql
 
         def check_complete!
           if @buffer.length >= 8
-            @protocol_version, @flags, @stream_id, @opcode, @length = @buffer.slice!(0, 8).unpack(Formats::HEADER_FORMAT)
+            @protocol_version = @buffer.read_byte(true)
+            @flags = @buffer.read_byte(true)
+            @stream_id = @buffer.read_byte(true)
+            @opcode = @buffer.read_byte(true)
+            @length = @buffer.read_int
             raise UnsupportedFrameTypeError, 'Request frames are not supported' if @protocol_version > 0
             @protocol_version &= 0x7f
           end
@@ -120,7 +124,7 @@ module Cql
             extra_length = @buffer.length - @length
             @response = @type.decode!(@buffer)
             if @buffer.length > extra_length
-              @buffer.slice!(0, @buffer.length - extra_length)
+              @buffer.discard(@buffer.length - extra_length)
             end
           end
         end
@@ -303,33 +307,38 @@ module Cql
 
       private
 
+      COLUMN_TYPES = [
+        nil,
+        :ascii,
+        :bigint,
+        :blob,
+        :boolean,
+        :counter,
+        :decimal,
+        :double,
+        :float,
+        :int,
+        :text,
+        :timestamp,
+        :uuid,
+        :varchar,
+        :varint,
+        :timeuuid,
+        :inet,
+      ].freeze
+
       def self.read_column_type!(buffer)
         id, type = read_option!(buffer) do |id, b|
-          case id
-          when 0x01 then :ascii
-          when 0x02 then :bigint
-          when 0x03 then :blob
-          when 0x04 then :boolean
-          when 0x05 then :counter
-          when 0x06 then :decimal
-          when 0x07 then :double
-          when 0x08 then :float
-          when 0x09 then :int
-          # when 0x0a then :text
-          when 0x0b then :timestamp
-          when 0x0c then :uuid
-          when 0x0d then :varchar
-          when 0x0e then :varint
-          when 0x0f then :timeuuid
-          when 0x10 then :inet
-          when 0x20
+          if id > 0 && id <= 0x10
+            COLUMN_TYPES[id]
+          elsif id == 0x20
             sub_type = read_column_type!(buffer)
             [:list, sub_type]
-          when 0x21
+          elsif id == 0x21
             key_type = read_column_type!(buffer)
             value_type = read_column_type!(buffer)
             [:map, key_type, value_type]
-          when 0x22
+          elsif id == 0x22
             sub_type = read_column_type!(buffer)
             [:set, sub_type]
           else
@@ -360,75 +369,159 @@ module Cql
         end
       end
 
-      def self.convert_type(bytes, type)
-        return nil unless bytes
-        case type
-        when :ascii
-          bytes.force_encoding(::Encoding::ASCII)
-        when :bigint
-          read_long!(bytes)
-        when :blob
-          bytes
-        when :boolean
-          bytes == Constants::TRUE_BYTE
-        when :counter
-          read_long!(bytes)
-        when :decimal
-          read_decimal!(bytes)
-        when :double
-          read_double!(bytes)
-        when :float
-          read_float!(bytes)
-        when :int
-          read_int!(bytes)
-        when :timestamp
-          timestamp = read_long!(bytes)
-          Time.at(timestamp/1000.0)
-        when :varchar, :text
-          bytes.force_encoding(::Encoding::UTF_8)
-        when :varint
-          read_varint!(bytes)
-        when :timeuuid, :uuid
-          read_uuid!(bytes)
-        when :inet
-          IPAddr.new_ntoh(bytes)
-        when Array
-          case type.first
-          when :list
-            list = []
-            size = read_short!(bytes)
-            size.times do
-              list << convert_type(read_short_bytes!(bytes), type.last)
-            end
-            list
-          when :map
-            map = {}
-            size = read_short!(bytes)
-            size.times do
-              key = convert_type(read_short_bytes!(bytes), type[1])
-              value = convert_type(read_short_bytes!(bytes), type[2])
-              map[key] = value
-            end
-            map
-          when :set
-            set = Set.new
-            size = read_short!(bytes)
-            size.times do
-              set << convert_type(read_short_bytes!(bytes), type.last)
+      class TypeConverter
+        include Decoding
+
+        def initialize
+          @conversions = conversions
+        end
+
+        def convert_type(buffer, type, size_bytes=4)
+          return nil if buffer.empty?
+          case type
+          when Array
+            buffer.discard(size_bytes)
+            case type.first
+            when :list
+              convert_list(buffer, @conversions[type[1]])
+            when :map
+              convert_map(buffer, @conversions[type[1]], @conversions[type[2]])
+            when :set
+              convert_set(buffer, @conversions[type[1]])
             end
-            set
+          else
+            @conversions[type].call(buffer, size_bytes)
+          end
+        end
+
+        def conversions
+          {
+            :ascii => method(:convert_ascii),
+            :bigint => method(:convert_bigint),
+            :blob => method(:convert_blob),
+            :boolean => method(:convert_boolean),
+            :counter => method(:convert_bigint),
+            :decimal => method(:convert_decimal),
+            :double => method(:convert_double),
+            :float => method(:convert_float),
+            :int => method(:convert_int),
+            :timestamp => method(:convert_timestamp),
+            :varchar => method(:convert_varchar),
+            :text => method(:convert_varchar),
+            :varint => method(:convert_varint),
+            :timeuuid => method(:convert_uuid),
+            :uuid => method(:convert_uuid),
+            :inet => method(:convert_inet),
+          }
+        end
+
+        def convert_ascii(buffer, size_bytes)
+          bytes = size_bytes == 4 ? read_bytes!(buffer) : read_short_bytes!(buffer)
+          bytes ? bytes.force_encoding(::Encoding::ASCII) : nil
+        end
+
+        def convert_bigint(buffer, size_bytes)
+          buffer.discard(size_bytes)
+          read_long!(buffer)
+        end
+
+        def convert_blob(buffer, size_bytes)
+          bytes = size_bytes == 4 ? read_bytes!(buffer) : read_short_bytes!(buffer)
+          bytes ? bytes : nil
+        end
+
+        def convert_boolean(buffer, size_bytes)
+          buffer.discard(size_bytes)
+          buffer.read(1) == Constants::TRUE_BYTE
+        end
+
+        def convert_counter(buffer, size_bytes)
+          buffer.discard(size_bytes)
+          read_long!(buffer)
+        end
+
+        def convert_decimal(buffer, size_bytes)
+          read_decimal!(buffer, buffer.read_int)
+        end
+
+        def convert_double(buffer, size_bytes)
+          buffer.discard(size_bytes)
+          read_double!(buffer)
+        end
+
+        def convert_float(buffer, size_bytes)
+          buffer.discard(size_bytes)
+          read_float!(buffer)
+        end
+
+        def convert_int(buffer, size_bytes)
+          buffer.discard(size_bytes)
+          read_int!(buffer)
+        end
+
+        def convert_timestamp(buffer, size_bytes)
+          buffer.discard(size_bytes)
+          timestamp = read_long!(buffer)
+          Time.at(timestamp/1000.0)
+        end
+
+        def convert_varchar(buffer, size_bytes)
+          bytes = size_bytes == 4 ? read_bytes!(buffer) : read_short_bytes!(buffer)
+          bytes ? bytes.force_encoding(::Encoding::UTF_8) : nil
+        end
+
+        def convert_varint(buffer, size_bytes)
+          read_varint!(buffer, buffer.read_int)
+        end
+
+        def convert_uuid(buffer, size_bytes)
+          buffer.discard(size_bytes)
+          read_uuid!(buffer)
+        end
+
+        def convert_inet(buffer, size_bytes)
+          size = size_bytes == 4 ? buffer.read_int : buffer.read_short
+          IPAddr.new_ntoh(buffer.read(size))
+        end
+
+        def convert_list(buffer, value_converter)
+          list = []
+          size = buffer.read_short
+          size.times do
+            list << value_converter.call(buffer, 2)
+          end
+          list
+        end
+
+        def convert_map(buffer, key_converter, value_converter)
+          map = {}
+          size = buffer.read_short
+          size.times do
+            key = key_converter.call(buffer, 2)
+            value = value_converter.call(buffer, 2)
+            map[key] = value
+          end
+          map
+        end
+
+        def convert_set(buffer, value_converter)
+          set = Set.new
+          size = buffer.read_short
+          size.times do
+            set << value_converter.call(buffer, 2)
           end
+          set
         end
       end
 
       def self.read_rows!(buffer, column_specs)
+        type_converter = TypeConverter.new
         rows_count = read_int!(buffer)
         rows = []
         rows_count.times do |row_index|
           row = {}
           column_specs.each do |column_spec|
-            column_value = read_bytes!(buffer)
-            row[column_spec[2]] = convert_type(column_value, column_spec[3])
+            row[column_spec[2]] = type_converter.convert_type(buffer, column_spec[3])
           end
           rows << row
         end

data/lib/cql/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 
 module Cql
-  VERSION = '1.0.0.pre5'.freeze
+  VERSION = '1.0.0.pre6'.freeze
 end

data/spec/cql/byte_buffer_spec.rb

@@ -0,0 +1,299 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+
+module Cql
+  describe ByteBuffer do
+    let :buffer do
+      described_class.new
+    end
+
+    describe '#initialize' do
+      it 'can be inititialized empty' do
+        described_class.new.should be_empty
+      end
+
+      it 'can be initialized with bytes' do
+        described_class.new('hello').length.should == 5
+      end
+    end
+
+    describe '#length/#size/#bytesize' do
+      it 'returns the number of bytes in the buffer' do
+        buffer << 'foo'
+        buffer.length.should == 3
+      end
+
+      it 'is zero initially' do
+        buffer.length.should == 0
+      end
+
+      it 'is aliased as #size' do
+        buffer << 'foo'
+        buffer.size.should == 3
+      end
+
+      it 'is aliased as #bytesize' do
+        buffer << 'foo'
+        buffer.bytesize.should == 3
+      end
+    end
+
+    describe '#empty?' do
+      it 'is true initially' do
+        buffer.should be_empty
+      end
+
+      it 'is false when there are bytes in the buffer' do
+        buffer << 'foo'
+        buffer.should_not be_empty
+      end
+    end
+
+    describe '#append/#<<' do
+      it 'adds bytes to the buffer' do
+        buffer.append('foo')
+        buffer.should_not be_empty
+      end
+
+      it 'can be used as <<' do
+        buffer << 'foo'
+        buffer.should_not be_empty
+      end
+
+      it 'returns itself' do
+        buffer.append('foo').should eql(buffer)
+      end
+
+      it 'stores its bytes as binary' do
+        buffer.append('hällö').length.should == 7
+        buffer.to_s.encoding.should == ::Encoding::BINARY
+      end
+
+      it 'handles appending with multibyte strings' do
+        buffer.append('hello')
+        buffer.append('würld')
+        buffer.to_s.should == 'hellowürld'.force_encoding(::Encoding::BINARY)
+      end
+
+      it 'handles appending with another byte buffer' do
+        buffer.append('hello ').append(ByteBuffer.new('world'))
+        buffer.to_s.should == 'hello world'
+      end
+    end
+
+    describe '#eql?' do
+      it 'is equal to another buffer with the same contents' do
+        b1 = described_class.new
+        b2 = described_class.new
+        b1.append('foo')
+        b2.append('foo')
+        b1.should eql(b2)
+      end
+
+      it 'is not equal to another buffer with other contents' do
+        b1 = described_class.new
+        b2 = described_class.new
+        b1.append('foo')
+        b2.append('bar')
+        b1.should_not eql(b2)
+      end
+
+      it 'is aliased as #==' do
+        b1 = described_class.new
+        b2 = described_class.new
+        b1.append('foo')
+        b2.append('foo')
+        b1.should == b2
+      end
+
+      it 'is equal to another buffer when both are empty' do
+        b1 = described_class.new
+        b2 = described_class.new
+        b1.should eql(b2)
+      end
+    end
+
+    describe '#hash' do
+      it 'has the same hash code as another buffer with the same contents' do
+        b1 = described_class.new
+        b2 = described_class.new
+        b1.append('foo')
+        b2.append('foo')
+        b1.hash.should == b2.hash
+      end
+
+      it 'is not equal to the hash code of another buffer with other contents' do
+        b1 = described_class.new
+        b2 = described_class.new
+        b1.append('foo')
+        b2.append('bar')
+        b1.hash.should_not == b2.hash
+      end
+
+      it 'is equal to the hash code of another buffer when both are empty' do
+        b1 = described_class.new
+        b2 = described_class.new
+        b1.hash.should == b2.hash
+      end
+    end
+
+    describe '#to_s' do
+      it 'returns the bytes' do
+        buffer.append('hello world').to_s.should == 'hello world'
+      end
+    end
+
+    describe '#to_str' do
+      it 'returns the bytes' do
+        buffer.append('hello world').to_str.should == 'hello world'
+      end
+    end
+
+    describe '#inspect' do
+      it 'returns the bytes wrapped in ByteBuffer(...)' do
+        buffer.append("\xca\xfe")
+        buffer.inspect.should == '#<Cql::ByteBuffer: "\xCA\xFE">'
+      end
+    end
+
+    describe '#discard' do
+      it 'discards the specified number of bytes from the front of the buffer' do
+        buffer.append('hello world')
+        buffer.discard(4)
+        buffer.should == ByteBuffer.new('o world')
+      end
+
+      it 'returns the byte buffer' do
+        buffer.append('hello world')
+        buffer.discard(4).should == ByteBuffer.new('o world')
+      end
+
+      it 'raises an error if the number of bytes in the buffer is fewer than the number to discard' do
+        expect { buffer.discard(1) }.to raise_error(RangeError)
+        buffer.append('hello')
+        expect { buffer.discard(7) }.to raise_error(RangeError)
+      end
+    end
+
+    describe '#read' do
+      it 'returns the specified number of bytes, as a string' do
+        buffer.append('hello')
+        buffer.read(4).should == 'hell'
+      end
+
+      it 'removes the bytes from the buffer' do
+        buffer.append('hello')
+        buffer.read(3)
+        buffer.should == ByteBuffer.new('lo')
+        buffer.read(2).should == 'lo'
+      end
+
+      it 'raises an error if there are not enough bytes' do
+        buffer.append('hello')
+        expect { buffer.read(23423543) }.to raise_error(RangeError)
+        expect { buffer.discard(5).read(1) }.to raise_error(RangeError)
+      end
+
+      it 'returns a string with binary encoding' do
+        buffer.append('hello')
+        buffer.read(4).encoding.should == ::Encoding::BINARY
+        buffer.append('∆')
+        buffer.read(2).encoding.should == ::Encoding::BINARY
+      end
+    end
+
+    describe '#read_int' do
+      it 'returns the first four bytes interpreted as an int' do
+        buffer.append("\xca\xfe\xba\xbe\x01")
+        buffer.read_int.should == 0xcafebabe
+      end
+
+      it 'removes the bytes from the buffer' do
+        buffer.append("\xca\xfe\xba\xbe\x01")
+        buffer.read_int
+        buffer.should == ByteBuffer.new("\x01")
+      end
+
+      it 'raises an error if there are not enough bytes' do
+        buffer.append("\xca\xfe\xba")
+        expect { buffer.read_int }.to raise_error(RangeError)
+      end
+    end
+
+    describe '#read_short' do
+      it 'returns the first two bytes interpreted as a short' do
+        buffer.append("\xca\xfe\x01")
+        buffer.read_short.should == 0xcafe
+      end
+
+      it 'removes the bytes from the buffer' do
+        buffer.append("\xca\xfe\x01")
+        buffer.read_short
+        buffer.should == ByteBuffer.new("\x01")
+      end
+
+      it 'raises an error if there are not enough bytes' do
+        buffer.append("\xca")
+        expect { buffer.read_short }.to raise_error(RangeError)
+      end
+    end
+
+    describe '#read_byte' do
+      it 'returns the first bytes interpreted as an int' do
+        buffer.append("\x10\x01")
+        buffer.read_byte.should == 0x10
+        buffer.read_byte.should == 0x01
+      end
+
+      it 'removes the byte from the buffer' do
+        buffer.append("\x10\x01")
+        buffer.read_byte
+        buffer.should == ByteBuffer.new("\x01")
+      end
+
+      it 'raises an error if there are no bytes' do
+        expect { buffer.read_byte }.to raise_error(RangeError)
+      end
+
+      it 'can interpret the byte as signed' do
+        buffer.append("\x81\x02")
+        buffer.read_byte(true).should == -127
+        buffer.read_byte(true).should == 2
+      end
+    end
+
+    describe '#dup' do
+      it 'returns a copy' do
+        buffer.append('hello world')
+        copy = buffer.dup
+        copy.should eql(buffer)
+      end
+
+      it 'returns a copy which can be modified without modifying the original' do
+        buffer.append('hello world')
+        copy = buffer.dup
+        copy.append('goodbye')
+        copy.should_not eql(buffer)
+      end
+    end
+
+    context 'when reading and appending' do
+      it 'handles heavy churn' do
+        1000.times do
+          buffer.append('x' * 6)
+          buffer.read_byte
+          buffer.append('y')
+          buffer.read_int
+          buffer.read_short
+          buffer.append('z' * 4)
+          buffer.read_byte
+          buffer.append('z')
+          buffer.read_int
+          buffer.should be_empty
+        end
+      end
+    end
+  end
+end