rediska 0.3.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 5efa2877ed6be2aaac8746a197e0c0af6a82684a
-  data.tar.gz: 30d0a4254f13357960664cf89e8737ec3ac05703
+SHA256:
+  metadata.gz: '09a30ec9909bf8d0e289b62a48184649e43a5053e4d38049efc1514fc496d29f'
+  data.tar.gz: 211591dea5dc948d4bcb0fece84b33bb6899fe980b87b061daa6bcb44b8d8354
 SHA512:
-  metadata.gz: 7c053f2ec1b3b5dfaeaffe3e3319d4c7d3644f3300ca868066ae9bc38f45012299ae14cd5b7b3189f5f2730b8adea503c33dce565b7cb925ec9e07c3ea0b5a79
-  data.tar.gz: c0ce4d41e22a9215144ebaef7d714720b7567c7729b17c3d3b4305d9e0cbd6573db6f23aad7cf5a848d070e1009e648cd0204d88a6ab5daab39c1c012db1b6d9
+  metadata.gz: 3d0ee50c993ca33227397ad369ce542555422ff9d589e09d3944dd2cc03fb093bc6799c7c139e987b52fc30ae34e986aa743259d4791688bee60763a351c9c2e
+  data.tar.gz: a29a26ffa641cbd11c8cd0569206f1e1547c569a1a365ec7bd8c4bf443afaf5345bbe55917ae7531d5a4d4947bd8b00bf9194dd43990ba59e0df35a7b3e8cad6

data/.travis.yml

@@ -2,14 +2,13 @@ language: ruby
 before_install:
   - travis_retry gem install bundler
 rvm:
-  - 2.0.0
-  - 2.1.2
-  - 2.2.0
+  - 2.2.2
   - ruby-head
   - jruby
-  - rbx-2
 gemfile:
   - Gemfile
+services:
+  - redis-server
 matrix:
   allow_failures:
     - rvm: rbx-2

data/README.md

@@ -160,6 +160,7 @@ end
 * SPOP
 * SRANDMEMBER
 * SREM
+* SSCAN
 * STRLEN
 * SUNION
 * SUNIONSTORE
@@ -171,7 +172,6 @@ end
 * ZADD
 * ZCARD
 * ZCOUNT
-* ZINCRBY
 * ZINTERSTORE
 * ZUNIONSTORE
 * ZRANK
@@ -182,7 +182,7 @@ end
 * ZREVRANGE
 * ZREVRANGEBYSCORE
 * ZREVRANK
-* ZSCORE
+* ZSCAN
 
 ## Credits and Contributors
 

data/lib/rediska/command_executor.rb

@@ -1,13 +1,16 @@
 module Rediska
   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
@@ -16,6 +19,8 @@ module Rediska
         reply = 1
       elsif reply == false
         reply = 0
+      elsif reply.is_a?(Array)
+        reply = reply.map { |r| r == true ? 1 : r == false ? 0 : r }
       end
 
       replies << reply

data/lib/rediska/driver.rb

@@ -17,6 +17,16 @@ module Rediska
     def disconnect
     end
 
+    def client(command, _options = {})
+      case command
+      when :setname then true
+      when :getname then nil
+      when :client then true
+      else
+        raise Redis::CommandError, "ERR unknown command '#{command}'"
+      end
+    end
+
     def timeout=(usecs)
     end
 
@@ -43,7 +53,7 @@ module Rediska
       'OK'
     end
 
-    def auth(password)
+    def auth(*args)
       'OK'
     end
 
@@ -198,6 +208,42 @@ module Rediska
       data[key].keys
     end
 
+    def hscan(key, start_cursor, *args)
+      data_type_check(key, Hash)
+      return ['0', []] unless data[key]
+
+      match = '*'
+      count = 10
+
+      raise_argument_error('hscan') if args.size.odd?
+
+      if idx = args.index('MATCH')
+        match = args[idx + 1]
+      end
+
+      if idx = args.index('COUNT')
+        count = args[idx + 1]
+      end
+
+      start_cursor = start_cursor.to_i
+
+      cursor = start_cursor
+      next_keys = []
+
+      if start_cursor + count >= data[key].length
+        next_keys = (data[key].to_a)[start_cursor..-1]
+        cursor = 0
+      else
+        cursor = start_cursor + count
+        next_keys = (data[key].to_a)[start_cursor..cursor-1]
+      end
+
+      filtered_next_keys = next_keys.select{|k,v| File.fnmatch(match, k)}
+      result = filtered_next_keys.flatten.map(&:to_s)
+
+      return ["#{cursor}", result]
+    end
+
     def keys(pattern = '*')
       data.keys.select { |key| File.fnmatch(pattern, key) }
     end
