cql-rb 2.0.0.pre0 → 2.0.0.pre1

data/lib/cql/protocol/decoding.rb

@@ -1,187 +0,0 @@
-# encoding: utf-8
-
-require 'bigdecimal'
-
-
-module Cql
-  module Protocol
-    module Decoding
-      extend self
-
-      def read_byte!(buffer)
-        buffer.read_byte
-      rescue RangeError => e
-        raise DecodingError, e.message, e.backtrace
-      end
-
-      def read_varint!(buffer, length=buffer.length, signed=true)
-        bytes = buffer.read(length)
-        n = 0
-        bytes.each_byte do |b|
-          n = (n << 8) | b
-        end
-        if signed && bytes.getbyte(0) & 0x80 == 0x80
-          n -= 2**(bytes.length * 8)
-        end
-        n
-      rescue RangeError => e
-        raise DecodingError, e.message, e.backtrace
-      end
-
-      def read_decimal!(buffer, length=buffer.length)
-        size = read_int!(buffer)
-        number_string = read_varint!(buffer, length - 4).to_s
-        if number_string.length < size
-          if number_string.start_with?(MINUS)
-            number_string = number_string[1, number_string.length - 1]
-            fraction_string = MINUS + ZERO << DECIMAL_POINT
-          else
-            fraction_string = ZERO + DECIMAL_POINT
-          end
-          (size - number_string.length).times { fraction_string << ZERO }
-          fraction_string << number_string
-        else
-          fraction_string = number_string[0, number_string.length - size]
-          fraction_string << DECIMAL_POINT
-          fraction_string << number_string[number_string.length - size, number_string.length]
-        end
-        BigDecimal.new(fraction_string)
-      rescue DecodingError => e
-        raise DecodingError, e.message, e.backtrace
-      end
-
-      def read_long!(buffer)
-        top, bottom = buffer.read(8).unpack(Formats::TWO_INTS_FORMAT)
-        return (top << 32) | bottom if top <= 0x7fffffff
-        top ^= 0xffffffff
-        bottom ^= 0xffffffff
-        -((top << 32) | bottom) - 1
-      rescue RangeError => e
-        raise DecodingError, e.message, e.backtrace
-      end
-
-      def read_double!(buffer)
-        buffer.read(8).unpack(Formats::DOUBLE_FORMAT).first
-      rescue RangeError => e
-        raise DecodingError, "Not enough bytes available to decode a double: #{e.message}", e.backtrace
-      end
-
-      def read_float!(buffer)
-        buffer.read(4).unpack(Formats::FLOAT_FORMAT).first
-      rescue RangeError => e
-        raise DecodingError, "Not enough bytes available to decode a float: #{e.message}", e.backtrace
-      end
-
-      def read_int!(buffer)
-        n = buffer.read_int
-        return n if n <= 0x7fffffff
-        n - 0xffffffff - 1
-      rescue RangeError => e
-        raise DecodingError, "Not enough bytes available to decode an int: #{e.message}", e.backtrace
-      end
-
-      def read_short!(buffer)
-        buffer.read_short
-      rescue RangeError => e
-        raise DecodingError, "Not enough bytes available to decode a short: #{e.message}", e.backtrace
-      end
-
-      def read_string!(buffer)
-        length = read_short!(buffer)
-        string = buffer.read(length)
-        string.force_encoding(::Encoding::UTF_8)
-        string
-      rescue RangeError => e
-        raise DecodingError, "Not enough bytes available to decode a string: #{e.message}", e.backtrace
-      end
-
-      def read_long_string!(buffer)
-        length = read_int!(buffer)
-        string = buffer.read(length)
-        string.force_encoding(::Encoding::UTF_8)
-        string
-      rescue RangeError => e
-        raise DecodingError, "Not enough bytes available to decode a long string: #{e.message}", e.backtrace
-      end
-
-      def read_uuid!(buffer, impl=Uuid)
-        impl.new(read_varint!(buffer, 16, false))
-      rescue DecodingError => e
-        raise DecodingError, "Not enough bytes available to decode a UUID: #{e.message}", e.backtrace
-      end
-
-      def read_string_list!(buffer)
-        size = read_short!(buffer)
-        size.times.map do
-          read_string!(buffer)
-        end
-      end
-
-      def read_bytes!(buffer)
-        size = read_int!(buffer)
-        return nil if size & 0x80000000 == 0x80000000
-        buffer.read(size)
-      rescue RangeError => e
-        raise DecodingError, "Not enough bytes available to decode a bytes: #{e.message}", e.backtrace
-      end
-
-      def read_short_bytes!(buffer)
-        size = read_short!(buffer)
-        return nil if size & 0x8000 == 0x8000
-        buffer.read(size)
-      rescue RangeError => e
-        raise DecodingError, "Not enough bytes available to decode a short bytes: #{e.message}", e.backtrace
-      end
-
-      def read_option!(buffer)
-        id = read_short!(buffer)
-        value = nil
-        if block_given?
-          value = yield id, buffer
-        end
-        [id, value]
-      end
-
-      def read_inet!(buffer)
-        size = read_byte!(buffer)
-        ip_addr = IPAddr.new_ntoh(buffer.read(size))
-        port = read_int!(buffer)
-        [ip_addr, port]
-      rescue RangeError => e
-        raise DecodingError, "Not enough bytes available to decode an INET: #{e.message}", e.backtrace
-      end
-
-      def read_consistency!(buffer)
-        index = read_short!(buffer)
-        raise DecodingError, "Unknown consistency index #{index}" if index >= CONSISTENCIES.size || CONSISTENCIES[index].nil?
-        CONSISTENCIES[index]
-      end
-
-      def read_string_map!(buffer)
-        map = {}
-        map_size = read_short!(buffer)
-        map_size.times do
-          key = read_string!(buffer)
-          map[key] = read_string!(buffer)
-        end
-        map
-      end
-
-      def read_string_multimap!(buffer)
-        map = {}
-        map_size = read_short!(buffer)
-        map_size.times do
-          key = read_string!(buffer)
-          map[key] = read_string_list!(buffer)
-        end
-        map
-      end
-
-      private
-
-      MINUS = '-'.freeze
-      ZERO = '0'.freeze
-      DECIMAL_POINT = '.'.freeze
-    end
-  end
-end

