Module: MockRedis::ZsetMethods

Includes:
Assertions, UtilityMethods
Included in:
Database
Defined in:
lib/mock_redis/zset_methods.rb

Instance Method Summary collapse

Instance Method Details

#zadd(key, *args) ⇒ Object 



10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
 
# File 'lib/mock_redis/zset_methods.rb', line 10

def zadd(key, *args)
  if args.size == 1 && args[0].is_a?(Array)
    args = args.first
    assert_has_args(args, 'zadd')

    args = args.each_slice(2).to_a unless args.first.is_a?(Array)
    retval = args.map(&:last).map { |member| !!zscore(key, member.to_s) }.count(false)
    with_zset_at(key) do |z|
      args.each { |score, member| z.add(score, member.to_s) }
    end
  elsif args.size == 2
    score, member = args
    assert_scorey(score) unless score =~ /(\+|\-)inf/
    retval = !zscore(key, member)
    with_zset_at(key) { |z| z.add(score, member.to_s) }
  else
    raise Redis::CommandError, 'ERR wrong number of arguments'
  end

  retval
end

#zcard(key) ⇒ Object 



32
33
34
 
# File 'lib/mock_redis/zset_methods.rb', line 32

def zcard(key)
  with_zset_at(key, &:size)
end

#zcount(key, min, max) ⇒ Object 



36
37
38
39
40
41
42
 
# File 'lib/mock_redis/zset_methods.rb', line 36

def zcount(key, min, max)
  assert_range_args(min, max)

  with_zset_at(key) do |zset|
    zset.in_range(min, max).size
  end
end

#zincrby(key, increment, member) ⇒ Object 



44
45
46
47
48
49
50
51
52
53
 
# File 'lib/mock_redis/zset_methods.rb', line 44

def zincrby(key, increment, member)
  assert_scorey(increment)
  member = member.to_s
  with_zset_at(key) do |z|
    old_score = z.include?(member) ? z.score(member) : 0
    new_score = old_score + increment
    z.add(new_score, member)
    new_score.to_f
  end
end

#zinterstore(destination, keys, options = {}) ⇒ Object 



55
56
57
58
59
60
 
# File 'lib/mock_redis/zset_methods.rb', line 55

def zinterstore(destination, keys, options = {})
  assert_has_args(keys, 'zinterstore')

  data[destination] = combine_weighted_zsets(keys, options, :intersection)
  zcard(destination)
end

#zrange(key, start, stop, options = {}) ⇒ Object 



62
63
64
65
66
 
# File 'lib/mock_redis/zset_methods.rb', line 62

def zrange(key, start, stop, options = {})
  with_zset_at(key) do |z|
    to_response(z.sorted[start.to_i..stop.to_i] || [], options)
  end
end

#zrangebyscore(key, min, max, options = {}) ⇒ Object 



68
69
70
71
72
73
74
75
 
# File 'lib/mock_redis/zset_methods.rb', line 68

def zrangebyscore(key, min, max, options = {})
  assert_range_args(min, max)

  with_zset_at(key) do |zset|
    all_results = zset.in_range(min, max)
    to_response(apply_limit(all_results, options[:limit]), options)
  end
end

#zrank(key, member) ⇒ Object 



77
78
79
 
# File 'lib/mock_redis/zset_methods.rb', line 77

def zrank(key, member)
  with_zset_at(key) { |z| z.sorted_members.index(member.to_s) }
end

#zrem(key, *args) ⇒ Object 



81
82
83
84
85
86
87
88
89
90
91
92
93
 
# File 'lib/mock_redis/zset_methods.rb', line 81

def zrem(key, *args)
  if !args.first.is_a?(Array)
    retval = with_zset_at(key) { |z| !!z.delete?(args.first.to_s) }
  else
    args = args.first
    retval = args.map { |member| !!zscore(key, member.to_s) }.count(true)
    with_zset_at(key) do |z|
      args.each { |member| z.delete?(member) }
    end
  end

  retval
end

#zremrangebyrank(key, start, stop) ⇒ Object 



101
102
103
104
105
 
# File 'lib/mock_redis/zset_methods.rb', line 101

def zremrangebyrank(key, start, stop)
  zrange(key, start, stop).
    each { |member| zrem(key, member) }.
    size
end

#zremrangebyscore(key, min, max) ⇒ Object 



107
108
109
110
111
112
113
 
# File 'lib/mock_redis/zset_methods.rb', line 107

def zremrangebyscore(key, min, max)
  assert_range_args(min, max)

  zrangebyscore(key, min, max).
    each { |member| zrem(key, member) }.
    size
end

#zrevrange(key, start, stop, options = {}) ⇒ Object 



95
96
97
98
99
 
# File 'lib/mock_redis/zset_methods.rb', line 95

def zrevrange(key, start, stop, options = {})
  with_zset_at(key) do |z|
    to_response(z.sorted.reverse[start..stop] || [], options)
  end
end

#zrevrangebyscore(key, max, min, options = {}) ⇒ Object 



115
116
117
118
119
120
121
122
123
124
125
 
# File 'lib/mock_redis/zset_methods.rb', line 115

def zrevrangebyscore(key, max, min, options = {})
  assert_range_args(min, max)

  with_zset_at(key) do |zset|
    to_response(
      apply_limit(
        zset.in_range(min, max).reverse,
        options[:limit]),
      options)
  end
end

#zrevrank(key, member) ⇒ Object 



127
128
129
 
# File 'lib/mock_redis/zset_methods.rb', line 127

def zrevrank(key, member)
  with_zset_at(key) { |z| z.sorted_members.reverse.index(member.to_s) }
end

#zscan(key, cursor, opts = {}) ⇒ Object 



131
132
133
134
 
# File 'lib/mock_redis/zset_methods.rb', line 131

def zscan(key, cursor, opts = {})
  opts = opts.merge(key: lambda { |x| x[0] })
  common_scan(zrange(key, 0, -1, withscores: true), cursor, opts)
end

#zscan_each(key, opts = {}, &block) ⇒ Object 



136
137
138
139
140
141
142
143
144
 
# File 'lib/mock_redis/zset_methods.rb', line 136

def zscan_each(key, opts = {}, &block)
  return to_enum(:zscan_each, key, opts) unless block_given?
  cursor = 0
  loop do
    cursor, values = zscan(key, cursor, opts)
    values.each(&block)
    break if cursor == '0'
  end
end

#zscore(key, member) ⇒ Object 



146
147
148
149
150
151
 
# File 'lib/mock_redis/zset_methods.rb', line 146

def zscore(key, member)
  with_zset_at(key) do |z|
    score = z.score(member.to_s)
    score.to_f if score
  end
end

#zunionstore(destination, keys, options = {}) ⇒ Object 



153
154
155
156
157
158
 
# File 'lib/mock_redis/zset_methods.rb', line 153

def zunionstore(destination, keys, options = {})
  assert_has_args(keys, 'zunionstore')

  data[destination] = combine_weighted_zsets(keys, options, :union)
  zcard(destination)
end