fakeredis 0.5.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 20688b94f039d268518697ede7cdfad15f26cf73
-  data.tar.gz: ab1982d7e9ed2f7c6b864d2beadd63d6041bb59a
+SHA256:
+  metadata.gz: 7c0b77a04c1c761edb3a6544aca213f373d57bb485d17f9e7e0f2c63bfd7e660
+  data.tar.gz: 57975993a6664bc469ee297a6a36d75ac2e4e429972aee6e50a2f518f93ca580
 SHA512:
-  metadata.gz: 080b44a262bae01a09dcd2660cb35e1a52543cad7d3780fc58224854b6007adb8a0598a0b892560988f7a86c921a1ea1d3b36fa19248542017ffb97ce8caa0ef
-  data.tar.gz: 687896c96f26f389776216ef6397ce9bb025e9fb04008860dc377f8ba0965245185b02bb4381e7e560a5d76621b8c87ee4989878fbe0bd086e5fc30e2e3c6442
+  metadata.gz: ba35de9b7e297eca69cb7652d7817f257c447d7533d8c259c47215b15355ec49e5c2584907f0726f97327c443de122bd240cbca6fa194222f114bc99ffd0dbb9
+  data.tar.gz: 8c4e340be842d1fe966a3a4c6f63987bc8af346da74ced914cdc77488e08a6d15101ee6625097337287ec55c19f41118da4a79892b7fdd00bbebff1d103a813a

data/.gitignore

