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)
    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
43
 
# File 'lib/mock_redis/zset_methods.rb', line 36

def zcount(key, min, max)
  assert_scorey(min, 'ERR min or max is not a float') unless min == '-inf'
  assert_scorey(max, 'ERR min or max is not a float') unless max == '+inf'

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

#zincrby(key, increment, member) ⇒ Object 



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

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 



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

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 



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

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 



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

def zrangebyscore(key, min, max, options={})
  assert_scorey(min, 'ERR min or max is not a float') unless min == '-inf'
  assert_scorey(max, 'ERR min or max is not a float') unless max == '+inf'

  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 



79
80
81
 
# File 'lib/mock_redis/zset_methods.rb', line 79

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

#zrem(key, *args) ⇒ Object 



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

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 



103
104
105
106
107
 
# File 'lib/mock_redis/zset_methods.rb', line 103

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

#zremrangebyscore(key, min, max) ⇒ Object 



109
110
111
112
113
114
115
116
 
# File 'lib/mock_redis/zset_methods.rb', line 109

def zremrangebyscore(key, min, max)
  assert_scorey(min, 'ERR min or max is not a float') unless min == '-inf'
  assert_scorey(max, 'ERR min or max is not a float') unless max == '+inf'

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

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



97
98
99
100
101
 
# File 'lib/mock_redis/zset_methods.rb', line 97

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 



118
119
120
121
122
123
124
125
126
127
128
129
 
# File 'lib/mock_redis/zset_methods.rb', line 118

def zrevrangebyscore(key, max, min, options={})
  assert_scorey(min, 'ERR min or max is not a float') unless min == '-inf'
  assert_scorey(max, 'ERR min or max is not a float') unless max == '+inf'

  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 



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

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

#zscore(key, member) ⇒ Object 



135
136
137
138
139
140
 
# File 'lib/mock_redis/zset_methods.rb', line 135

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 



142
143
144
145
146
147
 
# File 'lib/mock_redis/zset_methods.rb', line 142

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

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