fakeredis 0.4.3 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 88195a8e3e41a553347ff30096fac78a8dcec153
-  data.tar.gz: 3ea4aa2ec9ec9857486a503ef8032b2f22562a60
+  metadata.gz: 20688b94f039d268518697ede7cdfad15f26cf73
+  data.tar.gz: ab1982d7e9ed2f7c6b864d2beadd63d6041bb59a
 SHA512:
-  metadata.gz: 28fd4cbbe0ec660365112a7b7485c950771a4c8d75c933d0d55afdb3cfbdabdd1fdeba98d687e9050b01fdf2e52e07278b8497a8d0e03ac97f974c0211afaa72
-  data.tar.gz: 0c5c519761c03545a014d0822c3c4a32d63ea6ae3bd96f7c7b6e433dd5acf646dec8b195b5675838cd56e3ac6e5320164654318724e8c3e57ee8f53e32a408cd
+  metadata.gz: 080b44a262bae01a09dcd2660cb35e1a52543cad7d3780fc58224854b6007adb8a0598a0b892560988f7a86c921a1ea1d3b36fa19248542017ffb97ce8caa0ef
+  data.tar.gz: 687896c96f26f389776216ef6397ce9bb025e9fb04008860dc377f8ba0965245185b02bb4381e7e560a5d76621b8c87ee4989878fbe0bd086e5fc30e2e3c6442

data/.travis.yml

@@ -1,8 +1,8 @@
+language: ruby
 rvm:
-  - 1.8.7
   - 1.9.2
   - 1.9.3
   - 2.0.0
-  - ree
-  - jruby
-  - rbx
+  - 2.1.1
+  - jruby-19mode
+  - rbx-2

data/Gemfile

@@ -1,9 +1,13 @@
-source "http://rubygems.org"
+source "https://rubygems.org"
 
 gem 'rake'
 gem 'rdoc'
 
-gem 'rubysl', :platforms => :rbx
+platforms :rbx do
+  gem 'racc'
+  gem 'rubysl', '~> 2.0'
+  gem 'psych'
+end
 
 # Specify your gem's dependencies in fakeredis.gemspec
 gemspec

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2011-2013 Guillermo Iguaran
+Copyright (c) 2011-2014 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

@@ -15,7 +15,7 @@ Add it to your Gemfile:
 
 ## Versions
 
-FakeRedis currently supports redis-rb v3.0.0 or later, if you are using
+FakeRedis currently supports redis-rb v3.x.y or later, if you are using
 redis-rb v2.2.x install the version 0.3.x:
 
     gem install fakeredis -v "~> 0.3.0"
@@ -82,5 +82,5 @@ Or:
 
 ## Copyright
 
-Copyright (c) 2011-2013 Guillermo Iguaran. See LICENSE for
+Copyright (c) 2011-2014 Guillermo Iguaran. See LICENSE for
 further details.

data/fakeredis.gemspec

@@ -18,6 +18,6 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_runtime_dependency(%q<redis>, ["~> 3.0.0"])
-  s.add_development_dependency(%q<rspec>, [">= 2.0.0"])
+  s.add_runtime_dependency(%q<redis>, ["~> 3.0"])
+  s.add_development_dependency(%q<rspec>, ["~> 3.0"])
 end

data/lib/fakeredis/command_executor.rb

@@ -0,0 +1,25 @@
+module FakeRedis
+  module CommandExecutor
+    def write(command)
+      meffod = command.shift.to_s.downcase.to_sym
+
+      if in_multi && !(TRANSACTION_COMMANDS.include? meffod) # queue commands
+        queued_commands << [meffod, *command]
+        reply = 'QUEUED'
+      elsif respond_to?(meffod)
+        reply = send(meffod, *command)
+      else
+        raise Redis::CommandError, "ERR unknown command '#{meffod}'"
+      end
+
+      if reply == true
+        reply = 1
+      elsif reply == false
+        reply = 0
+      end
+
+      replies << reply
+      nil
+    end
+  end
+end

data/lib/fakeredis/sort_method.rb

