fakeredis 0.3.3 → 0.4.0

data/README.md

@@ -1,4 +1,4 @@
-# FakeRedis [![Build Status](https://secure.travis-ci.org/guilleiguaran/fakeredis.png)](http://travis-ci.org/guilleiguaran/fakeredis)
+# FakeRedis [![Build Status](http://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
 
 
@@ -64,8 +64,6 @@ Or:
 * [obrie](https://github.com/obrie)
 * [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!!!)
 
 

data/fakeredis.gemspec

@@ -8,16 +8,17 @@ Gem::Specification.new do |s|
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Guillermo Iguaran"]
   s.email       = ["guilleiguaran@gmail.com"]
-  s.homepage    = "https://guilleiguaran.github.com/fakeredis"
-  s.license     = "MIT"
+  s.homepage    = "https://github.com/guilleiguaran/fakeredis"
   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) }
   s.require_paths = ["lib"]
 
-  s.add_runtime_dependency(%q<redis>, ["~> 2.2.0"])
+  s.add_runtime_dependency(%q<redis>, ["~> 3.0.0"])
   s.add_development_dependency(%q<rspec>, [">= 2.0.0"])
 end

data/lib/fakeredis/version.rb

@@ -1,3 +1,3 @@
 module FakeRedis
-  VERSION = "0.3.3"
+  VERSION = "0.4.0"
 end

data/lib/redis/connection/memory.rb

@@ -1,20 +1,73 @@
 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
+
+        def delete(key)
+          expire(key)
+          super
+        end
+
+        def expire(key)
+          expires.delete(key)
+        end
+
+        def expired?(key)
+          expires.include?(key) && expires[key] < Time.now
+        end
+
+        def key?(key)
+          delete(key) if expired?(key)
+          super
+        end
+
+        def values_at(*keys)
+          keys.each {|key| delete(key) if expired?(key)}
+          super
+        end
+
+        def keys
+          super.select do |key|
+            if expired?(key)
+              delete(key)
+              false
+            else
+              true
+            end
+          end
+        end
+      end
+
+      class ZSet < Hash
+      end
+
       include Redis::Connection::CommandHelper
-      include FakeRedis
 
-      def initialize
+      def initialize(connected = false)
         @data = ExpiringHash.new
-        @connected = false
+        @connected = connected
         @replies = []
         @buffer = nil
       end
@@ -23,8 +76,8 @@ class Redis
         @connected
       end
 
-      def connect(host, port, timeout)
-        @connected = true
+      def self.connect(options = {})
+        self.new(true)
       end
 
       def connect_unix(path, timeout)
@@ -40,12 +93,8 @@ class Redis
       end
 
       def write(command)
-        meffod = command.shift
-        if respond_to?(meffod)
-          reply = send(meffod, *command)
-        else
-          raise RuntimeError, "ERR unknown command '#{meffod}'"
-        end
+        method = command.shift
+        reply = send(method, *command)
 
         if reply == true
           reply = 1
@@ -54,7 +103,7 @@ class Redis
         end
 
         @replies << reply
-        @buffer << reply if @buffer && meffod != :multi
+        @buffer << reply if @buffer && method != :multi
         nil
       end
 
@@ -68,14 +117,13 @@ class Redis
       # * brpoplpush
       # * discard
       # * move
-      # * sort
       # * subscribe
       # * psubscribe
       # * publish
-
+      # * zremrangebyrank
+      # * zunionstore
       def flushdb
         @data = ExpiringHash.new
-        "OK"
       end
 
       def flushall
@@ -112,7 +160,6 @@ class Redis
       def bgreriteaof ; end
 
       def get(key)
-        data_type_check(key, String)
         @data[key]
       end
 
@@ -128,14 +175,13 @@ class Redis
       alias :substr :getrange
 
       def getset(key, value)
-        data_type_check(key, String)
-        @data[key].tap do
-          set(key, value)
-        end
+        old_value = @data[key]
+        @data[key] = value
+        return old_value
       end
 
       def mget(*keys)
