fakeredis 0.4.1 → 0.4.2

data/.travis.yml

@@ -2,7 +2,7 @@ rvm:
   - 1.8.7
   - 1.9.2
   - 1.9.3
-  - ruby-head
+  - 2.0.0
   - ree
   - jruby
-  - rbx
+  - rbx-19mode

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2011-2012 Guillermo Iguaran
+Copyright (c) 2011-2013 Guillermo Iguaran
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,4 +1,4 @@
-# FakeRedis [![Build Status](http://travis-ci.org/guilleiguaran/fakeredis.png)](http://travis-ci.org/guilleiguaran/fakeredis)
+# FakeRedis [![Build Status](https://secure.travis-ci.org/guilleiguaran/fakeredis.png)](http://travis-ci.org/guilleiguaran/fakeredis)
 This a fake implementation of redis-rb for machines without Redis or test environments
 
 
@@ -65,6 +65,7 @@ Or:
 * [jredville](https://github.com/jredville)
 * [redsquirrel](https://github.com/redsquirrel)
 * [dpick](https://github.com/dpick)
+* [caius](https://github.com/caius) 
 * [Travis-CI](http://travis-ci.org/) (Travis-CI also uses Fakeredis in its tests!!!)
 
 
@@ -81,5 +82,5 @@ Or:
 
 ## Copyright
 
-Copyright (c) 2011-2012 Guillermo Iguaran. See LICENSE for
+Copyright (c) 2011-2013 Guillermo Iguaran. See LICENSE for
 further details.

data/fakeredis.gemspec

@@ -8,12 +8,11 @@ Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Guillermo Iguaran"]
   s.email       = ["guilleiguaran@gmail.com"]
-  s.homepage    = "https://github.com/guilleiguaran/fakeredis"
+  s.homepage    = "https://guilleiguaran.github.com/fakeredis"
+  s.license     = "MIT"
   s.summary     = %q{Fake (In-memory) driver for redis-rb.}
   s.description = %q{Fake (In-memory) driver for redis-rb. Useful for testing environment and machines without Redis.}
 
-  s.rubyforge_project = "fakeredis"
-
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }

data/lib/fake_redis.rb

@@ -0,0 +1 @@
+require "fakeredis"

data/lib/fakeredis/expiring_hash.rb

@@ -0,0 +1,70 @@
+module FakeRedis
+  # Represents a normal hash with some additional expiration information
+  # associated with each key
+  class ExpiringHash < Hash
+    attr_reader :expires
+
+    def initialize(*)
+      super
+      @expires = {}
+    end
+
+    def [](key)
+      key = normalize key
+      delete(key) if expired?(key)
+      super
+    end
+
+    def []=(key, val)
+      key = normalize key
+      expire(key)
+      super
+    end
+
+    def delete(key)
+      key = normalize key
+      expire(key)
+      super
+    end
+
+    def expire(key)
+      key = normalize key
+      expires.delete(key)
+    end
+
+    def expired?(key)
+      key = normalize key
+      expires.include?(key) && expires[key] < Time.now
+    end
+
+    def key?(key)
+      key = normalize key
+      delete(key) if expired?(key)
+      super
+    end
+
+    def values_at(*keys)
+      keys.each do |key|
+        key = normalize(key)
+        delete(key) if expired?(key)
+      end
+      super
+    end
+
+    def keys
+      super.select do |key|
+        key = normalize(key)
+        if expired?(key)
+          delete(key)
+          false
+        else
+          true
+        end
+      end
+    end
+
+    def normalize key
+      key.to_s
+    end
+  end
+end

data/lib/fakeredis/rspec.rb

@@ -17,7 +17,7 @@ require 'fakeredis'
 RSpec.configure do |c|
 
   c.before do    
-    Redis::Connection::Memory.instances.values.each &:flushdb
+    Redis::Connection::Memory.reset_all_databases
   end
 
 end

data/lib/fakeredis/sorted_set_argument_handler.rb

@@ -0,0 +1,74 @@
+module FakeRedis
+  # Takes in the variable length array of arguments for a zinterstore/zunionstore method
+  # and parses them into a few attributes for the method to access.
+  #
+  # Handles throwing errors for various scenarios (matches redis):
+  #   * Custom weights specified, but not enough or too many given
+  #   * Invalid aggregate value given
+  #   * Multiple aggregate values given
+  class SortedSetArgumentHandler
+    # [Symbol] The aggregate method to use for the output values. One of %w(sum min max) expected
+    attr_reader :aggregate
+    # [Integer] Number of keys in the argument list
+    attr_accessor :number_of_keys
+    # [Array] The actual keys in the argument list
+    attr_accessor :keys
+    # [Array] integers for weighting the values of each key - one number per key expected
+    attr_accessor :weights
+
+    # Used internally
+    attr_accessor :type
+
+    # Expects all the argments for the method to be passed as an array
+    def initialize args
+      # Pull out known lengths of data
+      self.number_of_keys = args.shift
+      self.keys = args.shift(number_of_keys)
+      # Handle the variable lengths of data (WEIGHTS/AGGREGATE)
+      args.inject(self) {|handler, item| handler.handle(item) }
+
+      # Defaults for unspecified things
+      self.weights ||= Array.new(number_of_keys) { 1 }
+      self.aggregate ||= :sum
+
+      # Validate values
+      raise(Redis::CommandError, "ERR syntax error") unless weights.size == number_of_keys
+      raise(Redis::CommandError, "ERR syntax error") unless [:min, :max, :sum].include?(aggregate)
+    end
+
+    # Only allows assigning a value *once* - raises Redis::CommandError if a second is given
+    def aggregate=(str)
+      raise(Redis::CommandError, "ERR syntax error") if (defined?(@aggregate) && @aggregate)
+      @aggregate = str.to_s.downcase.to_sym
+    end
+
+    # Decides how to handle an item, depending on where we are in the arguments
+    def handle(item)
+      case item
+      when "WEIGHTS"
+        self.type = :weights
+        self.weights = []
+      when "AGGREGATE"
+        self.type = :aggregate
+      when nil
+        # This should never be called, raise a syntax error if we manage to hit it
+        raise(Redis::CommandError, "ERR syntax error")
+      else
+        send "handle_#{type}", item
+      end
+      self
+    end
+
+    def handle_weights(item)
+      self.weights << item
+    end
+
+    def handle_aggregate(item)
+      self.aggregate = item
+    end
+
+    def inject_block
+      lambda { |handler, item| handler.handle(item) }
+    end
+  end
+end

data/lib/fakeredis/sorted_set_store.rb

@@ -0,0 +1,80 @@
+module FakeRedis
+  class SortedSetStore
+    attr_accessor :data, :weights, :aggregate, :keys
+
+    def initialize params, data
+      self.data = data
+      self.weights = params.weights
+      self.aggregate = params.aggregate
+      self.keys = params.keys
+    end
+
+    def hashes
+      @hashes ||= keys.map do |src|
+        case data[src]
+        when ::Set
+          # Every value has a score of 1
+          Hash[data[src].map {|k,v| [k, 1]}]
+        when Hash
+          data[src]
+        else
+          {}
+        end
+      end
+    end
+
+    # Apply the weightings to the hashes
+    def computed_values
+      unless defined?(@computed_values) && @computed_values
+        # Do nothing if all weights are 1, as n * 1 is n
+        @computed_values = hashes if weights.all? {|weight| weight == 1 }
+        # Otherwise, multiply the values in each hash by that hash's weighting
+        @computed_values ||= hashes.each_with_index.map do |hash, index|
+          weight = weights[index]
+          Hash[hash.map {|k, v| [k, (v * weight)]}]
+        end
+      end
+      @computed_values
+    end
+
+    def aggregate_sum out
+      selected_keys.each do |key|
+        out[key] = computed_values.inject(0) do |n, hash|
+          n + (hash[key] || 0)
+        end
+      end
+    end
+
+    def aggregate_min out
+      selected_keys.each do |key|
+        out[key] = computed_values.map {|h| h[key] }.compact.min
+      end
+    end
+
+    def aggregate_max out
+      selected_keys.each do |key|
+        out[key] = computed_values.map {|h| h[key] }.compact.max
+      end
+    end
+
+    def selected_keys
+      raise NotImplemented, "subclass needs to implement #selected_keys"
+    end
+
+    def call
+      ZSet.new.tap {|out| send("aggregate_#{aggregate}", out) }
+    end
+  end
+
+  class SortedSetIntersectStore < SortedSetStore
+    def selected_keys
+      @values ||= hashes.inject([]) { |r, h| r.empty? ? h.keys : (r & h.keys) }
+    end
+  end
+
+  class SortedSetUnionStore < SortedSetStore
+    def selected_keys
+      @values ||= hashes.map(&:keys).flatten.uniq
+    end
+  end
+end

data/lib/fakeredis/version.rb

@@ -1,3 +1,3 @@
 module FakeRedis
-  VERSION = "0.4.1"
+  VERSION = "0.4.2"
 end

data/lib/fakeredis/zset.rb

@@ -0,0 +1,29 @@
+module FakeRedis
+  class ZSet < Hash
+
+    def []=(key, val)
+      super(key, _floatify(val))
+    end
+
+    # Increments the value of key by val
+    def increment(key, val)
+      self[key] += _floatify(val)
+    end
+
+    def select_by_score min, max
+      min = _floatify(min)
+      max = _floatify(max)
+      reject {|_,v| v < min || v > max }
+    end
+
+    # Originally lifted from redis-rb
+    def _floatify(str)
+      if (( inf = str.to_s.match(/^([+-])?inf/i) ))
+        (inf[1] == "-" ? -1.0 : 1.0) / 0.0
+      else
+        Float str
+      end
+    end
+
+  end
+end

data/lib/redis/connection/memory.rb

@@ -1,104 +1,88 @@
 require 'set'
 require 'redis/connection/registry'
 require 'redis/connection/command_helper'
+require "fakeredis/expiring_hash"
+require "fakeredis/sorted_set_argument_handler"
+require "fakeredis/sorted_set_store"
+require "fakeredis/zset"
 
 class Redis
   module Connection
     class Memory
-      # Represents a normal hash with some additional expiration information
-      # associated with each key
-      class ExpiringHash < Hash
-        attr_reader :expires
-
-        def initialize(*)
-          super
-          @expires = {}
-        end
-
-        def [](key)
-          delete(key) if expired?(key)
-          super
-        end
-
-        def []=(key, val)
-          expire(key)
-          super
-        end
+      include Redis::Connection::CommandHelper
+      include FakeRedis
 
-        def delete(key)
-          expire(key)
-          super
-        end
+      attr_accessor :buffer, :options
 
-        def expire(key)
-          expires.delete(key)
-        end
+      # Tracks all databases for all instances across the current process.
+      # We have to be able to handle two clients with the same host/port accessing
+      # different databases at once without overwriting each other. So we store our
+      # "data" outside the client instances, in this class level instance method.
+      # Client instances access it with a key made up of their host/port, and then select
+      # which DB out of the array of them they want. Allows the access we need.
+      def self.databases
+        @databases ||= Hash.new {|h,k| h[k] = [] }
+      end
 
-        def expired?(key)
-          expires.include?(key) && expires[key] < Time.now
-        end
+      # Used for resetting everything in specs
+      def self.reset_all_databases
+        @databases = nil
+      end
 
-        def key?(key)
-          delete(key) if expired?(key)
-          super
-        end
+      def self.connect(options = {})
+        new(options)
+      end
 
-        def values_at(*keys)
-          keys.each {|key| delete(key) if expired?(key)}
-          super
-        end
+      def initialize(options = {})
+        self.options = options
+      end
 
-        def keys
-          super.select do |key|
-            if expired?(key)
-              delete(key)
-              false
-            else
-              true
-            end
-          end
-        end
+      def database_id
+        @database_id ||= 0
       end
+      attr_writer :database_id
 
-      class ZSet < Hash
+      def database_instance_key
+        [options[:host], options[:port]].hash
       end
 
-      include Redis::Connection::CommandHelper
+      def databases
+        self.class.databases[database_instance_key]
+      end
 
-      def initialize(connected = false)
-        @data = ExpiringHash.new
-        @connected = connected
-        @replies = []
-        @buffer = nil
+      def find_database id=database_id
+        databases[id] ||= ExpiringHash.new
       end
 
-      def connected?
-        @connected
+      def data
+        find_database
       end
 
-      def self.instances
-        @instances ||= {}
+      def replies
+        @replies ||= []
       end
+      attr_writer :replies
 
-      def self.connect(options = {})
-        self.instances[options] ||= self.new(true)
+      def connected?
+        true
       end
 
       def connect_unix(path, timeout)
-        @connected = true
       end
 
       def disconnect
-        @connected = false
-        nil
       end
 
       def timeout=(usecs)
       end
 
       def write(command)
-        method = command.shift
-        reply = send(method, *command)
+        meffod = command.shift
+        if respond_to?(meffod)
+          reply = send(meffod, *command)
+        else
+          raise Redis::CommandError, "ERR unknown command '#{meffod}'"
+        end
 
         if reply == true
           reply = 1
@@ -106,13 +90,13 @@ class Redis
           reply = 0
         end
 
-        @replies << reply
-        @buffer << reply if @buffer && method != :multi
+        replies << reply
+        buffer << reply if buffer && meffod != :multi
         nil
       end
 
       def read
-        @replies.shift
+        replies.shift
       end
 
       # NOT IMPLEMENTED:
@@ -120,25 +104,30 @@ class Redis
       # * brpop
       # * brpoplpush
       # * discard
-      # * move
+      # * sort
       # * subscribe
       # * psubscribe
       # * publish
-      # * zremrangebyrank
-      # * zunionstore
+
       def flushdb
-        @data = ExpiringHash.new
+        databases.delete_at(database_id)
+        "OK"
       end
 
       def flushall
-        flushdb
+        self.class.databases[database_instance_key] = []
+        "OK"
       end
 
       def auth(password)
         "OK"
       end
 
-      def select(index) ; end
+      def select(index)
+        data_type_check(index, Integer)
+        self.database_id = index
+        "OK"
+      end
 
       def info
         {
@@ -163,71 +152,84 @@ class Redis
 
       def bgreriteaof ; end
 
+      def move key, destination_id
+        raise Redis::CommandError, "ERR source and destination objects are the same" if destination_id == database_id
+        destination = find_database(destination_id)
+        return false unless data.has_key?(key)
+        return false if destination.has_key?(key)
+        destination[key] = data.delete(key)
+        true
+      end
+
       def get(key)
-        @data[key]
+        data_type_check(key, String)
+        data[key]
       end
 
       def getbit(key, offset)
-        return unless @data[key]
-        @data[key].unpack('B*')[0].split("")[offset].to_i
+        return unless data[key]
+        data[key].unpack('B*')[0].split("")[offset].to_i
       end
 
       def getrange(key, start, ending)
-        return unless @data[key]
-        @data[key][start..ending]
+        return unless data[key]
+        data[key][start..ending]
       end
       alias :substr :getrange
 
       def getset(key, value)
-        old_value = @data[key]
-        @data[key] = value
-        return old_value
+        data_type_check(key, String)
+        data[key].tap do
+          set(key, value)
+        end
       end
 
       def mget(*keys)
         raise Redis::CommandError, "wrong number of arguments for 'mget' command" if keys.empty?
-        @data.values_at(*keys)
+        # We work with either an array, or list of arguments
+        keys = keys.first if keys.size == 1
+        data.values_at(*keys)
       end
 
       def append(key, value)
-        @data[key] = (@data[key] || "")
-        @data[key] = @data[key] + value.to_s
+        data[key] = (data[key] || "")
+        data[key] = data[key] + value.to_s
       end
 
       def strlen(key)
-        return unless @data[key]
-        @data[key].size
+        return unless data[key]
+        data[key].size
       end
 
       def hgetall(key)
         data_type_check(key, Hash)
-        @data[key].to_a.flatten || {}
+        data[key].to_a.flatten || {}
       end
 
       def hget(key, field)
         data_type_check(key, Hash)
-        @data[key] && @data[key][field.to_s]
+        data[key] && data[key][field.to_s]
       end
 
       def hdel(key, field)
         data_type_check(key, Hash)
-        @data[key] && @data[key].delete(field)
+        data[key] && data[key].delete(field)
         remove_key_for_empty_collection(key)
       end
 
       def hkeys(key)
         data_type_check(key, Hash)
-        return [] if @data[key].nil?
-        @data[key].keys
+        return [] if data[key].nil?
+        data[key].keys
       end
 
       def keys(pattern = "*")
         regexp = Regexp.new(pattern.split("*").map { |r| Regexp.escape(r) }.join(".*"))
-        @data.keys.select { |key| key =~ regexp }
+        data.keys.select { |key| key =~ regexp }
       end
 
       def randomkey
-        @data.keys[rand(dbsize)]
+        data.keys[rand(dbsize)]
       end
 
       def echo(string)
@@ -243,66 +245,66 @@ class Redis
       end
 
       def dbsize
-        @data.keys.count
+        data.keys.count
       end
 
       def exists(key)
-        @data.key?(key)
+        data.key?(key)
       end
 
       def llen(key)
         data_type_check(key, Array)
-        return 0 unless @data[key]
-        @data[key].size
+        return 0 unless data[key]
+        data[key].size
       end
 
       def lrange(key, startidx, endidx)
         data_type_check(key, Array)
-        (@data[key] && @data[key][startidx..endidx]) || []
+        (data[key] && data[key][startidx..endidx]) || []
       end
 
       def ltrim(key, start, stop)
         data_type_check(key, Array)
-        return unless @data[key]
-        @data[key] = @data[key][start..stop]
+        return unless data[key]
+        data[key] = data[key][start..stop]
       end
 
       def lindex(key, index)
         data_type_check(key, Array)
-        @data[key] && @data[key][index]
+        data[key] && data[key][index]
       end
 
       def linsert(key, where, pivot, value)
         data_type_check(key, Array)
-        return unless @data[key]
-        index = @data[key].index(pivot)
+        return unless data[key]
+        index = data[key].index(pivot)
         case where
-          when :before then @data[key].insert(index, value)
-          when :after  then @data[key].insert(index + 1, value)
+          when :before then data[key].insert(index, value)
+          when :after  then data[key].insert(index + 1, value)
           else raise Redis::CommandError, "ERR syntax error"
         end
       end
 
       def lset(key, index, value)
         data_type_check(key, Array)
-        return unless @data[key]
-        raise RuntimeError if index >= @data[key].size
-        @data[key][index] = value
+        return unless data[key]
+        raise(Redis::CommandError, "ERR index out of range") if index >= data[key].size
+        data[key][index] = value
       end
 
       def lrem(key, count, value)
         data_type_check(key, Array)
-        return unless @data[key]
-        old_size = @data[key].size
+        return unless data[key]
+        old_size = data[key].size
         diff =
           if count == 0
-            @data[key].delete(value)
-            old_size - @data[key].size
+            data[key].delete(value)
+            old_size - data[key].size
           else
-            array = count > 0 ? @data[key].dup : @data[key].reverse
+            array = count > 0 ? data[key].dup : data[key].reverse
             count.abs.times{ array.delete_at(array.index(value) || array.length) }
-            @data[key] = count > 0 ? array.dup : array.reverse
-            old_size - @data[key].size
+            data[key] = count > 0 ? array.dup : array.reverse
+            old_size - data[key].size
           end
         remove_key_for_empty_collection(key)
         diff
@@ -310,75 +312,76 @@ class Redis
 
       def rpush(key, value)
         data_type_check(key, Array)
-        @data[key] ||= []
+        data[key] ||= []
         [value].flatten.each do |val|
-          @data[key].push(val.to_s)
+          data[key].push(val.to_s)
         end
-        @data[key].size
+        data[key].size
       end
 
       def rpushx(key, value)
         data_type_check(key, Array)
-        return unless @data[key]
+        return unless data[key]
         rpush(key, value)
       end
 
       def lpush(key, value)
         data_type_check(key, Array)
-        @data[key] ||= []
+        data[key] ||= []
         [value].flatten.each do |val|
-          @data[key].unshift(val.to_s)
+          data[key].unshift(val.to_s)
         end
-        @data[key].size
+        data[key].size
       end
 
       def lpushx(key, value)
         data_type_check(key, Array)
-        return unless @data[key]
+        return unless data[key]
         lpush(key, value)
       end
 
       def rpop(key)
         data_type_check(key, Array)
-        return unless @data[key]
-        @data[key].pop
+        return unless data[key]
+        data[key].pop
       end
 
       def rpoplpush(key1, key2)
         data_type_check(key1, Array)
-        elem = rpop(key1)
-        lpush(key2, elem)
+        rpop(key1).tap do |elem|
+          lpush(key2, elem)
+        end
       end
 
       def lpop(key)
         data_type_check(key, Array)
-        return unless @data[key]
-        @data[key].shift
+        return unless data[key]
+        data[key].shift
       end
 
       def smembers(key)
         data_type_check(key, ::Set)
-        return [] unless @data[key]
-        @data[key].to_a.reverse
+        return [] unless data[key]
+        data[key].to_a.reverse
       end
 
       def sismember(key, value)
         data_type_check(key, ::Set)
-        return false unless @data[key]
-        @data[key].include?(value.to_s)
+        return false unless data[key]
+        data[key].include?(value.to_s)
       end
 
       def sadd(key, value)
         data_type_check(key, ::Set)
         value = Array(value)
 
-        result = if @data[key]
-          old_set = @data[key].dup
-          @data[key].merge(value.map(&:to_s))
-          (@data[key] - old_set).size
+        result = if data[key]
+          old_set = data[key].dup
+          data[key].merge(value.map(&:to_s))
+          (data[key] - old_set).size
         else
-          @data[key] = ::Set.new(value.map(&:to_s))
-          @data[key].size
+          data[key] = ::Set.new(value.map(&:to_s))
+          data[key].size
         end
 
         # 0 = false, 1 = true, 2+ untouched
@@ -388,7 +391,7 @@ class Redis
 
       def srem(key, value)
         data_type_check(key, ::Set)
-        deleted = !!(@data[key] && @data[key].delete?(value.to_s))
+        deleted = !!(data[key] && data[key].delete?(value.to_s))
         remove_key_for_empty_collection(key)
         deleted
       end
@@ -409,14 +412,14 @@ class Redis
 
       def scard(key)
         data_type_check(key, ::Set)
-        return 0 unless @data[key]
-        @data[key].size
+        return 0 unless data[key]
+        data[key].size
       end
 
       def sinter(*keys)
         keys.each { |k| data_type_check(k, ::Set) }
-        return ::Set.new if keys.any? { |k| @data[k].nil? }
-        keys = keys.map { |k| @data[k] || ::Set.new }
+        return ::Set.new if keys.any? { |k| data[k].nil? }
+        keys = keys.map { |k| data[k] || ::Set.new }
         keys.inject do |set, key|
           set & key
         end.to_a
@@ -425,12 +428,12 @@ class Redis
       def sinterstore(destination, *keys)
         data_type_check(destination, ::Set)
         result = sinter(*keys)
-        @data[destination] = ::Set.new(result)
+        data[destination] = ::Set.new(result)
       end
 
       def sunion(*keys)
         keys.each { |k| data_type_check(k, ::Set) }
-        keys = keys.map { |k| @data[k] || ::Set.new }
+        keys = keys.map { |k| data[k] || ::Set.new }
         keys.inject(::Set.new) do |set, key|
           set | key
         end.to_a
@@ -439,13 +442,13 @@ class Redis
       def sunionstore(destination, *keys)
         data_type_check(destination, ::Set)
         result = sunion(*keys)
-        @data[destination] = ::Set.new(result)
+        data[destination] = ::Set.new(result)
       end
 
       def sdiff(key1, *keys)
         [key1, *keys].each { |k| data_type_check(k, ::Set) }
-        keys = keys.map { |k| @data[k] || ::Set.new }
-        keys.inject(@data[key1]) do |memo, set|
+        keys = keys.map { |k| data[k] || ::Set.new }
+        keys.inject(data[key1]) do |memo, set|
           memo - set
         end.to_a
       end
@@ -453,23 +456,23 @@ class Redis
       def sdiffstore(destination, key1, *keys)
         data_type_check(destination, ::Set)
         result = sdiff(key1, *keys)
-        @data[destination] = ::Set.new(result)
+        data[destination] = ::Set.new(result)
       end
 
       def srandmember(key)
         data_type_check(key, ::Set)
-        return nil unless @data[key]
-        @data[key].to_a[rand(@data[key].size)]
+        return nil unless data[key]
+        data[key].to_a[rand(data[key].size)]
       end
 
       def del(*keys)
         keys = keys.flatten(1)
         raise Redis::CommandError, "ERR wrong number of arguments for 'del' command" if keys.empty?
-        old_count = @data.keys.size
+        old_count = data.keys.size
         keys.each do |key|
-          @data.delete(key)
+          data.delete(key)
         end
-        deleted_count = old_count - @data.keys.size
+        old_count - data.keys.size
       end
 
       def setnx(key, value)
@@ -482,10 +485,10 @@ class Redis
       end
 
       def rename(key, new_key)
-        return unless @data[key]
-        @data[new_key] = @data[key]
-        @data.expires[new_key] = @data.expires[key] if @data.expires.include?(key)
-        @data.delete(key)
+        return unless data[key]
+        data[new_key] = data[key]
+        data.expires[new_key] = data.expires[key] if data.expires.include?(key)
+        data.delete(key)
       end
 
       def renamenx(key, new_key)
@@ -498,13 +501,13 @@ class Redis
       end
 
       def expire(key, ttl)
-        return unless @data[key]
-        @data.expires[key] = Time.now + ttl
+        return unless data[key]
+        data.expires[key] = Time.now + ttl
         true
       end
 
       def ttl(key)
-        if @data.expires.include?(key) && (ttl = @data.expires[key].to_i - Time.now.to_i) > 0
+        if data.expires.include?(key) && (ttl = data.expires[key].to_i - Time.now.to_i) > 0
           ttl
         else
           -1
@@ -512,23 +515,23 @@ class Redis
       end
 
       def expireat(key, timestamp)
-        @data.expires[key] = Time.at(timestamp)
+        data.expires[key] = Time.at(timestamp)
         true
       end
 
       def persist(key)
-        !!@data.expires.delete(key)
+        !!data.expires.delete(key)
       end
 
       def hset(key, field, value)
         data_type_check(key, Hash)
         field = field.to_s
-        if @data[key]
-          result = !@data[key].include?(field)
-          @data[key][field] = value.to_s
+        if data[key]
+          result = !data[key].include?(field)
+          data[key][field] = value.to_s
           result
         else
-          @data[key] = { field => value.to_s }
+          data[key] = { field => value.to_s }
           true
         end
       end
@@ -536,27 +539,28 @@ class Redis
       def hsetnx(key, field, value)
         data_type_check(key, Hash)
         field = field.to_s
-        return false if @data[key] && @data[key][field]
+        return false if data[key] && data[key][field]
         hset(key, field, value)
       end
 
       def hmset(key, *fields)
-        raise Redis::CommandError, "wrong number of arguments for 'hmset' command" if fields.empty? || fields.size.odd?
+        # mapped_hmset gives us [[:k1, "v1", :k2, "v2"]] for `fields`. Fix that.
+        fields = fields[0] if mapped_param?(fields)
+        raise Redis::CommandError, "ERR wrong number of arguments for HMSET" if fields.empty? || fields.size.odd?
         data_type_check(key, Hash)
-        @data[key] ||= {}
+        data[key] ||= {}
         fields.each_slice(2) do |field|
-          @data[key][field[0].to_s] = field[1].to_s
+          data[key][field[0].to_s] = field[1].to_s
         end
       end
 
       def hmget(key, *fields)
         raise Redis::CommandError, "wrong number of arguments for 'hmget' command" if fields.empty?
         data_type_check(key, Hash)
-        values = []
         fields.map do |field|
           field = field.to_s
-          if @data[key]
-            @data[key][field]
+          if data[key]
+            data[key][field]
           else
             nil
           end
@@ -565,30 +569,30 @@ class Redis
 
       def hlen(key)
         data_type_check(key, Hash)
-        return 0 unless @data[key]
-        @data[key].size
+        return 0 unless data[key]
+        data[key].size
       end
 
       def hvals(key)
         data_type_check(key, Hash)
-        return [] unless @data[key]
-        @data[key].values
+        return [] unless data[key]
+        data[key].values
       end
 
       def hincrby(key, field, increment)
         data_type_check(key, Hash)
-        if @data[key]
-          @data[key][field] = (@data[key][field.to_s].to_i + increment.to_i).to_s
+        if data[key]
+          data[key][field] = (data[key][field.to_s].to_i + increment.to_i).to_s
         else
-          @data[key] = { field => increment.to_s }
+          data[key] = { field => increment.to_s }
         end
-        @data[key][field].to_i
+        data[key][field].to_i
       end
 
       def hexists(key, field)
         data_type_check(key, Hash)
-        return false unless @data[key]
-        @data[key].key?(field)
+        return false unless data[key]
+        data[key].key?(field)
       end
 
       def sync ; end
@@ -602,44 +606,48 @@ class Redis
       end
 
       def set(key, value)
-        @data[key] = value.to_s
+        data[key] = value.to_s
         "OK"
       end
 
       def setbit(key, offset, bit)
-        old_val = @data[key] ? @data[key].unpack('B*')[0].split("") : []
+        old_val = data[key] ? data[key].unpack('B*')[0].split("") : []
         size_increment = [((offset/8)+1)*8-old_val.length, 0].max
         old_val += Array.new(size_increment).map{"0"}
         original_val = old_val[offset]
         old_val[offset] = bit.to_s
         new_val = ""
         old_val.each_slice(8){|b| new_val = new_val + b.join("").to_i(2).chr }
-        @data[key] = new_val
+        data[key] = new_val
         original_val
       end
 
       def setex(key, seconds, value)
-        @data[key] = value.to_s
+        data[key] = value.to_s
         expire(key, seconds)
       end
 
       def setrange(key, offset, value)
-        return unless @data[key]
-        s = @data[key][offset,value.size]
-        @data[key][s] = value
+        return unless data[key]
+        s = data[key][offset,value.size]
+        data[key][s] = value
       end
 
       def mset(*pairs)
+        # Handle pairs for mapped_mset command
+        pairs = pairs[0] if mapped_param?(pairs)
         pairs.each_slice(2) do |pair|
-          @data[pair[0].to_s] = pair[1].to_s
+          data[pair[0].to_s] = pair[1].to_s
         end
         "OK"
       end
 
       def msetnx(*pairs)
+        # Handle pairs for mapped_msetnx command
+        pairs = pairs[0] if mapped_param?(pairs)
         keys = []
         pairs.each_with_index{|item, index| keys << item.to_s if index % 2 == 0}
-        return if keys.any?{|key| @data.key?(key) }
+        return false if keys.any?{|key| data.key?(key) }
         mset(*pairs)
         true
       end
@@ -649,27 +657,27 @@ class Redis
       end
 
       def incr(key)
-        @data.merge!({ key => (@data[key].to_i + 1).to_s || "1"})
-        @data[key].to_i
+        data.merge!({ key => (data[key].to_i + 1).to_s || "1"})
+        data[key].to_i
       end
 
       def incrby(key, by)
-        @data.merge!({ key => (@data[key].to_i + by.to_i).to_s || by })
-        @data[key].to_i
+        data.merge!({ key => (data[key].to_i + by.to_i).to_s || by })
+        data[key].to_i
       end
 
       def decr(key)
-        @data.merge!({ key => (@data[key].to_i - 1).to_s || "-1"})
-        @data[key].to_i
+        data.merge!({ key => (data[key].to_i - 1).to_s || "-1"})
+        data[key].to_i
       end
 
       def decrby(key, by)
-        @data.merge!({ key => ((@data[key].to_i - by.to_i) || (by.to_i * -1)).to_s })
-        @data[key].to_i
+        data.merge!({ key => ((data[key].to_i - by.to_i) || (by.to_i * -1)).to_s })
+        data[key].to_i
       end
 
       def type(key)
-        case value = @data[key]
+        case data[key]
           when nil then "none"
           when String then "string"
           when Hash then "hash"
@@ -685,13 +693,11 @@ class Redis
       def slaveof(host, port) ; end
 
       def exec
-        buffer = @buffer
-        @buffer = nil
-        buffer
+        buffer.tap {|x| self.buffer = nil }
       end
 
       def multi
-        @buffer = []
+        self.buffer = []
         yield if block_given?
         "OK"
       end
@@ -718,17 +724,17 @@ class Redis
         end
 
         data_type_check(key, ZSet)
-        @data[key] ||= ZSet.new
+        data[key] ||= ZSet.new
 
         if args.size == 2
           score, value = args
-          exists = !@data[key].key?(value.to_s)
-          @data[key][value.to_s] = score
+          exists = !data[key].key?(value.to_s)
+          data[key][value.to_s] = score
         else
           # Turn [1, 2, 3, 4] into [[1, 2], [3, 4]] unless it is already
           args = args.each_slice(2).to_a unless args.first.is_a?(Array)
-          exists = args.map(&:last).map { |el| @data[key].key?(el.to_s) }.count(false)
-          args.each { |score, value| @data[key][value.to_s] = score }
+          exists = args.map(&:last).map { |el| data[key].key?(el.to_s) }.count(false)
+          args.each { |s, v| data[key][v.to_s] = s }
         end
 
         exists
@@ -736,73 +742,85 @@ class Redis
 
       def zrem(key, value)
         data_type_check(key, ZSet)
-        exists = false
-        exists = @data[key].delete(value.to_s) if @data[key]
+        values = Array(value)
+        return 0 unless data[key]
+
+        response = values.map do |v|
+          data[key].delete(v) if data[key].has_key?(v)
+        end.compact.size
+
         remove_key_for_empty_collection(key)
-        !!exists
+        response
       end
 
       def zcard(key)
         data_type_check(key, ZSet)
-        @data[key] ? @data[key].size : 0
+        data[key] ? data[key].size : 0
       end
 
       def zscore(key, value)
         data_type_check(key, ZSet)
-        @data[key] && @data[key][value.to_s].to_s
+        value = data[key] && data[key][value.to_s]
+        value && value.to_s
       end
 
       def zcount(key, min, max)
         data_type_check(key, ZSet)
-        return 0 unless @data[key]
-        zrange_select_by_score(key, min, max).size
+        return 0 unless data[key]
+        data[key].select_by_score(min, max).size
       end
 
       def zincrby(key, num, value)
         data_type_check(key, ZSet)
-        @data[key] ||= ZSet.new
-        @data[key][value.to_s] ||= 0
-        @data[key][value.to_s] += num
-        @data[key][value.to_s].to_s
+        data[key] ||= ZSet.new
+        data[key][value.to_s] ||= 0
+        data[key].increment(value.to_s, num)
+        data[key][value.to_s].to_s
       end
 
       def zrank(key, value)
         data_type_check(key, ZSet)
-        @data[key].keys.sort_by {|k| @data[key][k] }.index(value.to_s)
+        data[key].keys.sort_by {|k| data[key][k] }.index(value.to_s)
       end
 
       def zrevrank(key, value)
         data_type_check(key, ZSet)
-        @data[key].keys.sort_by {|k| -@data[key][k] }.index(value.to_s)
+        data[key].keys.sort_by {|k| -data[key][k] }.index(value.to_s)
       end
 
       def zrange(key, start, stop, with_scores = nil)
         data_type_check(key, ZSet)
-        return [] unless @data[key]
+        return [] unless data[key]
 
-        if with_scores
-          @data[key].sort_by {|_,v| v }
-        else
-          @data[key].keys.sort_by {|k| @data[key][k] }
-        end[start..stop].flatten.map(&:to_s)
+        # Sort by score, or if scores are equal, key alphanum
+        results = data[key].sort do |(k1, v1), (k2, v2)|
+          if v1 == v2
+            k1 <=> k2
+          else
+            v1 <=> v2
+          end
+        end
+        # Select just the keys unless we want scores
+        results = results.map(&:first) unless with_scores
+        results[start..stop].flatten.map(&:to_s)
       end
 
       def zrevrange(key, start, stop, with_scores = nil)
         data_type_check(key, ZSet)
-        return [] unless @data[key]
+        return [] unless data[key]
 
         if with_scores
-          @data[key].sort_by {|_,v| -v }
+          data[key].sort_by {|_,v| -v }
         else
-          @data[key].keys.sort_by {|k| -@data[key][k] }
+          data[key].keys.sort_by {|k| -data[key][k] }
         end[start..stop].flatten.map(&:to_s)
       end
 
       def zrangebyscore(key, min, max, *opts)
         data_type_check(key, ZSet)
-        return [] unless @data[key]
+        return [] unless data[key]
 
-        range = zrange_select_by_score(key, min, max)
+        range = data[key].select_by_score(min, max)
         vals = if opts.include?('WITHSCORES')
           range.sort_by {|_,v| v }
         else
@@ -817,9 +835,9 @@ class Redis
 
       def zrevrangebyscore(key, max, min, *opts)
         data_type_check(key, ZSet)
-        return [] unless @data[key]
+        return [] unless data[key]
 
-        range = zrange_select_by_score(key, min, max)
+        range = data[key].select_by_score(min, max)
         vals = if opts.include?('WITHSCORES')
           range.sort_by {|_,v| -v }
         else
@@ -834,66 +852,45 @@ class Redis
 
       def zremrangebyscore(key, min, max)
         data_type_check(key, ZSet)
-        return 0 unless @data[key]
+        return 0 unless data[key]
 
-        range = zrange_select_by_score(key, min, max)
-        range.each {|k,_| @data[key].delete(k) }
+        range = data[key].select_by_score(min, max)
+        range.each {|k,_| data[key].delete(k) }
         range.size
       end
 
-      def zinterstore(out, _, *keys)
+      def zinterstore(out, *args)
         data_type_check(out, ZSet)
+        args_handler = SortedSetArgumentHandler.new(args)
+        data[out] = SortedSetIntersectStore.new(args_handler, data).call
+        data[out].size
+      end
 
-        hashes = keys.map do |src|
-          case @data[src]
-          when ::Set
-            # Every value has a score of 1
-            Hash[@data[src].map {|k,v| [k, 1]}]
-          when Hash
-            @data[src]
-          else
-            {}
-          end
-        end
-
-        @data[out] = ZSet.new
-        values = hashes.inject([]) {|r, h| r.empty? ? h.keys : r & h.keys }
-        values.each do |value|
-          @data[out][value] = hashes.inject(0) {|n, h| n + h[value].to_i }
-        end
-
-        @data[out].size
+      def zunionstore(out, *args)
+        data_type_check(out, ZSet)
+        args_handler = SortedSetArgumentHandler.new(args)
+        data[out] = SortedSetUnionStore.new(args_handler, data).call
+        data[out].size
       end
 
       def zremrangebyrank(key, start, stop)
-        sorted_elements = @data[key].sort { |(v_a, r_a), (v_b, r_b)| r_a <=> r_b }
+        sorted_elements = data[key].sort_by { |k, v| v }
         start = sorted_elements.length if start > sorted_elements.length
         elements_to_delete = sorted_elements[start..stop]
-        elements_to_delete.each { |elem, rank| @data[key].delete(elem) }
+        elements_to_delete.each { |elem, rank| data[key].delete(elem) }
         elements_to_delete.size
       end
 
       private
 
-        def zrange_select_by_score(key, min, max)
-          if min == '-inf' && max == '+inf'
-            @data[key]
-          elsif max == '+inf'
-            @data[key].reject { |_,v| v < min }
-          elsif min == '-inf'
-            @data[key].reject { |_,v| v > max }
-          else
-            @data[key].reject {|_,v| v < min || v > max }
-          end
-        end
-
         def remove_key_for_empty_collection(key)
-          del(key) if @data[key] && @data[key].empty?
+          del(key) if data[key] && data[key].empty?
         end
 
         def data_type_check(key, klass)
-          if @data[key] && !@data[key].is_a?(klass)
-            fail "Operation against a key holding the wrong kind of value: Expected #{klass} at #{key}."
+          if data[key] && !data[key].is_a?(klass)
+            warn "Operation against a key holding the wrong kind of value: Expected #{klass} at #{key}."
+            raise Redis::CommandError.new("ERR Operation against a key holding the wrong kind of value")
           end
         end
 
@@ -909,6 +906,10 @@ class Redis
             [offset, count]
           end
         end
+
+        def mapped_param? param
+          param.size == 1 && param[0].is_a?(Array)
+        end
     end
   end
 end