@@ -281,7 +327,7 @@ module Rediska
 
     def lrem(key, count, value)
       data_type_check(key, Array)
-      return unless data[key]
+      return 0 unless data[key]
       old_size = data[key].size
       diff =
         if count == 0
@@ -499,6 +545,44 @@ module Rediska
       number.nil? ? srandmember_single(key) : srandmember_multiple(key, number)
     end
 
+    def sscan(key, start_cursor, *args)
+      data_type_check(key, ::Set)
+      return ['0', []] unless data[key]
+
+      match = '*'
+      count = 10
+
+      if args.size.odd?
+        raise_argument_error('sscan')
+      end
+
+      if idx = args.index('MATCH')
+        match = args[idx + 1]
+      end
+
+      if idx = args.index('COUNT')
+        count = args[idx + 1]
+      end
+
+      start_cursor = start_cursor.to_i
+
+      cursor = start_cursor
+      next_keys = []
+
+      if start_cursor + count >= data[key].length
+        next_keys = (data[key].to_a)[start_cursor..-1]
+        cursor = 0
+      else
+        cursor = start_cursor + count
+        next_keys = (data[key].to_a)[start_cursor..cursor-1]
+      end
+
+      filtered_next_keys = next_keys.select{ |k,v| File.fnmatch(match, k)}
+      result = filtered_next_keys.flatten.map(&:to_s)
+
+      return ["#{cursor}", result]
+    end
+
     def del(*keys)
       keys = keys.flatten(1)
       raise_argument_error('del') if keys.empty?
@@ -813,7 +897,7 @@ module Rediska
       end
 
       start_cursor = start_cursor.to_i
-      data_type_check(start_cursor, Fixnum)
+      data_type_check(start_cursor, Integer)
 
       cursor = start_cursor
       next_keys = []
@@ -877,26 +961,12 @@ module Rediska
       data[key] ? data[key].size : 0
     end
 
-    def zscore(key, value)
-      data_type_check(key, ZSet)
-      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]
       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].increment(value.to_s, num)
-      data[key][value.to_s].to_s
-    end
-
     def zrank(key, value)
       data_type_check(key, ZSet)
       z = data[key]
@@ -915,14 +985,8 @@ module Rediska
       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
+      results = sort_keys(data[key])
+
       # Select just the keys unless we want scores
       results = results.map(&:first) unless with_scores
       results[start..stop].flatten.map(&:to_s)
@@ -1008,6 +1072,58 @@ module Rediska
       data[out].size
     end
 
+    def zscan(key, start_cursor, *args)
+      data_type_check(key, ZSet)
+      return [] unless data[key]
+
+      match = '*'
+      count = 10
+
+      if args.size.odd?
+        raise_argument_error('zscan')
+      end
+
+      if idx = args.index('MATCH')
+        match = args[idx + 1]
+      end
+
+      if idx = args.index('COUNT')
+        count = args[idx + 1]
+      end
+
+      start_cursor = start_cursor.to_i
+      data_type_check(start_cursor, Integer)
+
+      cursor = start_cursor
+      next_keys = []
+
+      sorted_keys = sort_keys(data[key])
+
+      if start_cursor + count >= sorted_keys.length
+        next_keys = sorted_keys.to_a.select { |k| File.fnmatch(match, k[0]) } [start_cursor..-1]
+        cursor = 0
+      else
+       cursor = start_cursor + count
+       next_keys = sorted_keys.to_a.select { |k| File.fnmatch(match, k[0]) } [start_cursor..cursor-1]
+      end
+
+      return "#{cursor}", next_keys.flatten.map(&:to_s)
+    end
+
+    # Originally from redis-rb
+    def zscan_each(key, *args, &block)
+      data_type_check(key, ZSet)
+      return [] unless data[key]
+
+      return to_enum(:zscan_each, key, options) unless block_given?
+      cursor = 0
+      loop do
+        cursor, values = zscan(key, cursor, options)
+        values.each(&block)
+        break if cursor == '0'
+      end
+    end
+
     private
     def raise_argument_error(command, match_string = command)
       error_message = if %w(hmset mset_odd).include?(match_string.downcase)
