Module: FakeRedis::Redis::SetsMethods

Included in:
FakeRedis::Redis
Defined in:
lib/fakeredis/sets.rb

Instance Method Summary collapse

Instance Method Details

#sadd(key, value) ⇒ Object 



4
5
6
7
8
9
10
 
# File 'lib/fakeredis/sets.rb', line 4

def sadd(key, value)
  fail_unless_set(key)
  case set = @data[key]
    when nil then @data[key] = Set.new([value.to_s])
    when Set then set.add(value.to_s)
  end
end

#scard(key) ⇒ Object 



12
13
14
15
16
17
18
 
# File 'lib/fakeredis/sets.rb', line 12

def scard(key)
  fail_unless_set(key)
  case set = @data[key]
    when nil then 0
    when Set then set.size
  end
end

#sdiff(key1, *keys) ⇒ Object 



20
21
22
23
24
25
26
 
# File 'lib/fakeredis/sets.rb', line 20

def sdiff(key1, *keys)
  [key1, *keys].each { |k| fail_unless_set(k) }
  keys = keys.map { |k| @data[k] || Set.new }
  keys.inject(@data[key1]) do |memo, set|
    memo - set
  end.to_a
end

#sdiffstore(destination, key1, *keys) ⇒ Object 



28
29
30
31
32
 
# File 'lib/fakeredis/sets.rb', line 28

def sdiffstore(destination, key1, *keys)
  fail_unless_set(destination)
  result = sdiff(key1, *keys)
  @data[destination] = Set.new(result)
end

#sinter(*keys) ⇒ Object 



34
35
36
37
38
39
40
41
 
# File 'lib/fakeredis/sets.rb', line 34

def sinter(*keys)
  keys.each { |k| fail_unless_set(k) }
  return Set.new if keys.any? { |k| @data[k].nil? }
  keys = keys.map { |k| @data[k] || Set.new }
  keys.inject do |set, key|
    set & key
  end.to_a
end

#sinterstore(destination, *keys) ⇒ Object 



43
44
45
46
47
 
# File 'lib/fakeredis/sets.rb', line 43

def sinterstore(destination, *keys)
  fail_unless_set(destination)
  result = sinter(*keys)
  @data[destination] = Set.new(result)
end

#sismember(key, value) ⇒ Object 



49
50
51
52
53
54
55
 
# File 'lib/fakeredis/sets.rb', line 49

def sismember(key, value)
  fail_unless_set(key)
  case set = @data[key]
    when nil then false
    when Set then set.include?(value.to_s)
  end
end

#smembers(key) ⇒ Object 



57
58
59
60
61
62
63
 
# File 'lib/fakeredis/sets.rb', line 57

def smembers(key)
  fail_unless_set(key)
  case set = @data[key]
    when nil then []
    when Set then set.to_a.reverse
  end
end

#smove(source, destination, value) ⇒ Object 



65
66
67
68
69
70
 
# File 'lib/fakeredis/sets.rb', line 65

def smove(source, destination, value)
  fail_unless_set(destination)
  if elem = self.srem(source, value)
    self.sadd(destination, value)
  end
end

#spop(key) ⇒ Object 



72
73
74
75
76
77
 
# File 'lib/fakeredis/sets.rb', line 72

def spop(key)
  fail_unless_set(key)
  elem = srandmember(key)
  srem(key, elem)
  elem
end

#srandmember(key) ⇒ Object 



79
80
81
82
83
84
85
 
# File 'lib/fakeredis/sets.rb', line 79

def srandmember(key)
  fail_unless_set(key)
  case set = @data[key]
    when nil then nil
    when Set then set.to_a[rand(set.size)]
  end
end

#srem(key, value) ⇒ Object 



87
88
89
90
91
92
93
 
# File 'lib/fakeredis/sets.rb', line 87

def srem(key, value)
  fail_unless_set(key)
  case set = @data[key]
    when nil then return
    when Set then set.delete(value.to_s)
  end
end

#sunion(*keys) ⇒ Object 



95
96
97
98
99
100
101
 
# File 'lib/fakeredis/sets.rb', line 95

def sunion(*keys)
  keys.each { |k| fail_unless_set(k) }
  keys = keys.map { |k| @data[k] || Set.new }
  keys.inject(Set.new) do |set, key|
    set | key
  end.to_a
end

#sunionstore(destination, *keys) ⇒ Object 



103
104
105
106
107
 
# File 'lib/fakeredis/sets.rb', line 103

def sunionstore(destination, *keys)
  fail_unless_set(destination)
  result = sunion(*keys)
  @data[destination] = Set.new(result)
end