redis-protocol 0.1.2 → 0.1.3

data/VERSION

@@ -1 +1 @@
-0.1.2
+0.1.3

data/lib/redis-protocol.rb

@@ -1,10 +1,8 @@
 # start with *, $, alpha-numeric, \r
 
 module RedisProtocol
-  class Response
-
-  end
 end
 
+require 'redis-protocol/unified_protocol'
 require 'redis-protocol/request'
-require 'redis-protocol/static_request'
+require 'redis-protocol/response'

data/lib/redis-protocol/request.rb

@@ -1,134 +1,38 @@
+require_relative 'unified_protocol'
+
 class RedisProtocol::Request
-  attr_reader :raw_data, :type, :component_count, :components
+  attr_reader :raw_data, :type, :components
 
   def initialize(data)
     @raw_data = data
-    @type, @components, @component_count, @current = nil, [], 0, ''
+    @type, @components= nil, []
     @next_length = 0
     parse
   end
 
+  def component_count
+    @components.length
+  end
+
   private
 
   def parse
-    @raw_data.chars.each do |c|
-      @type ||= c.eql?('*') ? :standard : :inline
+    @type ||= @raw_data[0].eql?('*') ? :standard : :inline
 
-      send(@type, c)
-    end
-
-    complete_token
-    @component_count += @components.count if @type == :inline
+    @components = send(@type)
   end
 =begin
     Inline Parser
 =end
-  def inline(char)
-    c = char.strip
-
-    if c.empty? and not @current.empty?
-      complete_token
-    else
-      @current += c
-    end
+  def inline
+    @raw_data.split
   end
 
 =begin
     Standard Parser
 =end
 
-  def standard(char)
-    @token_type ||= detect_token_type char
-    @doubt_str = ''
-
-    send(@token_type, char)
-  end
-
-  def args_counts(char)
-    return if char.eql? '*'
-
-    tokenize char do
-      @component_count = @current.to_i
-      clean_context
-    end
-  end
-
-  def length(char)
-    return if char.eql? '$'
-
-    tokenize char do
-      @next_length = @current.to_i
-      clean_context
-    end
-  end
-
-  def payload(char)
-    return if char.eql? '$'
-
-    @next_length = 0 if @current.length == @next_length
-
-    tokenize char do
-      @next_length = 0
-      complete_token
-    end
-  end
-
-  def tokenize(char, &block)
-    reach_delimiter = consume_delimiter(char)
-
-    if reach_delimiter
-      if @doubt_str.empty?
-        block.call
-      end
-      return
-    end
-
-    @current += char
-  end
-
-=begin
-    Common Utilities
-=end
-
-  def complete_token
-    @components << @current
-    clean_context
-  end
-
-  def clean_context
-    @current = ''
-    @token_type = nil
-  end
-
-  def consume_delimiter(char)
-    return false if @next_length != 0
-
-    if @doubt and char.eql? "\n"
-      @doubt_str = ''
-      @doubt = false
-      return true
-    end
-
-    if not @doubt and char.eql? "\r"
-      @doubt_str = "\r"
-      @doubt = true
-      return true
-    end
-
-    @doubt = false
-    @current += @doubt_str unless @doubt_str.empty?
-    @doubt_str = ''
-    return false
-  end
-
-  def detect_token_type(char)
-    case char
-      when '*'
-        :args_counts
-      when '$'
-        :length
-      else
-        :payload
-    end
+  def standard
+    RedisProtocol::UnifiedProtocol.parse @raw_data
   end
 end

data/lib/redis-protocol/response.rb

@@ -0,0 +1,22 @@
+require_relative 'unified_protocol'
+
+class RedisProtocol::Response
+  attr_reader :result, :raw_data
+
+  def <<(value)
+    @result += value.result
+    unless value.result.empty?
+      start = @raw_data.index('*') + 1
+      finish = @raw_data.index(RedisProtocol::UnifiedProtocol::DELIMITER)
+      @raw_data[start...finish] = @result.length.to_s
+
+      @raw_data += value.raw_data[(value.raw_data.index(RedisProtocol::UnifiedProtocol::DELIMITER) + RedisProtocol::UnifiedProtocol::DELIMITER.length)..-1]
+    end
+  end
+
+  def initialize(data)
+    @raw_data = data
+    @raw_data += RedisProtocol::UnifiedProtocol::DELIMITER unless @raw_data.end_with? RedisProtocol::UnifiedProtocol::DELIMITER
+    @result = RedisProtocol::UnifiedProtocol.parse @raw_data
+  end
+end

data/lib/redis-protocol/unified_protocol.rb