@@ -1064,5 +1180,16 @@ module Rediska
         (1..-number).map { data[key].to_a[rand(data[key].size)] }.flatten
       end
     end
+
+    def sort_keys(arr)
+      # Sort by score, or if scores are equal, key alphanum
+      arr.sort do |(k1, v1), (k2, v2)|
+        if v1 == v2
+          k1 <=> k2
+        else
+          v1 <=> v2
+        end
+      end
+    end
   end
 end

data/lib/rediska/transaction_commands.rb

@@ -1,5 +1,5 @@
 module Rediska
-  TRANSACTION_COMMANDS = [:discard, :exec, :multi, :watch, :unwatch]
+  TRANSACTION_COMMANDS = [:discard, :exec, :multi, :watch, :unwatch, :client]
 
   module TransactionCommands
     def self.included(klass)
@@ -46,7 +46,7 @@ module Rediska
         raise Redis::CommandError, 'ERR EXEC without MULTI'
       end
 
-      responses  = queued_commands.map do |cmd|
+      responses = queued_commands.map do |cmd|
         begin
           send(*cmd)
         rescue => e
@@ -54,8 +54,8 @@ module Rediska
         end
       end
 
-      self.queued_commands = [] # reset queued_commands
-      self.in_multi = false     # reset in_multi state
+      self.queued_commands = []
+      self.in_multi = false
 
       responses
     end

data/lib/rediska/version.rb

@@ -1,3 +1,3 @@
 module Rediska
-  VERSION = '0.3.1'.freeze
+  VERSION = '1.1.0'.freeze
 end

data/spec/redis_spec.rb

@@ -46,7 +46,7 @@ describe 'Rediska' do
     end
   end
 
-  pending 'real redis (interoperability)' do
+  context 'real redis (interoperability)' do
     before(:all) do
       Redis::Connection.drivers.pop
     end

data/spec/support/bitop.rb

@@ -9,7 +9,7 @@ shared_examples_for 'a bitwise operation' do |operator|
 
   it 'should not create destination key if nothing found' do
     expect(subject.bitop(operator, 'dest1', 'nothing_here1')).to eq(0)
-    expect(subject.exists('dest1')).to be_falsy
+    expect(subject.exists('dest1')).to eq(0)
   end
 
   it 'should accept operator as a case-insensitive symbol' do

data/spec/support/connection.rb

@@ -51,7 +51,7 @@ shared_examples 'connection' do
 
   it 'should not error with a disconnected client' do
     subject1 = Redis.new
-    subject1.client.disconnect
+    subject1.disconnect
     expect(subject1.get('key1')).to be_nil
   end
 

data/spec/support/hashes.rb

@@ -25,7 +25,7 @@ shared_examples 'hashes' do
     expect(subject.hdel('key1', 'k1')).to eq(1)
     expect(subject.hdel('key1', 'k2')).to eq(1)
 
-    expect(subject.exists('key1')).to be_falsey
+    expect(subject.exists('key1')).to eq(0)
   end
 
   it 'should convert key to a string for hset' do
@@ -122,7 +122,7 @@ shared_examples 'hashes' do
       subject.hmset('key')
     }.to raise_error(Redis::CommandError)
 
-    expect(subject.exists('key')).to be_falsey
+    expect(subject.exists('key')).to eq(0)
   end
 
   it 'rejects an insert with a key but no value' do
@@ -134,7 +134,7 @@ shared_examples 'hashes' do
       subject.hmset('key', 'foo', 3, 'bar')
     }.to raise_error(Redis::CommandError)
 
-    expect(subject.exists('key')).to be_falsey
+    expect(subject.exists('key')).to eq(0)
   end
 
   it 'should reject the wrong number of arguments' do
@@ -159,7 +159,7 @@ shared_examples 'hashes' do
 
   it 'should set the string value of a hash field' do
     expect(subject.hset('key1', 'k1', 'val1')).to be_truthy
-    expect(subject.hset('key1', 'k1', 'val1')).to be_falsey
+    expect(subject.hset('key1', 'k1', 'val1')).to eq(0)
 
     expect(subject.hget('key1', 'k1')).to eq('val1')
   end
@@ -210,4 +210,53 @@ shared_examples 'hashes' do
     subject.hset('key1', 1, 0)
     expect(subject.hincrby('key1', 1, 1)).to eq(1)
   end