-        raise RuntimeError, "ERR wrong number of arguments for 'mget' command" if keys.empty?
+        raise ArgumentError, "wrong number of arguments for 'mget' command" if keys.empty?
         @data.values_at(*keys)
       end
 
@@ -151,7 +197,7 @@ class Redis
 
       def hgetall(key)
         data_type_check(key, Hash)
-        @data[key] || {}
+        @data[key].to_a.flatten || {}
       end
 
       def hget(key, field)
@@ -208,7 +254,7 @@ class Redis
 
       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)
@@ -236,7 +282,7 @@ class Redis
       def lset(key, index, value)
         data_type_check(key, Array)
         return unless @data[key]
-        raise RuntimeError, "ERR index out of range" if index >= @data[key].size
+        raise RuntimeError if index >= @data[key].size
         @data[key][index] = value
       end
 
@@ -261,7 +307,7 @@ class Redis
       def rpush(key, value)
         data_type_check(key, Array)
         @data[key] ||= []
-        @data[key].push(value.to_s)
+        @data[key].push(value)
         @data[key].size
       end
 
@@ -274,7 +320,7 @@ class Redis
       def lpush(key, value)
         data_type_check(key, Array)
         @data[key] ||= []
-        @data[key].unshift(value.to_s)
+        @data[key].unshift(value)
         @data[key].size
       end
 
@@ -292,9 +338,8 @@ class Redis
 
       def rpoplpush(key1, key2)
         data_type_check(key1, Array)
-        rpop(key1).tap do |elem|
-          lpush(key2, elem)
-        end
+        elem = rpop(key1)
+        lpush(key2, elem)
       end
 
       def lpop(key)
@@ -406,7 +451,7 @@ class Redis
         keys.flatten.each do |key|
           @data.delete(key)
         end
-        old_count - @data.keys.size
+        deleted_count = old_count - @data.keys.size
       end
 
       def setnx(key, value)
@@ -478,11 +523,7 @@ class Redis
       end
 
       def hmset(key, *fields)
-        # mapped_hmset gives us [[:k1, "v1", :k2, "v2"]] for `fields`. Fix that.
-        fields = fields[0] if fields.size == 1 && fields[0].is_a?(Array)
-        fields = fields[0] if mapped_param?(fields)
-        raise RuntimeError, "ERR wrong number of arguments for HMSET" if fields.size > 2 && fields.size.odd?
-        raise RuntimeError, "ERR wrong number of arguments for 'hmset' command" if fields.empty? || fields.size.odd?
+        raise ArgumentError, "wrong number of arguments for 'hmset' command" if fields.empty? || fields.size.odd?
         data_type_check(key, Hash)
         @data[key] ||= {}
         fields.each_slice(2) do |field|
@@ -491,8 +532,9 @@ class Redis
       end
 
       def hmget(key, *fields)
-        raise RuntimeError, "ERR wrong number of arguments for 'hmget' command" if fields.empty?
+        raise ArgumentError, "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]
@@ -570,8 +612,6 @@ class Redis
       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
         end
@@ -579,11 +619,9 @@ class Redis
       end
 
       def msetnx(*pairs)
-        # Handle pairs for mapped_mset command
-        pairs = pairs[0] if mapped_param?(pairs)
         keys = []
         pairs.each_with_index{|item, index| keys << item.to_s if index % 2 == 0}
-        return false if keys.any? {|key| @data.key?(key) }
+        return if keys.any?{|key| @data.key?(key) }
         mset(*pairs)
         true
       end
@@ -593,27 +631,31 @@ class Redis
       end
 
       def incr(key)
-        @data.merge!({ key => (@data[key].to_i + 1).to_s || "1"})
+        @data[key] = (@data[key] || "0")
+        @data[key] = (@data[key].to_i + 1).to_s
         @data[key].to_i
       end
 
       def incrby(key, by)