@@ -0,0 +1,56 @@
+class RedisProtocol::UnifiedProtocol
+  DELIMITER="\r\n"
+  class << self
+    def parse(data)
+      processed, index = 0, data.index(DELIMITER)
+      index ||= data.length
+      result = case data[processed]
+                 when '*'
+                   parse_multi_chunked data
+                 when '$'
+                   parse_chunked data
+                 when '+'
+                   parse_status data
+                 when '-'
+                   parse_error data
+                 when ':'
+                   parse_integer data
+               end
+    end
+
+    def parse_multi_chunked(data)
+      index = data.index DELIMITER
+      count = data[1...index].to_i
+      result = []
+      start = index + DELIMITER.length
+      1.upto(count) do |_|
+        chunk, length = parse_chunked data, start
+        start = length + DELIMITER.length
+        result += chunk
+      end
+
+      result
+    end
+
+    def parse_chunked(data, start=0)
+      index = data.index DELIMITER, start
+      length = data[(start+1)...index].to_i
+      return nil if length == -1
+      result = [data[index+DELIMITER.length, length]]
+
+      start == 0 ? result : [result, index+DELIMITER.length + length]
+    end
+
+    def parse_status(data)
+      [true, data[1..-1]]
+    end
+
+    def parse_error(data)
+      [false, data[1..-1]]
+    end
+
+    def parse_integer(data)
+      [data[1..-1].to_i]
+    end
+  end
+end

data/spec/redis-protocol/response_spec.rb

@@ -0,0 +1,22 @@
+require_relative '../spec_helper'
+
+describe RedisProtocol::Response do
+  it 'should be parse response' do
+    result = RedisProtocol::Response.new "*3\r\n$3\r\nset\r\n$4\r\ntest\r\n$5\r\nhello\r\n"
+    result.result[0].should eql 'set'
+    result.result[1].should eql 'test'
+    result.result[2].should eql 'hello'
+  end
+
+  it 'should be parse aggregated response' do
+    result = RedisProtocol::Response.new "*3\r\n$3\r\nset\r\n$4\r\ntest\r\n$5\r\nhello\r\n"
+    additional = RedisProtocol::Response.new "*2\r\n$5\r\nworld\r\n$6\r\nturtle\r\n"
+    result << additional
+    result.result[0].should eql 'set'
+    result.result[1].should eql 'test'
+    result.result[2].should eql 'hello'
+    result.result[3].should eql 'world'
+    result.result[4].should eql 'turtle'
+    result.raw_data.should eql "*5\r\n$3\r\nset\r\n$4\r\ntest\r\n$5\r\nhello\r\n$5\r\nworld\r\n$6\r\nturtle\r\n"
+  end
+end

data/spec/redis-protocol/unified_protocol_spec.rb

@@ -0,0 +1,34 @@
+require_relative '../spec_helper'
+
+describe RedisProtocol::UnifiedProtocol do
+  it 'should parse a redis unified protocol based message' do
+    result = RedisProtocol::UnifiedProtocol.parse "$4\r\nping"
+    result[0].should eql 'ping'
+  end
+
+  it 'should parse multi-chunked format' do
+    result = RedisProtocol::UnifiedProtocol.parse "*1\r\n$4\r\nping"
+    result[0].should eql 'ping'
+    result = RedisProtocol::UnifiedProtocol.parse "*2\r\n$4\r\nkeys\r\n$1\r\n*\r\n"
+    result[0].should eql 'keys'
+    result[1].should eql '*'
+  end
+
+  it 'should parse status ok' do
+    result = RedisProtocol::UnifiedProtocol.parse '+ok'
+    result[0].should be true
+    result[1].should eql 'ok'
+  end
+
+  it 'should parse error with message' do
+    result = RedisProtocol::UnifiedProtocol.parse "-ERR unknown command 'foobar'"
+    result[0].should be false
+    result[1].should eql "ERR unknown command 'foobar'"
+  end
+
+  it 'should parse integer only return' do
+    result = RedisProtocol::UnifiedProtocol.parse ":1000\r\n"
+    result[0].should be 1000
+    RedisProtocol::UnifiedProtocol.parse(':-30')[0].should be -30
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis-protocol
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-12 00:00:00.000000000 Z
+date: 2013-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -127,9 +127,11 @@ files:
 - VERSION
 - lib/redis-protocol.rb
 - lib/redis-protocol/request.rb
-- lib/redis-protocol/static_request.rb
+- lib/redis-protocol/response.rb
+- lib/redis-protocol/unified_protocol.rb
 - spec/redis-protocol/request_spec.rb