+
+  describe "#hscan" do
+    it 'with no arguments and few items, returns all items' do
+      subject.hmset('hash', 'name', 'Jack', 'age', '33')
+      result = subject.hscan('hash', 0)
+
+      expect(result[0]).to eq('0')
+      expect(result[1]).to eq([['name', 'Jack'], ['age', '33']])
+    end
+
+    it 'with a count should return that number of members or more' do
+      subject.hmset('hash','a', '1', 'b', '2', 'c', '3', 'd', '4', 'e', '5', 'f', '6', 'g', '7')
+      result = subject.hscan('hash', 0, count: 3)
+      expect(result[0]).to eq('3')
+      expect(result[1]).to eq([
+        ['a', '1'],
+        ['b', '2'],
+        ['c', '3'],
+      ])
+    end
+
+    it 'returns items starting at the provided cursor' do
+      subject.hmset('hash', 'a', '1', 'b', '2', 'c', '3', 'd', '4', 'e', '5', 'f', '6', 'g', '7')
+      result = subject.hscan('hash', 2, count: 3)
+      expect(result[0]).to eq('5')
+      expect(result[1]).to eq([
+        ['c', '3'],
+        ['d', '4'],
+        ['e', '5']
+      ])
+    end
+
+    it 'with match, returns items matching the given pattern' do
+      subject.hmset('hash', 'aa', '1', 'b', '2', 'cc', '3', 'd', '4', 'ee', '5', 'f', '6', 'gg', '7')
+      result = subject.hscan('hash', 2, count: 3, match: '??')
+      expect(result[0]).to eq('5')
+      expect(result[1]).to eq([
+        ['cc', '3'],
+        ['ee', '5']
+      ])
+    end
+
+    it 'returns an empty result if the key is not found' do
+      result = subject.hscan('hash', 0)
+
+      expect(result[0]).to eq('0')
+      expect(result[1]).to eq([])
+    end
+  end
 end

data/spec/support/keys.rb

@@ -16,24 +16,14 @@ shared_examples 'keys' do
     expect(subject.get('key2')).to be_nil
   end
 
-  it 'should error deleting no keys' do
-    expect {
-      subject.del
-    }.to raise_error(Redis::CommandError)
-
-    expect {
-      subject.del []
-    }.to raise_error(Redis::CommandError)
+  it "should return true when setnx keys that don't exist" do
+    expect(subject.setnx('key1', '1')).to be_truthy
   end
 
-   it "should return true when setnx keys that don't exist" do
-     expect(subject.setnx('key1', '1')).to be_truthy
-   end
-
-   it 'should return false when setnx keys exist' do
-     subject.set('key1', '1')
-     expect(subject.setnx('key1', '1')).to be_falsey
-   end
+  it 'should return false when setnx keys exist' do
+    subject.set('key1', '1')
+    expect(subject.setnx('key1', '1')).to be_falsey
+  end
 
   it 'should return true when setting expires on keys that exist' do
     subject.set('key1', '1')
@@ -58,7 +48,7 @@ shared_examples 'keys' do
     subject.set('key1', '1')
 
     expect(subject.exists('key1')).to be_truthy
-    expect(subject.exists('key2')).to be_falsey
+    expect(subject.exists('key2')).to eq(0)
   end
 
   it "should set a key's time to live in seconds" do
@@ -123,7 +113,7 @@ shared_examples 'keys' do
     subject.set('key1', '1')
     subject.expireat('key1', Time.now.to_i)
 
-    expect(subject.exists('key1')).to be_falsey
+    expect(subject.exists('key1')).to eq(0)
   end
 
   it 'should find all keys matching the given pattern' do
@@ -387,13 +377,13 @@ shared_examples 'keys' do
 
     it 'uses nx option to only set the key if it does not already exist' do
       expect(subject.set('key1', '1', nx: true)).to be_truthy
-      expect(subject.set('key1', '2', nx: true)).to be_falsey
+      expect(subject.set('key1', '2', nx: true)).to eq(0)
 
       expect(subject.get('key1')).to eq('1')
     end
 
     it 'uses xx option to only set the key if it already exists' do
-      expect(subject.set('key2', '1', xx: true)).to be_falsey
+      expect(subject.set('key2', '1', xx: true)).to eq(0)
       subject.set('key2', '2')
       expect(subject.set('key2', '1', xx: true)).to be_truthy
 
