em-redis 0.2.3 → 0.3.0

data/lib/em-redis.rb

@@ -1,47 +1,2 @@
-
-module EMRedis
-
-  # :stopdoc:
-  VERSION = '0.2.3'
-  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
-  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
-  # :startdoc:
-
-  # Returns the version string for the library.
-  #
-  def self.version
-    VERSION
-  end
-
-  # Returns the library path for the module. If any arguments are given,
-  # they will be joined to the end of the libray path using
-  # <tt>File.join</tt>.
-  #
-  def self.libpath( *args )
-    args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
-  end
-
-  # Returns the lpath for the module. If any arguments are given,
-  # they will be joined to the end of the path using
-  # <tt>File.join</tt>.
-  #
-  def self.path( *args )
-    args.empty? ? PATH : ::File.join(PATH, args.flatten)
-  end
-
-  # Utility method used to require all files ending in .rb that lie in the
-  # directory below this file that has the same name as the filename passed
-  # in. Optionally, a specific _directory_ name can be passed in such that
-  # the _filename_ does not have to be equivalent to the directory.
-  #
-  def self.require_all_libs_relative_to( fname, dir = nil )
-    dir ||= ::File.basename(fname, '.*')
-    search_me = ::File.expand_path(
-        ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
-
-    Dir.glob(search_me).sort.each {|rb| require rb}
-  end
-
-end  # module EMRedis
-
-EMRedis.require_all_libs_relative_to(__FILE__)
+require File.expand_path('../em-redis/version', __FILE__)
+require File.expand_path('../em-redis/redis_protocol', __FILE__)

data/lib/em-redis/redis_protocol.rb

@@ -18,36 +18,6 @@ module EventMachine
       ASTERISK = "*".freeze
       DELIM    = "\r\n".freeze
 
-      BULK_COMMANDS = {
-        "set"       => true,
-        "setnx"     => true,
-        "rpush"     => true,
-        "lpush"     => true,
-        "lset"      => true,
-        "lrem"      => true,
-        "sadd"      => true,
-        "srem"      => true,
-        "sismember" => true,
-        "echo"      => true,
-        "getset"    => true,
-        "smove"     => true,
-        "zadd"      => true,
-        "zincrby"   => true,
-        "zrem"      => true,
-        "zscore"    => true,
-        "hget"      => true,
-        "hdel"      => true,
-        "hexists"   => true
-      }
-
-      MULTI_BULK_COMMANDS = {
-        "mset"      => true,
-        "msetnx"    => true,
-        "hset"      => true,
-        # these aliases aren't in redis gem
-        "multi_get" => true
-      }
-
       BOOLEAN_PROCESSOR = lambda{|r| r == 1 }
 
       REPLY_PROCESSOR = {
@@ -186,11 +156,11 @@ module EventMachine
       def sort(key, options={}, &blk)
         cmd = ["SORT"]
         cmd << key
-        cmd << "BY #{options[:by]}" if options[:by]
-        cmd << "GET #{[options[:get]].flatten * ' GET '}" if options[:get]
-        cmd << "#{options[:order]}" if options[:order]
-        cmd << "LIMIT #{options[:limit].join(' ')}" if options[:limit]
-        call_command(cmd, &blk)
+        cmd << ["BY", options[:by]] if options[:by]
+        cmd << [options[:get]].flatten.map { |key| ["GET", key] } if options[:get]
+        cmd << options[:order].split(/\s+/) if options[:order]
+        cmd << ["LIMIT", options[:limit]] if options[:limit]
+        call_command(cmd.flatten, &blk)
       end
 
       def incr(key, increment = nil, &blk)
@@ -296,26 +266,16 @@ module EventMachine
         argv = argv.dup
 
         argv[0] = argv[0].to_s.downcase
-        if MULTI_BULK_COMMANDS[argv[0]]
-          command = ""
-          command << "*#{argv.size}\r\n"
-          argv.each do |a|
-            a = a.to_s
-            command << "$#{get_size(a)}\r\n"
-            command << a
-            command << "\r\n"
-          end
-        else
-          command = ""
-          bulk = nil
-          argv[0] = ALIASES[argv[0]] if ALIASES[argv[0]]
-          raise "#{argv[0]} command is disabled" if DISABLED_COMMANDS[argv[0]]
-          if BULK_COMMANDS[argv[0]] and argv.length > 1
-            bulk = argv[-1].to_s
-            argv[-1] = get_size(bulk)
-          end
-          command << "#{argv.join(' ')}\r\n"
-          command << "#{bulk}\r\n" if bulk
+        argv[0] = ALIASES[argv[0]] if ALIASES[argv[0]]
+        raise "#{argv[0]} command is disabled" if DISABLED_COMMANDS[argv[0]]
+
+        command = ""
+        command << "*#{argv.size}\r\n"
+        argv.each do |a|
+          a = a.to_s
+          command << "$#{get_size(a)}\r\n"
+          command << a
+          command << "\r\n"
         end
 
         @logger.debug { "*** sending: #{command}" } if @logger

data/lib/em-redis/version.rb

@@ -0,0 +1,3 @@
+module EMRedis
+  VERSION = '0.3.0' unless defined? ::EMRedis::VERSION
+end

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: em-redis
 version: !ruby/object:Gem::Version 
+  hash: 19
   prerelease: false
   segments: 
   - 0
-  - 2
   - 3
-  version: 0.2.3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Jonathan Broad
@@ -15,113 +16,84 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-11 00:00:00 +04:00
+date: 2010-11-23 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: eventmachine
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
         - 0
-        - 12
-        - 10
-        version: 0.12.10
+        version: "0"
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: bacon
+  name: bundler
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
+        hash: 15424249
         segments: 
         - 1
-        - 1
         - 0
-        version: 1.1.0
+        - rc
+        - 6
+        version: 1.0.rc.6
   type: :development
   version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: em-spec
-  prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 2
-        - 1
-        version: 0.2.1
-  type: :development
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: bones
-  prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 3
-        - 2
-        - 1
-        version: 3.2.1
-  type: :development
-  version_requirements: *id004
 description: An eventmachine-based implementation of the Redis protocol
 email: libc@me.com
 executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- History.txt
-- README.rdoc
+extra_rdoc_files: []
+
 files: 
-- .gitignore
-- History.txt
-- README.rdoc
-- Rakefile
-- lib/em-redis.rb
 - lib/em-redis/redis_protocol.rb
-- spec/live_redis_protocol_spec.rb
-- spec/redis_commands_spec.rb
-- spec/redis_protocol_spec.rb
-- spec/test_helper.rb
+- lib/em-redis/version.rb
+- lib/em-redis.rb
+- History.txt
 has_rdoc: true
 homepage: http://github.com/libc/em-redis
 licenses: []
 
 post_install_message: 
-rdoc_options: 
-- --main
-- README.rdoc
+rdoc_options: []
+
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
-rubyforge_project: em-redis
-rubygems_version: 1.3.6
+rubyforge_project: 
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: An eventmachine-based implementation of the Redis protocol

data/.gitignore

@@ -1,2 +0,0 @@
-.DS_Store
-pkg

data/README.rdoc

@@ -1,85 +0,0 @@
-== EM-REDIS
-
-== DESCRIPTION:
-
-An EventMachine[http://rubyeventmachine.com/] based library for interacting with the very cool Redis[http://code.google.com/p/redis/] data store by Salvatore 'antirez' Sanfilippo.
-Modeled after eventmachine's implementation of the memcached protocol, and influenced by Ezra Zygmuntowicz's {redis-rb}[http://github.com/ezmobius/redis-rb/tree/master] library (distributed as part of Redis).
-
-This library is only useful when used as part of an application that relies on
-Event Machine's event loop.  It implements an EM-based client protocol, which
-leverages the non-blocking nature of the EM interface to achieve significant
-parallelization without threads.
-
-
-== FEATURES/PROBLEMS:
-
-Implements most Redis commands (see {the list of available commands here}[http://code.google.com/p/redis/wiki/CommandReference] with the notable
-exception of MONITOR.
-
-== SYNOPSIS:
-
-Like any Deferrable eventmachine-based protocol implementation, using EM-Redis involves making calls and passing blocks that serve as callbacks when the call returns.  
-
-  require 'em-redis'
-
-  EM.run do
-    redis = EM::Protocols::Redis.connect
-    redis.errback do |code|
-      puts "Error code: #{code}"
-    end
-    redis.set "a", "foo" do |response|
-      redis.get "a" do |response|
-        puts response
-      end
-    end
-    # We get pipelining for free
-    redis.set("b", "bar")
-    redis.get("a") do |response|
-      puts response # will be foo
-    end
-  end
-
-To run tests on a Redis server (currently compatible with 1.3)
-
-  rake
-
-Because the EM::Protocol::Memcached code used Bacon for testing, test code is
-currently in the form of bacon specs.
-
-== REQUIREMENTS:
-
-* Redis (download[http://code.google.com/p/redis/downloads/list])
-
-== INSTALL:
-
-  sudo gem install em-redis
-
-== LICENSE:
-
-(The MIT License)
-
-Copyright (c) 2008, 2009
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-'Software'), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-== CREDIT
-
-    by Jonathan Broad (http://www.relativepath.org)
-

data/Rakefile

@@ -1,41 +0,0 @@
-# Look in the tasks/setup.rb file for the various options that can be
-# configured in this Rakefile. The .rake files in the tasks directory
-# are where the options are used.
-
-begin
-  require 'bones'
-rescue LoadError
-  abort '### Please install the "bones" gem ###'
-end
-
-ensure_in_path 'lib'
-require 'em-redis'
-
-task :default => ['redis:test']
-
-Bones {
-  name 'em-redis'
-  authors ['Jonathan Broad', 'Eugene Pimenov']
-  email 'libc@me.com'
-  url 'http://github.com/libc/em-redis'
-  summary 'An eventmachine-based implementation of the Redis protocol'
-  description summary
-  version EMRedis::VERSION
-
-  readme_file  'README.rdoc'
-  ignore_file  '.gitignore'
-
-  depend_on 'eventmachine', '>=0.12.10'
-
-  depend_on "bacon", :development => true
-  depend_on "em-spec", :development => true 
-}
-
-namespace :redis do
-  desc "Test em-redis against a live Redis"
-  task :test do
-    sh "bacon spec/live_redis_protocol_spec.rb spec/redis_commands_spec.rb spec/redis_protocol_spec.rb"
-  end
-end
-
-# EOF

data/spec/live_redis_protocol_spec.rb

@@ -1,446 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + "/test_helper.rb")
-
-EM.describe EM::Protocols::Redis, "connected to an empty db" do
-
-  before do
-    @c = EM::Protocols::Redis.connect :db => 14
-    @c.flushdb
-  end
-
-  should "be able to set a string value" do
-    @c.set("foo", "bar") do |r|
-      r.should == "OK"
-      done
-    end
-  end
-
-  should "be able to increment the value of a string" do
-    @c.incr "foo" do |r|
-      r.should == 1
-      @c.incr "foo" do |r|
-        r.should == 2
-        done
-      end
-    end
-  end
-  
-  should "be able to increment the value of a string by an amount" do
-    @c.incrby "foo", 10 do |r|
-      r.should == 10
-      done
-    end
-  end
-
-  should "be able to decrement the value of a string" do
-    @c.incr "foo" do |r|
-      r.should == 1
-      @c.decr "foo" do |r|
-        r.should == 0
-        done
-      end
-    end
-  end
-
-  should "be able to decrement the value of a string by an amount" do
-    @c.incrby "foo", 20 do |r|
-      r.should == 20
-      @c.decrby "foo", 10 do |r|
-        r.should == 10
-        done
-      end
-    end
-  end
-
-  should "be able to 'lpush' to a nonexistent list" do
-    @c.lpush("foo", "bar") do |r|
-      r.should == 1
-      done
-    end
-  end
-
-  should "be able to 'rpush' to a nonexistent list" do
-    @c.rpush("foo", "bar") do |r|
-      r.should == 1
-      done
-    end
-  end
-
-
-  should "be able to get the size of the database" do
-    @c.dbsize do |r|
-      r.should == 0
-      done
-    end
-  end
-
-  should "be able to add a member to a nonexistent set" do
-    @c.sadd("set_foo", "bar") do |r|
-      r.should == true
-      done
-    end
-  end
-
-  should "be able to get info about the db as a hash" do
-    @c.info do |r|
-      r.should.key? :redis_version
-      done
-    end
-  end
-
-  should "be able to save db" do
-    @c.save do |r|
-      r.should == "OK"
-      done
-    end
-  end
-
-  should "be able to save db in the background" do
-    @c.bgsave do |r|
-      r.should == "Background saving started"
-      done
-    end
-  end
-
-end
-
-EM.describe EM::Protocols::Redis, "connected to a db containing some simple string-valued keys" do
-
-  before do
-    @c = EM::Protocols::Redis.connect :db => 14
-    @c.flushdb
-    @c.set "a", "b"
-    @c.set "x", "y"
-  end
-
-  should "be able to fetch the values of multiple keys" do
-    @c.mget "a", "x" do |r|
-      r.should == ["b", "y"]
-      done
-    end
-  end
-
-  should "be able to fetch the values of multiple keys in a hash" do
-    @c.mapped_mget "a", "x" do |r|
-      r.should == {"a" => "b",  "x" => "y"}
-      done
-    end
-  end
-
-  should "be able to fetch all the keys" do
-    @c.keys "*" do |r|
-      r.sort.should == ["a", "x"]
-      done
-    end
-  end
-
-  should "be able to set a value if a key doesn't exist" do
-    @c.setnx "a", "foo" do |r|
-      r.should == false
-      @c.setnx "zzz", "foo" do |r|
-        r.should == true
-        done
-      end
-    end
-  end
-
-  should "be able to test for the existence of a key" do
-    @c.exists "a" do |r|
-      r.should == true
-      @c.exists "zzz" do |r|
-        r.should == false
-        done
-      end
-    end
-  end
-  
-  should "be able to delete a key" do
-    @c.del "a" do |r|
-      r.should == true
-      @c.exists "a" do |r|
-        r.should == false
-        @c.del "a" do |r|
-          r.should == false
-          done
-        end
-      end
-    end
-  end
-
-  should "be able to detect the type of a key, existing or not" do
-    @c.type "a" do |r|
-      r.should == "string"
-      @c.type "zzz" do |r|
-        r.should == "none"
-        done
-      end
-    end
-  end
-
-  should "be able to rename a key" do
-    @c.rename "a", "x" do |r|
-      @c.get "x" do |r|
-        r.should == "b"
-        done
-      end
-    end
-  end
-
-  should "be able to rename a key unless it exists" do
-    @c.renamenx "a", "x" do |r|
-      r.should == false
-      @c.renamenx "a", "zzz" do |r|
-        r.should == true
-        @c.get "zzz" do |r|
-          r.should == "b"
-          done
-        end
-      end
-    end
-  end
-
-
-end
-
-EM.describe EM::Protocols::Redis, "connected to a db containing a list" do
-
-  before do
-    @c = EM::Protocols::Redis.connect :db => 14
-    @c.flushdb
-    @c.lpush "foo", "c"
-    @c.lpush "foo", "b"
-    @c.lpush "foo", "a"
-  end
-   
-  should "be able to 'lset' a list member and 'lindex' to retrieve it" do
-    @c.lset("foo",  1, "bar") do |r|
-      @c.lindex("foo", 1) do |r|
-        r.should == "bar"
-        done
-      end
-    end
-  end
-
-  should "be able to 'rpush' onto the tail of the list" do
-    @c.rpush "foo", "d" do |r|
-      r.should == 4
-      @c.rpop "foo" do |r|
-        r.should == "d"
-        done
-      end
-    end
-  end
-
-  should "be able to 'lpush' onto the head of the list" do
-    @c.lpush "foo", "d" do |r|
-      r.should == 4
-      @c.lpop "foo" do |r|
-        r.should == "d"
-        done
-      end
-    end
-  end
-
-  should "be able to 'rpop' off the tail of the list" do
-    @c.rpop("foo") do |r|
-      r.should == "c"
-      done
-    end
-  end
-
-  should "be able to 'lpop' off the tail of the list" do
-    @c.lpop("foo") do |r|
-      r.should == "a"
-      done
-    end
-  end
-
-  should "be able to get a range of values from a list" do
-    @c.lrange("foo", 0, 1) do |r|
-      r.should == ["a", "b"]
-      done
-    end
-  end
-
-  should "be able to 'ltrim' a list" do
-    @c.ltrim("foo", 0, 1) do |r|
-      r.should == "OK"
-      @c.llen("foo") do |r|
-        r.should == 2
-        done
-      end
-    end
-  end
-
-  should "be able to 'rem' a list element" do
-    @c.lrem("foo", 0, "a") do |r|
-      r.should == 1
-      @c.llen("foo") do |r|
-        r.should == 2
-        done
-      end
-    end
-  end
-
-  should "be able to detect the type of a list" do
-    @c.type "foo" do |r|
-      r.should == "list"
-      done
-    end
-  end
-
-end
-
-EM.describe EM::Protocols::Redis, "connected to a db containing two sets" do
-  before do
-    @c = EM::Protocols::Redis.connect :db => 14
-    @c.flushdb
-    @c.sadd "foo", "a"
-    @c.sadd "foo", "b"
-    @c.sadd "foo", "c"
-    @c.sadd "bar", "c"
-    @c.sadd "bar", "d"
-    @c.sadd "bar", "e"
-  end
-
-  should "be able to find a set's cardinality" do
-    @c.scard("foo") do |r|
-      r.should == 3
-      done
-    end
-  end
-
-  should "be able to add a new member to a set unless it is a duplicate" do
-    @c.sadd("foo", "d") do |r|
-      r.should == true # success
-      @c.sadd("foo", "a") do |r|
-        r.should == false # failure
-        @c.scard("foo") do |r|
-          r.should == 4
-          done
-        end
-      end
-    end
-  end
-
-  should "be able to remove a set member if it exists" do
-    @c.srem("foo", "a") do |r|
-      r.should == true
-      @c.srem("foo", "z") do |r|
-        r.should == false
-        @c.scard("foo") do |r|
-          r.should == 2
-          done
-        end
-      end
-    end
-  end
-
-  should "be able to retrieve a set's members" do
-    @c.smembers("foo") do |r|
-      r.sort.should == ["a", "b", "c"]
-      done
-    end
-  end
-
-  should "be able to detect set membership" do
-    @c.sismember("foo", "a") do |r|
-      r.should == true
-      @c.sismember("foo", "z") do |r|
-        r.should == false
-        done
-      end
-    end
-  end
-
-  should "be able to find the sets' intersection" do
-    @c.sinter("foo", "bar") do |r|
-      r.should == ["c"]
-      done
-    end
-  end
-
-  should "be able to find and store the sets' intersection" do
-    @c.sinterstore("baz", "foo", "bar") do |r|
-      r.should == 1
-      @c.smembers("baz") do |r|
-        r.should == ["c"]
-        done
-      end
-    end
-  end
-
-  should "be able to find the sets' union" do
-    @c.sunion("foo", "bar") do |r|
-      r.sort.should == ["a","b","c","d","e"]
-      done
-    end
-  end
-
-  should "be able to find and store the sets' union" do
-    @c.sunionstore("baz", "foo", "bar") do |r|
-      r.should == 5
-      @c.smembers("baz") do |r|
-        r.sort.should == ["a","b","c","d","e"]
-        done
-      end
-    end
-  end
-
-  should "be able to detect the type of a set" do
-    @c.type "foo" do |r|
-      r.should == "set"
-      done
-    end
-  end
-
-end
-
-
-EM.describe EM::Protocols::Redis, "connected to a db containing three linked lists" do
-  before do
-    @c = EM::Protocols::Redis.connect :db => 14
-    @c.flushdb
-    @c.rpush "foo", "a"
-    @c.rpush "foo", "b"
-    @c.set "a_sort", "2"
-    @c.set "b_sort", "1"
-    @c.set "a_data", "foo"
-    @c.set "b_data", "bar"
-  end
-
-  should "be able to collate a sorted set of data" do
-    @c.sort("foo", :by => "*_sort", :get => "*_data") do |r|
-      r.should == ["bar", "foo"]
-      done
-    end
-  end
-
-  should "be able to get keys selectively" do
-    @c.keys "a_*" do |r|
-      r.should == ["a_sort", "a_data"].sort
-      done
-    end
-  end
-end
-
-EM.describe EM::Protocols::Redis, "when reconnecting" do
-  before do
-    @c = EM::Protocols::Redis.connect :db => 14
-    @c.flushdb
-  end
-
-  should "select previously selected datase" do
-    #simulate disconnect
-    @c.set('foo', 'a') { @c.close_connection_after_writing }
-
-    EM.add_timer(2) do
-      @c.get('foo') do |r|
-        r.should == 'a'
-        @c.get('non_existing') do |r|
-          r.should == nil
-          done
-        end
-      end
-    end
-  end
-end