-        @data.merge!({ key => (@data[key].to_i + by.to_i).to_s || by })
+        @data[key] = (@data[key] || "0")
+        @data[key] = (@data[key].to_i + by.to_i).to_s
         @data[key].to_i
       end
 
       def decr(key)
-        @data.merge!({ key => (@data[key].to_i - 1).to_s || "-1"})
+        @data[key] = (@data[key] || "0")
+        @data[key] = (@data[key].to_i - 1).to_s
         @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] = (@data[key] || "0")
+        @data[key] = (@data[key].to_i - by.to_i).to_s
         @data[key].to_i
       end
 
       def type(key)
-        case @data[key]
+        case value = @data[key]
           when nil then "none"
           when String then "string"
           when Hash then "hash"
@@ -652,7 +694,6 @@ class Redis
         data_type_check(key, ZSet)
         @data[key] ||= ZSet.new
         exists = @data[key].key?(value.to_s)
-        score = "inf" if score == "+inf"
         @data[key][value.to_s] = score
         !exists
       end
@@ -672,8 +713,7 @@ class Redis
 
       def zscore(key, value)
         data_type_check(key, ZSet)
-        result = @data[key] && @data[key][value.to_s]
-        result.to_s if result
+        @data[key] && @data[key][value.to_s].to_s
       end
 
       def zcount(key, min, max)
@@ -686,12 +726,7 @@ class Redis
         data_type_check(key, ZSet)
         @data[key] ||= ZSet.new
         @data[key][value.to_s] ||= 0
-        if %w(+inf -inf).include?(num)
-          num = "inf" if num == "+inf"
-          @data[key][value.to_s] = num
-        elsif ! %w(+inf -inf).include?(@data[key][value.to_s])
-          @data[key][value.to_s] += num
-        end
+        @data[key][value.to_s] += num
         @data[key][value.to_s].to_s
       end
 
@@ -709,17 +744,11 @@ class Redis
         data_type_check(key, ZSet)
         return [] unless @data[key]
 
-        # 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)
+        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)
       end
 
       def zrevrange(key, start, stop, with_scores = nil)
@@ -776,23 +805,31 @@ class Redis
         range.size
       end
 
-      def zinterstore(out, *args)
+      def zinterstore(out, _, *keys)
         data_type_check(out, ZSet)
-        args_handler = SortedSetArgumentHandler.new(args)
-        @data[out] = SortedSetIntersectStore.new(args_handler, @data).call
-        @data[out].size
-      end
 
-      def zunionstore(out, *args)
-        data_type_check(out, ZSet)
-        args_handler = SortedSetArgumentHandler.new(args)
-        @data[out] = SortedSetUnionStore.new(args_handler, @data).call
+        hashes = keys.map do |src|
+          case @data[src]
+          when ::Set
+            Hash[@data[src].zip([0] * @data[src].size)]
+          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
       end
 
       def zremrangebyrank(key, start, stop)
-        sorted_elements = @data[key].sort { |(_, r_a), (_, r_b)| r_a <=> r_b }
-        start = sorted_elements.length if start > sorted_elements.length
+        sorted_elements = @data[key].sort { |(v_a, r_a), (v_b, r_b)| r_a <=> r_b }
         elements_to_delete = sorted_elements[start..stop]
         elements_to_delete.each { |elem, rank| @data[key].delete(elem) }
         elements_to_delete.size
@@ -810,8 +847,7 @@ class Redis
 
         def data_type_check(key, klass)
           if @data[key] && !@data[key].is_a?(klass)
-            warn "Operation against a key holding the wrong kind of value: Expected #{klass} at #{key}."
-            raise RuntimeError.new("ERR Operation against a key holding the wrong kind of value")
+            fail "Operation against a key holding the wrong kind of value: Expected #{klass} at #{key}."
           end
         end
 
@@ -827,10 +863,6 @@ class Redis
             [offset, count]
           end
         end
-
-        def mapped_param? param
-          param.size == 1 && param[0].is_a?(Array)
-        end
     end
   end
 end