@@ -401,13 +391,13 @@ shared_examples 'keys' do
     end
 
     it 'does not set the key if both xx and nx option are specified' do
-      expect(subject.set('key2', '1', nx: true, xx: true)).to be_falsey
+      expect(subject.set('key2', '1', nx: true, xx: true)).to eq(0)
       expect(subject.get('key2')).to be_nil
     end
 
     describe '#dump' do
       it 'returns nil for unknown key' do
-        expect(subject.exists('key1')).to be_falsey
+        expect(subject.exists('key1')).to eq(0)
         expect(subject.dump('key1')).to be_nil
       end
 
@@ -445,7 +435,7 @@ shared_examples 'keys' do
           @dumped_value = subject.dump('key1')
 
           subject.del('key1')
-          expect(subject.exists('key1')).to be_falsey
+          expect(subject.exists('key1')).to eq(0)
         end
 
         it 'restores to a new key successfully' do

data/spec/support/lists.rb

@@ -89,13 +89,18 @@ shared_examples 'lists' do
     expect(subject.llen('key1')).to eq(2)
   end
 
+  it 'should return 0 if key does not map to a list' do
+    expect(subject.exists('nonexistant')).to eq(0)
+    expect(subject.lrem('nonexistant', 0, 'value')).to eq(0)
+  end
+
   it "should remove list's key when list is empty" do
     subject.rpush('key1', 'v1')
     subject.rpush('key1', 'v2')
     subject.lrem('key1', 1, 'v1')
     subject.lrem('key1', 1, 'v2')
 
-    expect(subject.exists('key1')).to be_falsey
+    expect(subject.exists('key1')).to eq(0)
   end
 
   it 'should set the value of an element in a list by its index' do

data/spec/support/server.rb

@@ -40,12 +40,12 @@ shared_examples 'server' do
       subject.select(0)
       expect(subject.dbsize).to eq(2)
       expect(subject.exists('key1')).to be_truthy
-      expect(subject.exists('key3')).to be_falsey
+      expect(subject.exists('key3')).to eq(0)
 
       subject.select(1)
       expect(subject.dbsize).to eq(3)
       expect(subject.exists('key4')).to be_truthy
-      expect(subject.exists('key2')).to be_falsey
+      expect(subject.exists('key2')).to eq(0)
 
       subject.flushall
       expect(subject.dbsize).to eq(0)

data/spec/support/sets.rb

@@ -157,7 +157,7 @@ shared_examples 'sets' do
     subject.srem('key1', 'b')
     subject.srem('key1', 'a')
 
-    expect(subject.exists('key1')).to be_falsey
+    expect(subject.exists('key1')).to eq(0)
   end
 
   it 'should add multiple sets' do
@@ -258,4 +258,42 @@ shared_examples 'sets' do
       end
     end
   end
+
+  describe 'sscan' do
+    it 'with no arguments and few items, returns all items' do
+      subject.sadd('set', ['name', 'Jack', 'age', '33'])
+      result = subject.sscan('set', 0)
+
+      expect(result[0]).to eq('0')
+      expect(result[1]).to eq(['name', 'Jack', 'age', '33'])
+    end
+
+    it 'with a count should return that number of members or more' do
+      subject.sadd('set', ['a', '1', 'b', '2', 'c', '3', 'd', '4', 'e', '5', 'f', '6', 'g', '7'])
+      result = subject.sscan('set', 0, count: 3)
+      expect(result[0]).to eq('3')
+      expect(result[1]).to eq([ 'a', '1', 'b'])
+    end
+
+    it 'returns items starting at the provided cursor' do
+      subject.sadd('set', ['a', '1', 'b', '2', 'c', '3', 'd', '4', 'e', '5', 'f', '6', 'g', '7'])
+      result = subject.sscan('set', 2, count: 3)
+      expect(result[0]).to eq('5')
+      expect(result[1]).to eq(['b', '2', 'c'])
+    end
+
+    it 'with match, returns items matching the given pattern' do
+      subject.sadd('set', ['aa', '1', 'b', '2', 'cc', '3', 'd', '4', 'ee', '5', 'f', '6', 'gg', '7'])
+      result = subject.sscan('set', 2, count: 7, match: '??')
+      expect(result[0]).to eq('9')
+      expect(result[1]).to eq(['cc','ee'])
+    end
+
+    it 'returns an empty result if the key is not found' do
+      result = subject.sscan('set', 0)
+
+      expect(result[0]).to eq('0')
+      expect(result[1]).to eq([])
+    end
+  end
 end