@@ -0,0 +1,116 @@
+# Codes are mostly referenced from MockRedis' implementation.
+module FakeRedis
+  module SortMethod
+    def sort(key, *redis_options_array)
+      return [] unless key
+
+      unless %w(list set zset).include? type(key)
+        warn "Operation against a key holding the wrong kind of value: Expected list, set or zset at #{key}."
+        raise Redis::CommandError.new("WRONGTYPE Operation against a key holding the wrong kind of value")
+      end
+
+      # redis_options is an array of format [BY pattern] [LIMIT offset count] [GET pattern [GET pattern ...]] [ASC|DESC] [ALPHA] [STORE destination]
+      # Lets nibble it back into a hash
+      options = extract_options_from(redis_options_array)
+
+      # And now to actually do the work of this method
+
+      projected = project(data[key], options[:by], options[:get])
+      sorted    = sort_by(projected, options[:order])
+      sliced    = slice(sorted, options[:limit])
+      # We have to flatten it down as redis-rb adds back the array to the return value
+      result = sliced.flatten(1)
+
+      options[:store] ? rpush(options[:store], sliced) : sliced.flatten(1)
+    end
+
+    private
+
+    ASCENDING_SORT  = Proc.new { |a, b| a.first <=> b.first }
+    DESCENDING_SORT = Proc.new { |a, b| b.first <=> a.first }
+
+    def extract_options_from(options_array)
+      # Defaults
+      options = {
+        :limit => [],
+        :order => "ASC",
+        :get => []
+      }
+
+      if options_array.first == "BY"
+        options_array.shift
+        options[:by] = options_array.shift
+      end
+
+      if options_array.first == "LIMIT"
+        options_array.shift
+        options[:limit] = [options_array.shift, options_array.shift]
+      end
+
+      while options_array.first == "GET"
+        options_array.shift
+        options[:get] << options_array.shift
+      end
+
+      if %w(ASC DESC ALPHA).include?(options_array.first)
+        options[:order] = options_array.shift
+        options[:order] = "ASC" if options[:order] == "ALPHA"
+      end
+
+      if options_array.first == "STORE"
+        options_array.shift
+        options[:store] = options_array.shift
+      end
+
+      options
+    end
+
+    def project(enumerable, by, get_patterns)
+      enumerable.map do |*elements|
+        element = elements.flatten.first
+        weight  = by ? lookup_from_pattern(by, element) : element
+        value   = element
+
+        if get_patterns.length > 0
+          value = get_patterns.map do |pattern|
+            pattern == "#" ? element : lookup_from_pattern(pattern, element)
+          end
+          value = value.first if value.length == 1
+        end
+
+        [weight, value]
+      end
+    end
+
+    def sort_by(projected, direction)
+      sorter =
+        case direction.upcase
+          when "DESC"
+            DESCENDING_SORT
+          when "ASC", "ALPHA"
+            ASCENDING_SORT
+          else
+            raise "Invalid direction '#{direction}'"
+        end
+
+      projected.sort(&sorter).map(&:last)
+    end
+
+    def slice(sorted, limit)
+      skip = limit.first || 0
+      take = limit.last || sorted.length
+
+      sorted[skip...(skip + take)] || sorted
+    end
+
+    def lookup_from_pattern(pattern, element)
+      key = pattern.sub('*', element)
+
+      if (hash_parts = key.split('->')).length > 1
+        hget hash_parts.first, hash_parts.last
+      else
+        get key
+      end
+    end
+  end
+end

data/lib/fakeredis/transaction_commands.rb

@@ -0,0 +1,83 @@
+module FakeRedis
+  TRANSACTION_COMMANDS = [:discard, :exec, :multi, :watch, :unwatch]
+
+  module TransactionCommands
+    def self.included(klass)
+      klass.class_eval do
+        def self.queued_commands
+          @queued_commands ||= Hash.new {|h,k| h[k] = [] }
+        end
+
+        def self.in_multi
+          @in_multi ||= Hash.new{|h,k| h[k] = false}
+        end
+
+        def queued_commands
+          self.class.queued_commands[database_instance_key]
+        end
+
+        def queued_commands=(cmds)
+          self.class.queued_commands[database_instance_key] = cmds
+        end
+
+        def in_multi
+          self.class.in_multi[database_instance_key]
+        end
+
+        def in_multi=(multi_state)
+          self.class.in_multi[database_instance_key] = multi_state
+        end
+      end
+    end
+
+    def discard
+      unless in_multi
+        raise Redis::CommandError, "ERR DISCARD without MULTI"
+      end
+
+      self.in_multi = false
+      self.queued_commands = []
+
+      'OK'
+    end
+
+    def exec
+      unless in_multi
+        raise Redis::CommandError, "ERR EXEC without MULTI"
+      end
+
+      responses  = queued_commands.map do |cmd|
+        begin
+          send(*cmd)
+        rescue => e
+          e
+        end
+      end
+
+      self.queued_commands = [] # reset queued_commands
+      self.in_multi = false     # reset in_multi state
+
+      responses
+    end
+
+    def multi
+      if in_multi
+        raise Redis::CommandError, "ERR MULTI calls can not be nested"
+      end
+
+      self.in_multi = true
+
+      yield(self) if block_given?
+
+      "OK"
+    end
+
+    def watch(_)
+      "OK"
+    end
+
+    def unwatch
+      "OK"
+    end
+  end
+end

data/lib/fakeredis/version.rb

@@ -1,3 +1,3 @@
 module FakeRedis
-  VERSION = "0.4.3"
+  VERSION = "0.5.0"
 end

data/lib/fakeredis/zset.rb

@@ -11,15 +11,19 @@ module FakeRedis
     end
 
     def select_by_score min, max
-      min = _floatify(min)
-      max = _floatify(max)
+      min = _floatify(min, true)
+      max = _floatify(max, false)
       reject {|_,v| v < min || v > max }
     end
 
+    private
+
     # Originally lifted from redis-rb
-    def _floatify(str)
+    def _floatify(str, increment = true)
       if (( inf = str.to_s.match(/^([+-])?inf/i) ))
         (inf[1] == "-" ? -1.0 : 1.0) / 0.0
+      elsif (( number = str.to_s.match(/^\((\d+)/i) ))
+        number[1].to_i + (increment ? 1 : -1)
       else
         Float str
       end

data/lib/redis/connection/memory.rb

@@ -1,9 +1,12 @@
 require 'set'
 require 'redis/connection/registry'
 require 'redis/connection/command_helper'
+require "fakeredis/command_executor"
 require "fakeredis/expiring_hash"
+require "fakeredis/sort_method"
 require "fakeredis/sorted_set_argument_handler"
 require "fakeredis/sorted_set_store"
+require "fakeredis/transaction_commands"
 require "fakeredis/zset"
 
 class Redis
@@ -11,8 +14,11 @@ class Redis
     class Memory
       include Redis::Connection::CommandHelper
       include FakeRedis
+      include SortMethod
+      include TransactionCommands
+      include CommandExecutor
 
-      attr_accessor :buffer, :options
+      attr_accessor :options
 
       # 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
@@ -76,25 +82,6 @@ class Redis
       def timeout=(usecs)
       end
 
-      def write(command)
-        meffod = command.shift.to_s.downcase.to_sym
-        if respond_to?(meffod)
-          reply = send(meffod, *command)
-        else
-          raise Redis::CommandError, "ERR unknown command '#{meffod}'"
-        end
-
-        if reply == true
-          reply = 1
-        elsif reply == false
-          reply = 0
-        end
-
-        replies << reply
-        buffer << reply if buffer && meffod != :multi
-        nil
-      end
-
       def read
         replies.shift
       end
@@ -103,8 +90,6 @@ class Redis
       # * blpop
       # * brpop
       # * brpoplpush
-      # * discard
-      # * sort
       # * subscribe
       # * psubscribe
       # * publish
@@ -150,7 +135,7 @@ class Redis
 
       def bgsave ; end
 
-      def bgreriteaof ; end
+      def bgrewriteaof ; end
 
       def move key, destination_id
         raise Redis::CommandError, "ERR source and destination objects are the same" if destination_id == database_id
@@ -171,6 +156,11 @@ class Redis
         data[key].unpack('B*')[0].split("")[offset].to_i
       end
 
+      def bitcount(key, start_index = 0, end_index = -1)
+        return 0 unless data[key]
+        data[key][start_index..end_index].unpack('B*')[0].count("1")
+      end
+
       def getrange(key, start, ending)
         return unless data[key]
         data[key][start..ending]
@@ -214,8 +204,9 @@ class Redis
       def hdel(key, field)
         field = field.to_s
         data_type_check(key, Hash)
-        data[key] && data[key].delete(field)
+        deleted = data[key] && data[key].delete(field)
         remove_key_for_empty_collection(key)
+        deleted ? 1 : 0
       end
 
       def hkeys(key)
@@ -244,6 +235,11 @@ class Redis
         Time.now.to_i
       end
 
+      def time
+        microseconds = (Time.now.to_f * 1000000).to_i
+        [ microseconds / 1000000, microseconds % 1000000 ]
+      end
+
       def dbsize
         data.keys.count
       end
@@ -267,17 +263,17 @@ class Redis
         data_type_check(key, Array)
         return unless data[key]
 
-        if start < 0 && data[key].count < start.abs
-          # Example: we have a list of 3 elements and
-          # we give it a ltrim list, -5, -1. This means
-          # it should trim to a max of 5. Since 3 < 5
-          # we should not touch the list. This is consistent
-          # with behavior of real Redis's ltrim with a negative
-          # start argument.
-          data[key]
-        else
+        # Example: we have a list of 3 elements and
+        # we give it a ltrim list, -5, -1. This means
+        # it should trim to a max of 5. Since 3 < 5
+        # we should not touch the list. This is consistent
+        # with behavior of real Redis's ltrim with a negative
+        # start argument.
+        unless start < 0 && data[key].count < start.abs
           data[key] = data[key][start..stop]
         end
+
+        "OK"
       end
 
       def lindex(key, index)
@@ -360,7 +356,7 @@ class Redis
       def rpoplpush(key1, key2)
         data_type_check(key1, Array)
         rpop(key1).tap do |elem|
-          lpush(key2, elem)
+          lpush(key2, elem) unless elem.nil?
         end
       end
 
@@ -403,7 +399,17 @@ class Redis
 
       def srem(key, value)
         data_type_check(key, ::Set)
-        deleted = !!(data[key] && data[key].delete?(value.to_s))
+        return false unless data[key]
+
+        if value.is_a?(Array)
+          old_size = data[key].size
+          values = value.map(&:to_s)
+          values.each { |value| data[key].delete(value) }
+          deleted = old_size - data[key].size
+        else
+          deleted = !!data[key].delete?(value.to_s)
+        end
+
         remove_key_for_empty_collection(key)
         deleted
       end
@@ -473,10 +479,8 @@ class Redis
         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)]
+      def srandmember(key, number=nil)
+        number.nil? ? srandmember_single(key) : srandmember_multiple(key, number)
       end
 
       def del(*keys)
@@ -516,9 +520,9 @@ class Redis
       end
 
       def expire(key, ttl)
-        return unless data[key]
+        return 0 unless data[key]
         data.expires[key] = Time.now + ttl
-        true
+        1
       end
 
       def ttl(key)
@@ -586,7 +590,7 @@ class Redis
         raise_argument_error('hmget')  if fields.empty?
 
         data_type_check(key, Hash)
-        fields.map do |field|
+        fields.flatten.map do |field|
           field = field.to_s
           if data[key]
             data[key][field]
@@ -619,6 +623,17 @@ class Redis
         data[key][field].to_i
       end
 
+      def hincrbyfloat(key, field, increment)
+        data_type_check(key, Hash)
+        field = field.to_s
+        if data[key]
+          data[key][field] = (data[key][field].to_f + increment.to_f).to_s
+        else
+          data[key] = { field => increment.to_s }
+        end
+        data[key][field]
+      end
+
       def hexists(key, field)
         data_type_check(key, Hash)
         return false unless data[key]
@@ -635,8 +650,23 @@ class Redis
         set(key, value)
       end
 
-      def set(key, value)
+      def set(key, value, *array_options)
+        option_nx = array_options.delete("NX")
+        option_xx = array_options.delete("XX")
+
+        return false if option_nx && option_xx
+
+        return false if option_nx && exists(key)
+        return false if option_xx && !exists(key)
+
         data[key] = value.to_s
+
+        options = Hash[array_options.each_slice(2).to_a]
+        ttl_in_seconds = options["EX"] if options["EX"]
+        ttl_in_seconds = options["PX"] / 1000.0 if options["PX"]
+
+        expire(key, ttl_in_seconds) if ttl_in_seconds
+
         "OK"
       end
 
@@ -644,7 +674,7 @@ class Redis
         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]
+        original_val = old_val[offset].to_i
         old_val[offset] = bit.to_s
         new_val = ""
         old_val.each_slice(8){|b| new_val = new_val + b.join("").to_i(2).chr }
@@ -687,10 +717,6 @@ class Redis
         true
       end
 
-      def sort(key)
-        # TODO: Implement
-      end
-
       def incr(key)
         data.merge!({ key => (data[key].to_i + 1).to_s || "1"})
         data[key].to_i
@@ -728,22 +754,37 @@ class Redis
 
       def slaveof(host, port) ; end
 
-      def exec
-        buffer.tap {|x| self.buffer = nil }
-      end
+      def scan(start_cursor, *args)
+        match = "*"
+        count = 10
 
-      def multi
-        self.buffer = []
-        yield if block_given?
-        "OK"
-      end
+        if args.size.odd?
+          raise_argument_error('scan')
+        end
 
-      def watch(_)
-        "OK"
-      end
+        if idx = args.index("MATCH")
+          match = args[idx + 1]
+        end
 
-      def unwatch
-        "OK"
+        if idx = args.index("COUNT")
+          count = args[idx + 1]
+        end
+
+        start_cursor = start_cursor.to_i
+        data_type_check(start_cursor, Fixnum)
+
+        cursor = start_cursor
+        next_keys = []
+
+        if start_cursor + count >= data.length
+          next_keys = keys(match)[start_cursor..-1]
+          cursor = 0
+        else
+          cursor = start_cursor + 10
+          next_keys = keys(match)[start_cursor..cursor]
+        end
+
+        return "#{cursor}", next_keys
       end
 
       def zadd(key, *args)
@@ -900,6 +941,17 @@ class Redis
         range.size
       end
 
+      def zremrangebyrank(key, start, stop)
+        data_type_check(key, ZSet)
+        return 0 unless data[key]
+
+        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.size
+      end
+
       def zinterstore(out, *args)
         data_type_check(out, ZSet)
         args_handler = SortedSetArgumentHandler.new(args)
@@ -914,14 +966,6 @@ class Redis
         data[out].size
       end
 
-      def zremrangebyrank(key, start, stop)
-        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.size
-      end
-
       private
         def raise_argument_error(command, match_string=command)
           error_message = if %w(hmset mset_odd).include?(match_string.downcase)
@@ -964,6 +1008,25 @@ class Redis
         def mapped_param? param
           param.size == 1 && param[0].is_a?(Array)
         end
+
+        def srandmember_single(key)
+          data_type_check(key, ::Set)
+          return nil unless data[key]
+          data[key].to_a[rand(data[key].size)]
+        end
+
+        def srandmember_multiple(key, number)
+          return [] unless data[key]
+          if number >= 0
+            # replace with `data[key].to_a.sample(number)` when 1.8.7 is deprecated
+            (1..number).inject([]) do |selected, _|
+              available_elements = data[key].to_a - selected
+              selected << available_elements[rand(available_elements.size)]
+            end.compact
+          else
+            (1..-number).map { data[key].to_a[rand(data[key].size)] }.flatten
+          end
+        end
     end
   end
 end