cql-rb 2.0.0.pre0 → 2.0.0.pre1

data/lib/cql/protocol/requests/options_request.rb

@@ -11,8 +11,8 @@ module Cql
         false
       end
 
-      def write(protocol_version, io)
-        io
+      def write(protocol_version, buffer)
+        buffer
       end
 
       def to_s

data/lib/cql/protocol/requests/prepare_request.rb

@@ -11,8 +11,8 @@ module Cql
         @cql = cql
       end
 
-      def write(protocol_version, io)
-        write_long_string(io, @cql)
+      def write(protocol_version, buffer)
+        buffer.append_long_string(@cql)
       end
 
       def to_s

data/lib/cql/protocol/requests/query_request.rb

@@ -15,16 +15,16 @@ module Cql
         @cql = cql
         @values = values || EMPTY_LIST
         @type_hints = type_hints || EMPTY_LIST
-        @encoded_values = self.class.encode_values('', @values, @type_hints)
+        @encoded_values = self.class.encode_values(CqlByteBuffer.new, @values, @type_hints)
         @consistency = consistency
         @serial_consistency = serial_consistency
         @page_size = page_size
         @paging_state = paging_state
       end
 
-      def write(protocol_version, io)
-        write_long_string(io, @cql)
-        write_consistency(io, @consistency)
+      def write(protocol_version, buffer)
+        buffer.append_long_string(@cql)
+        buffer.append_consistency(@consistency)
         if protocol_version > 1
           flags  = 0
           flags |= 0x04 if @page_size
@@ -32,16 +32,16 @@ module Cql
           flags |= 0x10 if @serial_consistency
           if @values && @values.size > 0
             flags |= 0x01
-            io << flags.chr
-            io << @encoded_values
+            buffer.append(flags.chr)
+            buffer.append(@encoded_values)
           else
-            io << flags.chr
+            buffer.append(flags.chr)
           end
-          write_int(io, @page_size) if @page_size
-          write_bytes(io, @paging_state) if @paging_state
-          write_consistency(io, @serial_consistency) if @serial_consistency
+          buffer.append_int(@page_size) if @page_size
+          buffer.append_bytes(@paging_state) if @paging_state
+          buffer.append_consistency(@serial_consistency) if @serial_consistency
         end
-        io
+        buffer
       end
 
       def to_s
@@ -74,7 +74,7 @@ module Cql
 
       def self.encode_values(buffer, values, hints)
         if values && values.size > 0
-          Encoding.write_short(buffer, values.size)
+          buffer.append_short(values.size)
           values.each_with_index do |value, index|
             type = (hints && hints[index]) || guess_type(value)
             raise EncodingError, "Could not guess a suitable type for #{value.inspect}" unless type
@@ -82,7 +82,7 @@ module Cql
           end
           buffer
         else
-          Encoding.write_short(buffer, 0)
+          buffer.append_short(0)
         end
       end
 

data/lib/cql/protocol/requests/register_request.rb

@@ -10,8 +10,8 @@ module Cql
         @events = events
       end
 
-      def write(protocol_version, io)
-        write_string_list(io, @events)
+      def write(protocol_version, buffer)
+        buffer.append_string_list(@events)
       end
 
       def to_s

data/lib/cql/protocol/requests/startup_request.rb

@@ -16,8 +16,8 @@ module Cql
         false
       end
 
-      def write(protocol_version, io)
-        write_string_map(io, @options)
+      def write(protocol_version, buffer)
+        buffer.append_string_map(@options)
       end
 
       def to_s

data/lib/cql/protocol/response.rb

@@ -3,12 +3,10 @@
 module Cql
   module Protocol
     class Response
-      extend Decoding
-
-      def self.decode!(opcode, protocol_version, buffer, length, trace_id)
+      def self.decode(opcode, protocol_version, buffer, length, trace_id)
         response_class = RESPONSE_TYPES[opcode]
         if response_class
-          response_class.decode!(protocol_version, buffer, length, trace_id)
+          response_class.decode(protocol_version, buffer, length, trace_id)
         else
           raise UnsupportedOperationError, "The operation #{opcode} is not supported"
         end

data/lib/cql/protocol/responses/auth_challenge_response.rb

@@ -5,8 +5,8 @@ module Cql
     class AuthChallengeResponse < Response
       attr_reader :token
 