data/spec/support/sorted_sets.rb

@@ -1,47 +1,4 @@
 shared_examples 'sorted sets' do
-  let(:infinity) { 1.0 / 0.0 }
-
-  it 'should add a member to a sorted set, or update its score if it already exists' do
-    expect(subject.zadd('key', 1, 'val')).to be_truthy
-    expect(subject.zscore('key', 'val')).to eq(1.0)
-
-    expect(subject.zadd('key', 2, 'val')).to be_falsey
-    expect(subject.zscore('key', 'val')).to eq(2.0)
-
-    expect(subject.zadd('key2', 'inf', 'val')).to be_truthy
-    expect(subject.zscore('key2', 'val')).to eq(infinity)
-
-    expect(subject.zadd('key3', '+inf', 'val')).to be_truthy
-    expect(subject.zscore('key3', 'val')).to eq(infinity)
-
-    expect(subject.zadd('key4', '-inf', 'val')).to be_truthy
-    expect(subject.zscore('key4', 'val')).to eq(-infinity)
-  end
-
-  it 'should return a nil score for value not in a sorted set or empty key' do
-    subject.zadd('key', 1, 'val')
-
-    expect(subject.zscore('key', 'val')).to eq(1.0)
-    expect(subject.zscore('key', 'val2')).to be_nil
-    expect(subject.zscore('key2', 'val')).to be_nil
-  end
-
-  it 'should add multiple members to a sorted set, or update its score if it already exists' do
-    expect(subject.zadd('key', [1, 'val', 2, 'val2'])).to eq(2)
-    expect(subject.zscore('key', 'val')).to eq(1)
-    expect(subject.zscore('key', 'val2')).to eq(2)
-
-    expect(subject.zadd('key', [[5, 'val'], [3, 'val3'], [4, 'val4']])).to eq(2)
-    expect(subject.zscore('key', 'val')).to eq(5)
-    expect(subject.zscore('key', 'val2')).to eq(2)
-    expect(subject.zscore('key', 'val3')).to eq(3)
-    expect(subject.zscore('key', 'val4')).to eq(4)
-
-    expect(subject.zadd('key', [[5, 'val5'], [3, 'val6']])).to eq(2)
-    expect(subject.zscore('key', 'val5')).to eq(5)
-    expect(subject.zscore('key', 'val6')).to eq(3)
-  end
-
   it 'should error with wrong number of arguments when adding members' do
     expect {
       subject.zadd('key')
@@ -64,14 +21,6 @@ shared_examples 'sorted sets' do
     }.to raise_error(Redis::CommandError)
   end
 
-  it 'should allow floats as scores when adding or updating' do
-    expect(subject.zadd('key', 4.321, 'val')).to be_truthy
-    expect(subject.zscore('key', 'val')).to eq(4.321)
-
-    expect(subject.zadd('key', 54.3210, 'val')).to be_falsey
-    expect(subject.zscore('key', 'val')).to eq(54.321)
-  end
-
   it 'should remove members from sorted sets' do
     expect(subject.zrem('key', 'val')).to be_falsey
     expect(subject.zadd('key', 1, 'val')).to be_truthy
@@ -92,7 +41,7 @@ shared_examples 'sorted sets' do
   it "should remove sorted set's key when it is empty" do
     subject.zadd('key', 1, 'val')
     subject.zrem('key', 'val')
-    expect(subject.exists('key')).to be_falsey
+    expect(subject.exists('key')).to eq(0)
   end
 
   it 'should get the number of members in a sorted set' do
@@ -111,26 +60,6 @@ shared_examples 'sorted sets' do
     expect(subject.zcount('key', 2, 3)).to eq(2)
   end
 