data/lib/cql/protocol/encoding.rb

@@ -1,114 +0,0 @@
-# encoding: utf-8
-
-module Cql
-  module Protocol
-    module Encoding
-      extend self
-
-      def write_int(buffer, n)
-        buffer << [n].pack(Formats::INT_FORMAT)
-      end
-
-      def write_short(buffer, n)
-        buffer << [n].pack(Formats::SHORT_FORMAT)
-      end
-
-      def write_string(buffer, str)
-        str = str.to_s
-        buffer << [str.bytesize].pack(Formats::SHORT_FORMAT)
-        buffer << str
-        buffer
-      end
-
-      def write_long_string(buffer, str)
-        buffer << [str.bytesize].pack(Formats::INT_FORMAT)
-        buffer << str
-        buffer
-      end
-
-      def write_uuid(buffer, uuid)
-        v = uuid.value
-        write_int(buffer, (v >> 96) & 0xffffffff)
-        write_int(buffer, (v >> 64) & 0xffffffff)
-        write_int(buffer, (v >> 32) & 0xffffffff)
-        write_int(buffer, v & 0xffffffff)
-      end
-
-      def write_string_list(buffer, strs)
-        buffer << [strs.size].pack(Formats::SHORT_FORMAT)
-        strs.each do |str|
-          write_string(buffer, str)
-        end
-        buffer
-      end
-
-      def write_bytes(buffer, bytes)
-        if bytes
-          write_int(buffer, bytes.bytesize)
-          buffer << bytes
-        else
-          write_int(buffer, -1)
-        end
-        buffer
-      end
-
-      def write_short_bytes(buffer, bytes)
-        if bytes
-          write_short(buffer, bytes.bytesize)
-          buffer << bytes
-        else
-          write_short(buffer, -1)
-        end
-        buffer
-      end
-
-      def write_consistency(buffer, consistency)
-        index = CONSISTENCIES.index(consistency)
-        raise EncodingError, %(Unknown consistency "#{consistency}") if index.nil? || CONSISTENCIES[index].nil?
-        write_short(buffer, index)
-      end
-
-      def write_string_map(buffer, map)
-        buffer << [map.size].pack(Formats::SHORT_FORMAT)
-        map.each do |key, value|
-          write_string(buffer, key)
-          write_string(buffer, value)
-        end
-        buffer
-      end
-
-      def write_long(buffer, n)
-        top = n >> 32
-        bottom = n & 0xffffffff
-        write_int(buffer, top)
-        write_int(buffer, bottom)
-      end
-
-      def write_varint(buffer, n)
-        num = n
-        bytes = []
-        until num == 0 || num == -1
-          bytes << (num & 0xff)
-          num = num >> 8
-        end
-        buffer << bytes.reverse.pack(Formats::BYTES_FORMAT)
-      end
-
-      def write_decimal(buffer, n)
-        sign, number_string, _, size = n.split
-        num = number_string.to_i
-        raw = write_varint('', num)
-        write_int(buffer, number_string.length - size)
-        buffer << raw
-      end
-
-      def write_double(buffer, n)
-        buffer << [n].pack(Formats::DOUBLE_FORMAT)
-      end
-
-      def write_float(buffer, n)
-        buffer << [n].pack(Formats::FLOAT_FORMAT)
-      end
-    end
-  end
-end

data/spec/cql/byte_buffer_spec.rb

@@ -1,337 +0,0 @@
-# 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 '#update' do
-      it 'changes the bytes at the specified location' do
-        buffer.append('foo bar')
-        buffer.update(4, 'baz')
-        buffer.to_s.should == 'foo baz'
-      end
-
-      it 'handles updates after a read' do
-        buffer.append('foo bar')
-        buffer.read(1)
-        buffer.update(3, 'baz')
-        buffer.to_s.should == 'oo baz'
-      end
-
-      it 'handles updates after multiple reads and appends' do
-        buffer.append('foo bar')
-        buffer.read(1)
-        buffer.append('x')
-        buffer.update(4, 'baz')
-        buffer.append('yyyy')
-        buffer.read(1)
-        buffer.to_s.should == 'o bbazyyyy'
-      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
-
-    describe '#cheap_peek' do
-      it 'returns a prefix of the buffer' do
-        buffer.append('foo')
-        buffer.append('bar')
-        buffer.read_byte
-        buffer.append('hello')
-        x = buffer.cheap_peek
-        x.bytesize.should be > 0
-        x.bytesize.should be <= buffer.bytesize
-        buffer.to_str.should start_with(x)
-      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