-      def self.decode!(protocol_version, buffer, length, trace_id=nil)
-        new(read_bytes!(buffer))
+      def self.decode(protocol_version, buffer, length, trace_id=nil)
+        new(buffer.read_bytes)
       end
 
       def initialize(token)

data/lib/cql/protocol/responses/auth_success_response.rb

@@ -5,8 +5,8 @@ module Cql
     class AuthSuccessResponse < Response
       attr_reader :token
 
-      def self.decode!(protocol_version, buffer, length, trace_id=nil)
-        new(read_bytes!(buffer))
+      def self.decode(protocol_version, buffer, length, trace_id=nil)
+        new(buffer.read_bytes)
       end
 
       def initialize(token)

data/lib/cql/protocol/responses/authenticate_response.rb

@@ -5,8 +5,8 @@ module Cql
     class AuthenticateResponse < Response
       attr_reader :authentication_class
 
-      def self.decode!(protocol_version, buffer, length, trace_id=nil)
-        new(read_string!(buffer))
+      def self.decode(protocol_version, buffer, length, trace_id=nil)
+        new(buffer.read_string)
       end
 
       def initialize(authentication_class)

data/lib/cql/protocol/responses/detailed_error_response.rb

@@ -10,28 +10,28 @@ module Cql
         @details = details
       end
 
-      def self.decode!(code, message, protocol_version, buffer, length, trace_id=nil)
+      def self.decode(code, message, protocol_version, buffer, length, trace_id=nil)
         details = {}
         case code
         when 0x1000 # unavailable
-          details[:cl] = read_consistency!(buffer)
-          details[:required] = read_int!(buffer)
-          details[:alive] = read_int!(buffer)
+          details[:cl] = buffer.read_consistency
+          details[:required] = buffer.read_int
+          details[:alive] = buffer.read_int
         when 0x1100 # write_timeout
-          details[:cl] = read_consistency!(buffer)
-          details[:received] = read_int!(buffer)
-          details[:blockfor] = read_int!(buffer)
-          details[:write_type] = read_string!(buffer)
+          details[:cl] = buffer.read_consistency
+          details[:received] = buffer.read_int
+          details[:blockfor] = buffer.read_int
+          details[:write_type] = buffer.read_string
         when 0x1200 # read_timeout
-          details[:cl] = read_consistency!(buffer)
-          details[:received] = read_int!(buffer)
-          details[:blockfor] = read_int!(buffer)
-          details[:data_present] = read_byte!(buffer) != 0
+          details[:cl] = buffer.read_consistency
+          details[:received] = buffer.read_int
+          details[:blockfor] = buffer.read_int
+          details[:data_present] = buffer.read_byte != 0
         when 0x2400 # already_exists
-          details[:ks] = read_string!(buffer)
-          details[:table] = read_string!(buffer)
+          details[:ks] = buffer.read_string
+          details[:table] = buffer.read_string
         when 0x2500
-          details[:id] = read_short_bytes!(buffer)
+          details[:id] = buffer.read_short_bytes
         end
         new(code, message, details)
       end

data/lib/cql/protocol/responses/error_response.rb

@@ -9,13 +9,13 @@ module Cql
         @code, @message = args
       end
 
-      def self.decode!(protocol_version, buffer, length, trace_id=nil)
-        code = read_int!(buffer)
-        message = read_string!(buffer)
+      def self.decode(protocol_version, buffer, length, trace_id=nil)
+        code = buffer.read_int
+        message = buffer.read_string
         case code
         when 0x1000, 0x1100, 0x1200, 0x2400, 0x2500
           new_length = length - 4 - 4 - message.bytesize
-          DetailedErrorResponse.decode!(code, message, protocol_version, buffer, new_length)
+          DetailedErrorResponse.decode(code, message, protocol_version, buffer, new_length)
         else
           new(code, message)
         end

data/lib/cql/protocol/responses/event_response.rb

@@ -3,12 +3,12 @@
 module Cql
   module Protocol
     class EventResponse < ResultResponse
-      def self.decode!(protocol_version, buffer, length, trace_id=nil)
-        type = read_string!(buffer)
+      def self.decode(protocol_version, buffer, length, trace_id=nil)
+        type = buffer.read_string
         impl = EVENT_TYPES[type]
         raise UnsupportedEventTypeError, %(Unsupported event type: "#{type}") unless impl
         new_length = length - 4 - type.bytesize
-        impl.decode!(protocol_version, buffer, new_length, trace_id)
+        impl.decode(protocol_version, buffer, new_length, trace_id)
       end
 
       private

data/lib/cql/protocol/responses/prepared_result_response.rb

@@ -10,12 +10,12 @@ module Cql
         @id, @metadata, @result_metadata = id, metadata, result_metadata
       end
 
-      def self.decode!(protocol_version, buffer, length, trace_id=nil)
-        id = read_short_bytes!(buffer)
-        metadata, _ = RowsResultResponse.read_metadata!(protocol_version, buffer)
+      def self.decode(protocol_version, buffer, length, trace_id=nil)
+        id = buffer.read_short_bytes
+        metadata, _ = RowsResultResponse.read_metadata(protocol_version, buffer)
         result_metadata = nil
         if protocol_version > 1
-          result_metadata, _, _ = RowsResultResponse.read_metadata!(protocol_version, buffer)
+          result_metadata, _, _ = RowsResultResponse.read_metadata(protocol_version, buffer)
         end
         new(id, metadata, result_metadata, trace_id)
       end

data/lib/cql/protocol/responses/raw_rows_result_response.rb

@@ -11,7 +11,7 @@ module Cql
 
       def materialize(metadata)
         @metadata = metadata
-        @rows = RowsResultResponse.read_rows!(@protocol_version, @raw_rows, @metadata)
+        @rows = RowsResultResponse.read_rows(@protocol_version, @raw_rows, @metadata)
       end
 
       def rows

data/lib/cql/protocol/responses/ready_response.rb

@@ -3,7 +3,7 @@
 module Cql
   module Protocol
     class ReadyResponse < Response
-      def self.decode!(protocol_version, buffer, length, trace_id=nil)
+      def self.decode(protocol_version, buffer, length, trace_id=nil)
         new
       end
 

data/lib/cql/protocol/responses/result_response.rb

@@ -9,11 +9,11 @@ module Cql
         @trace_id = trace_id
       end
 
-      def self.decode!(protocol_version, buffer, length, trace_id=nil)
-        kind = read_int!(buffer)
+      def self.decode(protocol_version, buffer, length, trace_id=nil)
+        kind = buffer.read_int
         impl = RESULT_TYPES[kind]
         raise UnsupportedResultKindError, %(Unsupported result kind: #{kind}) unless impl
-        impl.decode!(protocol_version, buffer, length - 4, trace_id)
+        impl.decode(protocol_version, buffer, length - 4, trace_id)
       end
 
       def void?

data/lib/cql/protocol/responses/rows_result_response.rb

@@ -10,15 +10,15 @@ module Cql
         @rows, @metadata, @paging_state = rows, metadata, paging_state
       end
 
-      def self.decode!(protocol_version, buffer, length, trace_id=nil)
+      def self.decode(protocol_version, buffer, length, trace_id=nil)
         original_buffer_length = buffer.length
-        column_specs, columns_count, paging_state = read_metadata!(protocol_version, buffer)
+        column_specs, columns_count, paging_state = read_metadata(protocol_version, buffer)
         if column_specs.nil?
           consumed_bytes = original_buffer_length - buffer.length
-          remaining_bytes = ByteBuffer.new(buffer.read(length - consumed_bytes))
+          remaining_bytes = CqlByteBuffer.new(buffer.read(length - consumed_bytes))
           RawRowsResultResponse.new(protocol_version, remaining_bytes, paging_state, trace_id)
         else
-          new(read_rows!(protocol_version, buffer, column_specs), column_specs, paging_state, trace_id)
+          new(read_rows(protocol_version, buffer, column_specs), column_specs, paging_state, trace_id)
         end
       end
 
@@ -56,19 +56,19 @@ module Cql
       HAS_MORE_PAGES_FLAG = 0x02
       NO_METADATA_FLAG = 0x04
 
-      def self.read_column_type!(buffer)
-        id, type = read_option!(buffer) do |id, b|
+      def self.read_column_type(buffer)
+        id, type = buffer.read_option do |id, b|
           if id > 0 && id <= 0x10
             COLUMN_TYPES[id]
           elsif id == 0x20
-            sub_type = read_column_type!(buffer)
+            sub_type = read_column_type(buffer)
             [:list, sub_type]
           elsif id == 0x21
-            key_type = read_column_type!(buffer)
-            value_type = read_column_type!(buffer)
+            key_type = read_column_type(buffer)
+            value_type = read_column_type(buffer)
             [:map, key_type, value_type]
           elsif id == 0x22
-            sub_type = read_column_type!(buffer)
+            sub_type = read_column_type(buffer)
             [:set, sub_type]
           else
             raise UnsupportedColumnTypeError, %(Unsupported column type: #{id})
@@ -77,37 +77,37 @@ module Cql
         type
       end
 
-      def self.read_metadata!(protocol_version, buffer)
-        flags = read_int!(buffer)
-        columns_count = read_int!(buffer)
+      def self.read_metadata(protocol_version, buffer)
+        flags = buffer.read_int
+        columns_count = buffer.read_int
         paging_state = nil
         column_specs = nil
         if flags & HAS_MORE_PAGES_FLAG != 0
-          paging_state = read_bytes!(buffer)
+          paging_state = buffer.read_bytes
         end
         if flags & NO_METADATA_FLAG == 0
           if flags & GLOBAL_TABLES_SPEC_FLAG != 0
-            global_keyspace_name = read_string!(buffer)
-            global_table_name = read_string!(buffer)
+            global_keyspace_name = buffer.read_string
+            global_table_name = buffer.read_string
           end
           column_specs = columns_count.times.map do
             if global_keyspace_name
               keyspace_name = global_keyspace_name
               table_name = global_table_name
             else
-              keyspace_name = read_string!(buffer)
-              table_name = read_string!(buffer)
+              keyspace_name = buffer.read_string
+              table_name = buffer.read_string
             end
-            column_name = read_string!(buffer)
-            type = read_column_type!(buffer)
+            column_name = buffer.read_string
+            type = read_column_type(buffer)
             [keyspace_name, table_name, column_name, type]
           end
         end
         [column_specs, columns_count, paging_state]
       end
 
-      def self.read_rows!(protocol_version, buffer, column_specs)
-        rows_count = read_int!(buffer)
+      def self.read_rows(protocol_version, buffer, column_specs)
+        rows_count = buffer.read_int
         rows = []
         rows_count.times do |row_index|
           row = {}

data/lib/cql/protocol/responses/schema_change_event_response.rb

@@ -12,8 +12,8 @@ module Cql
         @type = TYPE
       end
 
-      def self.decode!(protocol_version, buffer, length, trace_id=nil)
-        new(read_string!(buffer), read_string!(buffer), read_string!(buffer))
+      def self.decode(protocol_version, buffer, length, trace_id=nil)
+        new(buffer.read_string, buffer.read_string, buffer.read_string)
       end
 
       def eql?(rs)

data/lib/cql/protocol/responses/schema_change_result_response.rb

@@ -10,8 +10,8 @@ module Cql
         @change, @keyspace, @table = change, keyspace, table
       end
 
-      def self.decode!(protocol_version, buffer, length, trace_id=nil)
-        new(read_string!(buffer), read_string!(buffer), read_string!(buffer), trace_id)
+      def self.decode(protocol_version, buffer, length, trace_id=nil)
+        new(buffer.read_string, buffer.read_string, buffer.read_string, trace_id)
       end
 
       def eql?(other)

data/lib/cql/protocol/responses/set_keyspace_result_response.rb

@@ -10,8 +10,8 @@ module Cql
         @keyspace = keyspace
       end
 
-      def self.decode!(protocol_version, buffer, length, trace_id=nil)
-        new(read_string!(buffer), trace_id)
+      def self.decode(protocol_version, buffer, length, trace_id=nil)
+        new(buffer.read_string, trace_id)
       end
 
       def to_s

data/lib/cql/protocol/responses/status_change_event_response.rb

@@ -12,8 +12,8 @@ module Cql
         @type = TYPE
       end
 
-      def self.decode!(protocol_version, buffer, length, trace_id=nil)
-        new(read_string!(buffer), *read_inet!(buffer))
+      def self.decode(protocol_version, buffer, length, trace_id=nil)
+        new(buffer.read_string, *buffer.read_inet)
       end
 
       def to_s

data/lib/cql/protocol/responses/supported_response.rb

@@ -9,8 +9,8 @@ module Cql
         @options = options
       end
 
-      def self.decode!(protocol_version, buffer, length, trace_id=nil)
-        new(read_string_multimap!(buffer))
+      def self.decode(protocol_version, buffer, length, trace_id=nil)
+        new(buffer.read_string_multimap)
       end
 
       def to_s