-  it 'should increment the score of a member in a sorted set' do
-    subject.zadd('key', 1, 'val1')
-    expect(subject.zincrby('key', 2, 'val1')).to eq(3)
-    expect(subject.zscore('key', 'val1')).to eq(3)
-  end
-
-  it 'initializes the sorted set if the key wasnt already set' do
-    expect(subject.zincrby('key', 1, 'val1')).to eq(1)
-  end
-
-  it 'should convert the key to a string for zscore' do
-    subject.zadd('key', 1, 1)
-    expect(subject.zscore('key', 1)).to eq(1)
-  end
-
-  it 'should handle infinity values when incrementing a sorted set key' do
-    expect(subject.zincrby('bar', '+inf', 's2')).to eq(infinity)
-    expect(subject.zincrby('bar', '-inf', 's1')).to eq(-infinity)
-  end
-
   it 'should return a range of members in a sorted set, by index' do
     subject.zadd('key', 1, 'one')
     subject.zadd('key', 2, 'two')
@@ -318,17 +247,6 @@ shared_examples 'sorted sets' do
       expect(subject.zcard('key')).to eq(1)
     end
 
-    it 'should remove items by score with infinity' do # Issue #50
-      subject.zadd('key', 10.0, 'one')
-      subject.zadd('key', 20.0, 'two')
-      subject.zadd('key', 30.0, 'three')
-      expect(subject.zremrangebyscore('key', '-inf', '+inf')).to eq(3)
-      expect(subject.zcard('key')).to eq(0)
-      expect(subject.zscore('key', 'one')).to be_nil
-      expect(subject.zscore('key', 'two')).to be_nil
-      expect(subject.zscore('key', 'three')).to be_nil
-    end
-
     it 'should return 0 if the key did not exist' do
       expect(subject.zremrangebyscore('key', 0, 2)).to eq(0)
     end
@@ -442,10 +360,44 @@ shared_examples 'sorted sets' do
     end
   end
 
-  it 'zrem should remove members add by zadd' do
-    subject.zadd('key1', 1, 3)
-    subject.zrem('key1', 3)
-    expect(subject.zscore('key1', 3)).to be_nil
+  describe '#zscan' do
+    before do
+      50.times { |x| subject.zadd('key', x, "key #{x}") }
+    end
+
+    it 'with no arguments should return 10 numbers in ascending order' do
+      result = subject.zscan('key', 0)[1]
+      expect(result).to eq(result.sort { |x, y| x[1] <=> y[1] })
+      expect(result.count).to eq(10)
+    end
+
+    it 'with a count should return that number of members' do
+      expect(subject.zscan('key', 0, count: 2)).to eq(['2', [['key 0', 0.0], ['key 1', 1.0]]])
+    end
+
+    it 'with a count greater than the number of members, returns all the members in asc order' do
+      result = subject.zscan('key', 0, count: 1000)[1]
+      expect(result).to eq(result.sort { |x, y| x[1] <=> y[1] })
+      expect(result.size).to eq(50)
+    end
+
+    it 'with match, should return key-values where the key matches' do
+      subject.zadd('key', 1.0, 'blah')
+      subject.zadd('key', 2.0, 'bluh')
+      result = subject.zscan('key', 0, count: 100, match: 'key*')[1]
+      expect(result).to_not include(['blah', 1.0])
+      expect(result).to_not include(['bluh', 2.0])
+    end
+  end
+
+  describe '#zscan_each' do
+    before do
+      50.times { |x| subject.zadd('key', x, "key #{x}") }
+    end
+
+    it 'enumerates over the items in the sorted set' do
+      expect(subject.zscan_each('key').to_a).to eq(subject.zscan('key', 0, count: 50)[1])
+    end
   end
 
   #it 'should remove all members in a sorted set within the given indexes'

data/spec/support/upcase_method_names.rb

@@ -2,8 +2,4 @@ shared_examples 'upcase method names' do
   it '#ZCOUNT' do
     expect(subject.ZCOUNT('key', 2, 3)).to eq(subject.zcount('key', 2, 3))
   end
-
-  it '#ZSCORE' do
-    expect(subject.ZSCORE('key', 2)).to eq(subject.zscore('key', 2))
-  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rediska
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 1.1.0
 platform: ruby
 authors:
 - Leonid Beder
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-07-30 00:00:00.000000000 Z
+date: 2021-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -134,7 +134,7 @@ homepage: https://github.com/lbeder/rediska
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -149,9 +149,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.6
-signing_key: 
+rubygems_version: 3.1.6
+signing_key:
 specification_version: 4
 summary: A light-weighted redis driver for testing, development, and minimal environments
 test_files:
@@ -172,4 +171,3 @@ test_files:
 - spec/support/strings.rb
 - spec/support/transactions.rb
 - spec/support/upcase_method_names.rb
-has_rdoc: