fakeredis 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 1be2134927d3b7838ee3e2fd4376791bea516561
-  data.tar.gz: 2b3e0c64b79df1358151bbd1405000395fa06e86
+SHA256:
+  metadata.gz: 7c0b77a04c1c761edb3a6544aca213f373d57bb485d17f9e7e0f2c63bfd7e660
+  data.tar.gz: 57975993a6664bc469ee297a6a36d75ac2e4e429972aee6e50a2f518f93ca580
 SHA512:
-  metadata.gz: cfb37be84fd30d941fadc44a177e2029cd2de063fc090bc3004166a72f5dba6e7378e9c918aa1d156d44b8277f830dfedbd34aad57142770512f420f4f12fae3
-  data.tar.gz: 2f841badb4c16e9ff6d3c35b697b9ee262022bc8286553e7187a47173af742114eacd5cccdb3d0477c111457fc9a7f50fdb7de970a25c04ba1be33318c84a1ac
+  metadata.gz: ba35de9b7e297eca69cb7652d7817f257c447d7533d8c259c47215b15355ec49e5c2584907f0726f97327c443de122bd240cbca6fa194222f114bc99ffd0dbb9
+  data.tar.gz: 8c4e340be842d1fe966a3a4c6f63987bc8af346da74ced914cdc77488e08a6d15101ee6625097337287ec55c19f41118da4a79892b7fdd00bbebff1d103a813a

data/.gitignore

@@ -1,7 +1,6 @@
 *.gem
 .bundle
 Gemfile.lock
-gemfiles/*.gemfile.lock
 pkg/*
 .rvmrc
 *.rbc

data/.travis.yml

@@ -5,18 +5,13 @@ cache: bundler
 sudo: false
 
 rvm:
-  - 2.2
-  - 2.3.6
   - 2.4
   - 2.5
+  - 2.6
   - ruby-head
   - jruby
   - rbx-2
 
-gemfile:
-  - Gemfile
-  - gemfiles/redisrb-master.gemfile
-
 matrix:
   allow_failures:
     - rvm: rbx-2

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.2", "< 5.0"])
+  s.add_runtime_dependency(%q<redis>, ["~> 4.1"])
   s.add_development_dependency(%q<rspec>, ["~> 3.0"])
 end

data/lib/fakeredis.rb

@@ -15,4 +15,20 @@ module FakeRedis
   def self.disable
     Redis::Connection.drivers.delete_if {|driver| Redis::Connection::Memory == driver }
   end
+
+  def self.disabling
+    return yield unless enabled?
+
+    disable
+    yield
+    enable
+  end
+
+  def self.enabling
+    return yield if enabled?
+
+    enable
+    yield
+    disable
+  end
 end

data/lib/fakeredis/command_executor.rb

@@ -15,12 +15,6 @@ module FakeRedis
         raise Redis::CommandError, "ERR unknown command '#{meffod}'"
       end
 
-      if reply == true
-        reply = 1
-      elsif reply == false
-        reply = 0
-      end
-
       replies << reply
       nil
     end

data/lib/fakeredis/expiring_hash.rb

@@ -44,10 +44,8 @@ module FakeRedis
     end
 
     def values_at(*keys)
-      keys.each do |key|
-        key = normalize(key)
-        delete(key) if expired?(key)
-      end
+      keys = keys.map { |key| normalize(key) }
+      keys.each { |key| delete(key) if expired?(key) }
       super
     end
 

data/lib/fakeredis/geo_commands.rb

@@ -0,0 +1,142 @@
+require "fakeredis/geo_set"
+
+module FakeRedis
+  module GeoCommands
+    DISTANCE_UNITS = {
+      "m" => 1,
+      "km" => 1000,
+      "ft" => 0.3048,
+      "mi" => 1609.34
+    }
+
+    REDIS_DOUBLE_PRECISION = 4
+    REDIS_GEOHASH_SIZE = 10
+
+    def geoadd(key, *members)
+      raise_argument_error("geoadd") if members.empty? || members.size % 3 != 0
+
+      set = (data[key] ||= GeoSet.new)
+      prev_size = set.size
+      members.each_slice(3) do |member|
+        set.add(*member)
+      end
+      set.size - prev_size
+    end
+
+    def geodist(key, member1, member2, unit = "m")
+      unit = unit.to_s
+      raise_command_error("ERR unsupported unit provided. please use #{DISTANCE_UNITS.keys.join(', ')}") unless DISTANCE_UNITS.include?(unit)
+
+      set = (data[key] || GeoSet.new)
+      point1 = set.get(member1)
+      point2 = set.get(member2)
+      if point1 && point2
+        distance = point1.distance_to(point2)
+        distance_in_units = distance / DISTANCE_UNITS[unit]
+        distance_in_units.round(REDIS_DOUBLE_PRECISION).to_s
+      end
+    end
+
+    def geohash(key, member)
+      members = Array(member)
+      raise_argument_error("geohash") if members.empty?
+      set = (data[key] || GeoSet.new)
+      members.map do |member|
+        point = set.get(member)
+        point.geohash(REDIS_GEOHASH_SIZE) if point
+      end
+    end
+
+    def geopos(key, member)
+      return nil unless data[key]
+
+      members = Array(member)
+      set = (data[key] || GeoSet.new)
+      members.map do |member|
+        point = set.get(member)
+        [point.lon.to_s, point.lat.to_s] if point
+      end
+    end
+
+    def georadius(*args)
+      args = args.dup
+      raise_argument_error("georadius") if args.size < 5
+      key, lon, lat, radius, unit, *rest = args
+      raise_argument_error("georadius") unless DISTANCE_UNITS.has_key?(unit)
+      radius *= DISTANCE_UNITS[unit]
+
+      set = (data[key] || GeoSet.new)
+      center = GeoSet::Point.new(lon, lat, nil)
+
+      do_georadius(set, center, radius, unit, rest)
+    end
+
+    def georadiusbymember(*args)
+      args = args.dup
+      raise_argument_error("georadiusbymember") if args.size < 4
+      key, member, radius, unit, *rest = args
+      raise_argument_error("georadiusbymember") unless DISTANCE_UNITS.has_key?(unit)
+      radius *= DISTANCE_UNITS[unit]
+
+      set = (data[key] || GeoSet.new)
+      center = set.get(member)
+      raise_command_error("ERR could not decode requested zset member") unless center
+
+      do_georadius(set, center, radius, unit, args)
+    end
+
+    private
+
+    def do_georadius(set, center, radius, unit, args)
+      points = set.points_within_radius(center, radius)
+
+      options = georadius_options(args)
+
+      if options[:asc]
+        points.sort_by! { |p| p.distance_to(center) }
+      elsif options[:desc]
+        points.sort_by! { |p| -p.distance_to(center) }
+      end
+
+      points = points.take(options[:count]) if options[:count]
+      extras = options[:extras]
+      return points.map(&:name) if extras.empty?
+
+      points.map do |point|
+        member = [point.name]
+
+        extras.each do |extra|
+          case extra
+          when "WITHCOORD"
+            member << [point.lon.to_s, point.lat.to_s]
+          when "WITHDIST"
+            distance = point.distance_to(center)
+            distance_in_units = distance / DISTANCE_UNITS[unit]
+            member << distance_in_units.round(REDIS_DOUBLE_PRECISION).to_s
+          when "WITHHASH"
+            member << point.geohash(REDIS_GEOHASH_SIZE)
+          end
+        end
+
+        member
+      end
+    end
+
+    def georadius_options(args)
+      options = {}
+      args = args.map { |arg| arg.to_s.upcase }
+
+      if idx = args.index("COUNT")
+        options[:count] = Integer(args[idx + 1])
+      end
+
+      options[:asc]  = true if args.include?("ASC")
+      options[:desc] = true if args.include?("DESC")
+
+      extras = args & ["WITHCOORD", "WITHDIST", "WITHHASH"]
+      options[:extras] = extras
+
+      options
+    end
+  end
+end

data/lib/fakeredis/geo_set.rb

@@ -0,0 +1,84 @@
+module FakeRedis
+  class GeoSet
+    class Point
+      BASE32 = "0123456789bcdefghjkmnpqrstuvwxyz" # (geohash-specific) Base32 map
+      EARTH_RADIUS_IN_M = 6_378_100.0
+
+      attr_reader :lon, :lat, :name
+
+      def initialize(lon, lat, name)
+        @lon = Float(lon)
+        @lat = Float(lat)
+        @name = name
+      end
+
+      def geohash(precision = 10)
+        latlon = [@lat, @lon]
+        ranges = [[-90.0, 90.0], [-180.0, 180.0]]
+        coordinate = 1
+
+        (0...precision).map do
+          index = 0 # index into base32 map
+
+          5.times do |bit|
+            mid = (ranges[coordinate][0] + ranges[coordinate][1]) / 2
+            if latlon[coordinate] >= mid
+              index = index * 2 + 1
+              ranges[coordinate][0] = mid
+            else
+              index *= 2
+              ranges[coordinate][1] = mid
+            end
+
+            coordinate ^= 1
+          end
+
+          BASE32[index]
+        end.join
+      end
+
+      def distance_to(other)
+        lat1 = deg_to_rad(@lat)
+        lon1 = deg_to_rad(@lon)
+        lat2 = deg_to_rad(other.lat)
+        lon2 = deg_to_rad(other.lon)
+        haversine_distance(lat1, lon1, lat2, lon2)
+      end
+
+      private
+
+      def deg_to_rad(deg)
+        deg * Math::PI / 180.0
+      end
+
+      def haversine_distance(lat1, lon1, lat2, lon2)
+        h = Math.sin((lat2 - lat1) / 2) ** 2 + Math.cos(lat1) * Math.cos(lat2) *
+              Math.sin((lon2 - lon1) / 2) ** 2
+
+        2 * EARTH_RADIUS_IN_M * Math.asin(Math.sqrt(h))
+      end
+    end
+
+    def initialize
+      @points = {}
+    end
+
+    def size
+      @points.size
+    end
+
+    def add(lon, lat, name)
+      @points[name] = Point.new(lon, lat, name)
+    end
+
+    def get(name)
+      @points[name]
+    end
+
+    def points_within_radius(center, radius)
+      @points.values.select do |point|
+        point.distance_to(center) <= radius
+      end
+    end
+  end
+end

data/lib/fakeredis/minitest.rb

@@ -15,8 +15,8 @@ require 'fakeredis'
 module FakeRedis
   module Minitest
     def setup
-      super
       Redis::Connection::Memory.reset_all_databases
+      super
     end
 
     ::Minitest::Test.send(:include, self)

data/lib/fakeredis/sort_method.rb

@@ -6,7 +6,6 @@ module FakeRedis
       return [] if type(key) == 'none'
 
       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
 

data/lib/fakeredis/version.rb

@@ -1,3 +1,3 @@
 module FakeRedis
-  VERSION = "0.7.0"
+  VERSION = "0.8.0"
 end

data/lib/fakeredis/zset.rb

@@ -17,7 +17,7 @@ module FakeRedis
     def select_by_score min, max
       min = _floatify(min, true)
       max = _floatify(max, false)
-      reject {|_,v| v < min || v > max }
+      select {|_,v| v >= min && v <= max }
     end
 
     private

data/lib/redis/connection/memory.rb

@@ -9,16 +9,20 @@ require "fakeredis/sorted_set_store"
 require "fakeredis/transaction_commands"
 require "fakeredis/zset"
 require "fakeredis/bitop_command"
+require "fakeredis/geo_commands"
 require "fakeredis/version"
 
 class Redis
   module Connection
+    DEFAULT_REDIS_VERSION = '3.3.5'
+
     class Memory
       include Redis::Connection::CommandHelper
       include FakeRedis
       include SortMethod
       include TransactionCommands
       include BitopCommand
+      include GeoCommands
       include CommandExecutor
 
       attr_accessor :options
@@ -51,7 +55,7 @@ class Redis
       end
 
       def initialize(options = {})
-        self.options = options
+        self.options = self.options ? self.options.merge(options) : options
       end
 
       def database_id
@@ -93,9 +97,8 @@ class Redis
 
       def client(command, _options = {})
         case command
-        when :setname then true
+        when :setname then "OK"
         when :getname then nil
-        when :client then true
         else
           raise Redis::CommandError, "ERR unknown command '#{command}'"
         end
@@ -130,7 +133,7 @@ class Redis
 
       def info
         {
-          "redis_version" => "2.6.16",
+          "redis_version" => options[:version] || DEFAULT_REDIS_VERSION,
           "connected_clients" => "1",
           "connected_slaves" => "0",
           "used_memory" => "3187",
@@ -147,9 +150,13 @@ class Redis
 
       def save; end
 
-      def bgsave ; end
+      def bgsave; end
+
+      def bgrewriteaof; end
+
+      def evalsha; end
 
-      def bgrewriteaof ; end
+      def eval; end
 
       def move key, destination_id
         raise Redis::CommandError, "ERR source and destination objects are the same" if destination_id == database_id
@@ -214,6 +221,11 @@ class Redis
         data[key][start_index..end_index].unpack('B*')[0].count("1")
       end
 
+      def bitpos(key, bit, start_index = 0, end_index = -1)
+        value = data[key] || ""
+        value[0..end_index].unpack('B*')[0].index(bit.to_s, start_index * 8) || -1
+      end
+
       def getrange(key, start, ending)
         return unless data[key]
         data[key][start..ending]
@@ -493,9 +505,9 @@ class Redis
 
       def brpoplpush(key1, key2, opts={})
         data_type_check(key1, Array)
-        brpop(key1).tap do |elem|
-          lpush(key2, elem) unless elem.nil?
-        end
+        _key, elem = brpop(key1)
+        lpush(key2, elem) unless elem.nil?
+        elem
       end
 
       def lpop(key)
@@ -549,6 +561,8 @@ class Redis
 
       def srem(key, value)
         data_type_check(key, ::Set)
+        value = Array(value)
+        raise_argument_error('srem') if value.empty?
         return false unless data[key]
 
         if value.is_a?(Array)
@@ -575,7 +589,7 @@ class Redis
         data_type_check(key, ::Set)
         results = (count || 1).times.map do
           elem = srandmember(key)
-          srem(key, elem)
+          srem(key, elem) if elem
           elem
         end.compact
         count.nil? ? results.first : results
@@ -680,14 +694,11 @@ class Redis
       end
 
       def del(*keys)
-        keys = keys.flatten(1)
-        raise_argument_error('del') if keys.empty?
+        delete_keys(keys, 'del')
+      end
 
-        old_count = data.keys.size
-        keys.each do |key|
-          data.delete(key)
-        end
-        old_count - data.keys.size
+      def unlink(*keys)
+        delete_keys(keys, 'unlink')
       end
 
       def setnx(key, value)
@@ -798,7 +809,7 @@ class Redis
       end
 
       def hmget(key, *fields)
-        raise_argument_error('hmget')  if fields.empty?
+        raise_argument_error('hmget')  if fields.empty? || fields.flatten.empty?
 
         data_type_check(key, Hash)
         fields.flatten.map do |field|
@@ -817,6 +828,12 @@ class Redis
         data[key].size
       end
 
+      def hstrlen(key, field)
+        data_type_check(key, Hash)
+        return 0 if data[key].nil? || data[key][field].nil?
+        data[key][field].size
+      end
+
       def hvals(key)
         data_type_check(key, Hash)
         return [] unless data[key]
@@ -853,22 +870,14 @@ class Redis
 
       def sync ; end
 
-      def [](key)
-        get(key)
-      end
-
-      def []=(key, value)
-        set(key, value)
-      end
-
       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 nil if option_nx && option_xx
 
-        return false if option_nx && exists(key)
-        return false if option_xx && !exists(key)
+        return nil if option_nx && exists(key)
+        return nil if option_xx && !exists(key)
 
         data[key] = value.to_s
 
@@ -899,6 +908,10 @@ class Redis
         "OK"
       end
 
+      def psetex(key, milliseconds, value)
+        setex(key, milliseconds / 1000.0, value)
+      end
+
       def setrange(key, offset, value)
         return unless data[key]
         s = data[key][offset,value.size]
@@ -1005,6 +1018,19 @@ class Redis
       end
 
       def zadd(key, *args)
+        option_xx = args.delete("XX")
+        option_nx = args.delete("NX")
+        option_ch = args.delete("CH")
+        option_incr = args.delete("INCR")
+
+        if option_xx && option_nx
+          raise_options_error("XX", "NX")
+        end
+
+        if option_incr && args.size > 2
+          raise_options_error("INCR")
+        end
+
         if !args.first.is_a?(Array)
           if args.size < 2
             raise_argument_error('zadd')
@@ -1020,18 +1046,39 @@ class Redis
         data_type_check(key, ZSet)
         data[key] ||= ZSet.new
 
-        if args.size == 2 && !(Array === args.first)
-          score, value = args
-          exists = !data[key].key?(value.to_s)
+        # 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)
+
+        changed = 0
+        exists = args.map(&:last).count { |el| !hexists(key, el.to_s) }
+
+        args.each do |score, value|
+          if option_nx && hexists(key, value.to_s)
+            next
+          end
+
+          if option_xx && !hexists(key, value.to_s)
+            exists -= 1
+            next
+          end
+
+          if option_incr
+            data[key][value.to_s] ||= 0
+            return data[key].increment(value, score).to_s
+          end
+
+          if option_ch && data[key][value.to_s] != score
+            changed += 1
+          end
           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 { |s, v| data[key][v.to_s] = s }
         end
 
-        exists
+        if option_incr
+          changed = changed.zero? ? nil : changed
+          exists = exists.zero? ? nil : exists
+        end
+
+        option_ch ? changed : exists
       end
 
       def zrem(key, value)
@@ -1047,6 +1094,36 @@ class Redis
         response
       end
 
+      def zpopmax(key, count = nil)
+        data_type_check(key, ZSet)
+        return [] unless data[key]
+        sorted_members = sort_keys(data[key])
+        results = sorted_members.last(count || 1).reverse!
+        results.each do |member|
+          zrem(key, member.first)
+        end
+        count.nil? ? results.first : results.flatten
+      end
+
+      def zpopmin(key, count = nil)
+        data_type_check(key, ZSet)
+        return [] unless data[key]
+        sorted_members = sort_keys(data[key])
+        results = sorted_members.first(count || 1)
+        results.each do |member|
+          zrem(key, member.first)
+        end
+        count.nil? ? results.first : results.flatten
+      end
+
+      def bzpopmax(*args)
+        bzpop(:bzpopmax, args)
+      end
+
+      def bzpopmin(*args)
+        bzpop(:bzpopmin, args)
+      end
+
       def zcard(key)
         data_type_check(key, ZSet)
         data[key] ? data[key].size : 0
@@ -1055,7 +1132,13 @@ class Redis
       def zscore(key, value)
         data_type_check(key, ZSet)
         value = data[key] && data[key][value.to_s]
-        value && value.to_s
+        if value == Float::INFINITY
+          "inf"
+        elsif value == -Float::INFINITY
+          "-inf"
+        elsif value
+          value.to_s
+        end
       end
 
       def zcount(key, min, max)
@@ -1069,7 +1152,14 @@ class Redis
         data[key] ||= ZSet.new
         data[key][value.to_s] ||= 0
         data[key].increment(value.to_s, num)
-        data[key][value.to_s].to_s
+
+        if num =~ /^\+?inf/
+          "inf"
+        elsif num == "-inf"
+          "-inf"
+        else
+          data[key][value.to_s].to_s
+        end
       end
 
       def zrank(key, value)
@@ -1093,6 +1183,7 @@ class Redis
         results = sort_keys(data[key])
         # Select just the keys unless we want scores
         results = results.map(&:first) unless with_scores
+        start = [start, -results.size].max
         (results[start..stop] || []).flatten.map(&:to_s)
       end
 
@@ -1208,6 +1299,33 @@ class Redis
         data[out].size
       end
 
+      def pfadd(key, member)
+        data_type_check(key, Set)
+        data[key] ||= Set.new
+        previous_size = data[key].size
+        data[key] |= Array(member)
+        data[key].size != previous_size
+      end
+
+      def pfcount(*keys)
+        keys = keys.flatten
+        raise_argument_error("pfcount") if keys.empty?
+        keys.each { |key| data_type_check(key, Set) }
+        if keys.count == 1
+          (data[keys.first] || Set.new).size
+        else
+          union = keys.map { |key| data[key] }.compact.reduce(&:|)
+          union.size
+        end
+      end
+
+      def pfmerge(destination, *sources)
+        sources.each { |source| data_type_check(source, Set) }
+        union = sources.map { |source| data[source] || Set.new }.reduce(&:|)
+        data[destination] = union
+        "OK"
+      end
+
       def subscribe(*channels)
         raise_argument_error('subscribe') if channels.empty?()
 
@@ -1348,13 +1466,36 @@ class Redis
           raise Redis::CommandError, "ERR syntax error"
         end
 
+        def raise_options_error(*options)
+          if options.detect { |opt| opt.match(/incr/i) }
+            error_message = "ERR INCR option supports a single increment-element pair"
+          else
+            error_message = "ERR #{options.join(" and ")} options at the same time are not compatible"
+          end
+          raise Redis::CommandError, error_message
+        end
+
+        def raise_command_error(message)
+          raise Redis::CommandError, message
+        end
+
+        def delete_keys(keys, command)
+          keys = keys.flatten(1)
+          raise_argument_error(command) if keys.empty?
+
+          old_count = data.keys.size
+          keys.each do |key|
+            data.delete(key)
+          end
+          old_count - data.keys.size
+        end
+
         def remove_key_for_empty_collection(key)
           del(key) if data[key] && data[key].empty?
         end
 
         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 Redis::CommandError.new("WRONGTYPE Operation against a key holding the wrong kind of value")
           end
         end
@@ -1419,9 +1560,33 @@ class Redis
           end
         end
 
+        def bzpop(command, args)
+          timeout =
+            if args.last.is_a?(Hash)
+              args.pop[:timeout]
+            elsif args.last.respond_to?(:to_int)
+              args.pop.to_int
+            end
+
+          timeout ||= 0
+          single_pop_command = command.to_s[1..-1]
+          keys = args.flatten
+          keys.each do |key|
+            if data[key]
+              data_type_check(data[key], ZSet)
+              if data[key].size > 0
+                result = public_send(single_pop_command, key)
+                return result.unshift(key)
+              end
+            end
+          end
+          sleep(timeout.to_f)
+          nil
+        end
+
         def sort_keys(arr)
           # Sort by score, or if scores are equal, key alphanum
-          sorted_keys = arr.sort do |(k1, v1), (k2, v2)|
+          arr.sort do |(k1, v1), (k2, v2)|
             if v1 == v2
               k1 <=> k2
             else