-- spec/redis-protocol/static_request_spec.rb
+- spec/redis-protocol/response_spec.rb
+- spec/redis-protocol/unified_protocol_spec.rb
 - spec/redis-protocol_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/astral1/redis-protocol
@@ -147,7 +149,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 3700473079050196087
+      hash: -1569199417732497117
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:

data/lib/redis-protocol/static_request.rb

@@ -1,77 +0,0 @@
-class RedisProtocol::StaticRequest
-  attr_reader :raw_data, :type, :components, :component_count
-  OP_DELIMITER = "\r\n"
-
-  def initialize(data)
-    @raw_data = data
-    parse_request
-  end
-
-  def parse_request
-    @type = check_request_type
-
-    send @type
-  end
-
-  def self.recognize(data)
-    (check_request_type == :inline) ? data.split[0] : data.split(OP_DELIMITER)[2]
-  end
-
-  def check_request_type
-    (@raw_data.start_with? '*') ? :standard : :inline
-  end
-
-  def standard
-    components = []
-    data = @raw_data.dup
-    operand_length, payload = operand_length_for data.split(OP_DELIMITER)
-    1.upto(operand_length).each do |_|
-      data, payload = unpack_payload(payload)
-      components << data
-    end
-    @component_count = components.count
-    @components = components
-  end
-
-  def operand_length_for(data)
-    operand_length, payload = next_token data
-    raise "invalid packet : #{operand_length}" unless operand_length.start_with? '*'
-    operand_length = operand_length[1..-1].to_i
-
-    [operand_length, payload]
-  end
-
-  def unpack_payload(payload)
-    field_length, payload = next_token payload
-    raise "invalid length format : #{field_length}" unless field_length.start_with? '$'
-    field_length = field_length[1..-1].to_i
-    next_token payload, field_length
-  end
-
-  def inline
-    @components = @raw_data.split
-    @component_count = @components.count
-    @components
-  end
-
-  def next_token(data, length = 0)
-    if data[0].length == length || length == 0
-      [data[0], data[1..-1]]
-    else
-      multiline_token(data, length)
-    end
-  end
-
-  def multiline_token(data, length)
-    val, index = '', 0
-    data.each do |token|
-      val.empty? ? val = token : val += "\r\n#{token}"
-      index += 1
-
-      break if val.length == length
-    end
-    [val, data[index..-1]]
-  end
-
-  private :next_token, :standard, :inline, :operand_length_for, :unpack_payload, :multiline_token
-end

data/spec/redis-protocol/static_request_spec.rb

@@ -1,54 +0,0 @@
-require_relative '../spec_helper'
-
-describe RedisProtocol::StaticRequest do
-  it 'initialize with data' do
-    RedisProtocol::StaticRequest.new 'ping'
-  end
-
-  it 'should get raw data as original' do
-    request = RedisProtocol::StaticRequest.new 'ping'
-    request.raw_data.should eql 'ping'
-  end
-
-  it 'should parse inline command' do
-    request = RedisProtocol::StaticRequest.new 'ping'
-    request.components[0].should eql 'ping'
-    request.component_count.should be 1
-  end
-
-  it 'should parse inline command with parameter' do
-    request = RedisProtocol::StaticRequest.new 'keys *'
-    request.components[0].should eql 'keys'
-    request.component_count.should be 2
-  end
-
-  it 'should parse inline command with multi whitespaces' do
-    request = RedisProtocol::StaticRequest.new 'keys    *'
-    request.components[0].should eql 'keys'
-    request.component_count.should be 2
-  end
-
-  it 'should parse standard command' do
-    request = RedisProtocol::StaticRequest.new "*1\r\n$4\r\nping"
-    request.components[0].should eql 'ping'
-    request.component_count.should be 1
-  end
-
-  it 'should parse standard command with parameter' do
-    request = RedisProtocol::StaticRequest.new "*2\r\n$4\r\nkeys\r\n$1\r\n*"
-    request.components[0].should eql 'keys'
-    request.component_count.should be 2
-  end
-
-  it 'should parse standard command with multiple parameters' do
-    request = RedisProtocol::StaticRequest.new "*3\r\n$3\r\nset\r\n$4\r\ntest\r\n$5\r\nhello"
-    request.components[0].should eql 'set'
-    request.component_count.should be 3
-  end
-
-  it 'should parse standard command containing delimiter' do
-    request = RedisProtocol::StaticRequest.new "*3\r\n$3\r\nset\r\n$4\r\ntest\r\n$12\r\nhello\r\nworld"
-    request.components[2].should eql "hello\r\nworld"
-    request.component_count.should be 3
-  end
-end