@@ -4,3 +4,6 @@ Gemfile.lock
 pkg/*
 .rvmrc
 *.rbc
+.ruby-version
+.ruby-gemset
+bin

data/.travis.yml

@@ -1,8 +1,17 @@
 language: ruby
+cache: bundler
+# Use the faster container based infrastructure
+# http://blog.travis-ci.com/2014-12-17-faster-builds-with-container-based-infrastructure/
+sudo: false
+
 rvm:
-  - 1.9.2
-  - 1.9.3
-  - 2.0.0
-  - 2.1.1
-  - jruby-19mode
+  - 2.4
+  - 2.5
+  - 2.6
+  - ruby-head
+  - jruby
   - rbx-2
+
+matrix:
+  allow_failures:
+    - rvm: rbx-2

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2011-2014 Guillermo Iguaran
+Copyright (c) 2011-2018 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,8 +15,8 @@ Add it to your Gemfile:
 
 ## Versions
 
-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:
+FakeRedis currently supports redis-rb v3 or later, if you are using
+redis-rb v2.2 install the version 0.3.x:
 
     gem install fakeredis -v "~> 0.3.0"
 
@@ -29,45 +29,63 @@ or use the branch 0-3-x on your Gemfile:
 
 You can use FakeRedis without any changes:
 
+```
     require "fakeredis"
-    
+
     redis = Redis.new
-    
+
     >> redis.set "foo", "bar"
     => "OK"
-    
+
     >> redis.get "foo"
     => "bar"
+```
 
-Read [redis-rb](https://github.com/ezmobius/redis-rb) documentation and
+Read [redis-rb](https://github.com/redis/redis-rb) documentation and
 [Redis](http://redis.io) homepage for more info about commands
 
 ## Usage with RSpec
 
-Require this either in your Gemfile or in RSpec's support scripts. So either: 
+Require this either in your Gemfile or in RSpec's support scripts. So either:
 
-    # Gemfile
-    group :test do
-      gem "rspec"
-      gem "fakeredis", :require => "fakeredis/rspec"
-    end
+```ruby
+# Gemfile
+group :test do
+  gem "rspec"
+  gem "fakeredis", :require => "fakeredis/rspec"
+end
+```
 
 Or:
 
-    # spec/support/fakeredis.rb
-    require 'fakeredis/rspec'
+```ruby
+# spec/support/fakeredis.rb
+require 'fakeredis/rspec'
+```
 
-## Acknowledgements
+## Usage with Minitest
+
+Require this either in your Gemfile or in Minitest's support scripts. So
+either:
 
-* [dim](https://github.com/dim)
-* [czarneckid](https://github.com/czarneckid)
-* [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!!!)
+```ruby
+# Gemfile
+group :test do
+  gem "minitest"
+  gem "fakeredis", :require => "fakeredis/minitest"
+end
+```
+
+Or:
+
+```ruby
+# test/test_helper.rb (or test/minitest_config.rb)
+require 'fakeredis/minitest'
+```
+
+## Acknowledgements
 
+Thanks to [all contributors](https://github.com/guilleiguaran/fakeredis/graphs/contributors), specially to [Caius Durling](https://github.com/caius) the most active one.
 
 ## Contributing to FakeRedis
 
@@ -82,5 +100,5 @@ Or:
 
 ## Copyright
 
-Copyright (c) 2011-2014 Guillermo Iguaran. See LICENSE for
+Copyright (c) 2011-2018 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"])
+  s.add_runtime_dependency(%q<redis>, ["~> 4.1"])
   s.add_development_dependency(%q<rspec>, ["~> 3.0"])
 end

data/lib/fakeredis.rb

@@ -3,4 +3,32 @@ require 'redis/connection/memory'
 
 module FakeRedis
   Redis = ::Redis
+
+  def self.enable
+    Redis::Connection.drivers << Redis::Connection::Memory unless enabled?
+  end
+
+  def self.enabled?
+    Redis::Connection.drivers.last == Redis::Connection::Memory
+  end
+
+  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/bitop_command.rb

@@ -0,0 +1,56 @@
+module FakeRedis
+  module BitopCommand
+    BIT_OPERATORS = {
+      'or'  => :|,
+      'and' => :&,
+      'xor' => :'^',
+      'not' => :~,
+    }
+
+    def bitop(operation, destkey, *keys)
+      if result = apply(operator(operation), keys)
+        set(destkey, result)
+        result.length
+      else
+        0
+      end
+    rescue ArgumentError => _
+      raise_argument_error('bitop')
+    end
+
+    private
+
+    def operator(operation)
+      BIT_OPERATORS[operation.to_s.downcase]
+    end
+
+    def apply(operator, keys)
+      case operator
+      when :~
+        raise ArgumentError if keys.count != 1
+        bitwise_not(keys.first)
+      when :&, :|, :'^'
+        raise ArgumentError if keys.empty?
+        bitwise_operation(operator, keys)
+      else
+        raise ArgumentError
+      end
+    end
+
+    def bitwise_not(key)
+      if value = get(keys.first)
+        value.bytes.map { |byte| ~ byte }.pack('c*')
+      end
+    end
+
+    def bitwise_operation(operation, keys)
+      apply_onto, *values = keys.map { |key| get(key) }.reject(&:nil?)
+      values.reduce(apply_onto) do |memo, value|
+        shorter, longer = [memo, value].sort_by(&:length).map(&:bytes).map(&:to_a)
+        longer.each_with_index.map do |byte, index|
+          byte.send(operation, shorter[index] || 0)
+        end.pack('c*')
+      end
+    end
+  end
+end

data/lib/fakeredis/command_executor.rb

@@ -1,23 +1,20 @@
 module FakeRedis
   module CommandExecutor
     def write(command)
-      meffod = command.shift.to_s.downcase.to_sym
+      meffod = command[0].to_s.downcase.to_sym
+      args = command[1..-1]
 
       if in_multi && !(TRANSACTION_COMMANDS.include? meffod) # queue commands
-        queued_commands << [meffod, *command]
+        queued_commands << [meffod, *args]
         reply = 'QUEUED'
+      elsif respond_to?(meffod) && method(meffod).arity.zero?
+        reply = send(meffod)
       elsif respond_to?(meffod)
-        reply = send(meffod, *command)
+        reply = send(meffod, *args)
       else
         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

@@ -34,7 +34,7 @@ module FakeRedis
 
     def expired?(key)
       key = normalize key
-      expires.include?(key) && expires[key] < Time.now
+      expires.include?(key) && expires[key] <= Time.now
     end
 
     def key?(key)
@@ -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