Module: MockRedis::SetMethods

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

Instance Method Summary collapse

Instance Method Details

#sadd(key, *members) ⇒ Object 



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

def sadd(key, *members)
  members_class = members.class
  members = Array(members).flatten.map(&:to_s)
  assert_type(key, *members)
  assert_has_args(members, 'sadd')

  with_set_at(key) do |s|
    size_before = s.size
    if members.size > 1
      members.reverse_each { |m| s << m }
      s.size - size_before
    else
      added = !!s.add?(members.first)
      if members_class == Array
        s.size - size_before
      else
        added ? 1 : 0
      end
    end
  end
end

#sadd?(key, members) ⇒ Boolean

Returns:

  • (Boolean) 


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

def sadd?(key, members)
  res = sadd(key, members)
  res.is_a?(Numeric) ? res > 0 : res
end

#scard(key) ⇒ Object 



36
37
38
39
 
# File 'lib/mock_redis/set_methods.rb', line 36

def scard(key)
  assert_type(key)
  with_set_at(key, &:length)
end

#sdiff(*keys) ⇒ Object 



41
42
43
44
 
# File 'lib/mock_redis/set_methods.rb', line 41

def sdiff(*keys)
  assert_has_args(keys, 'sdiff')
  with_sets_at(*keys) { |*sets| sets.reduce(&:-) }.to_a
end

#sdiffstore(destination, *keys) ⇒ Object 



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

def sdiffstore(destination, *keys)
  assert_type(destination, *keys)
  assert_has_args(keys, 'sdiffstore')
  with_set_at(destination) do |set|
    set.replace(sdiff(*keys))
  end
  scard(destination)
end

#sinter(*keys) ⇒ Object 



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

def sinter(*keys)
  assert_has_args(keys, 'sinter')

  with_sets_at(*keys) do |*sets|
    sets.reduce(&:&).to_a
  end
end

#sinterstore(destination, *keys) ⇒ Object 



63
64
65
66
67
68
69
70
 
# File 'lib/mock_redis/set_methods.rb', line 63

def sinterstore(destination, *keys)
  assert_type(destination, *keys)
  assert_has_args(keys, 'sinterstore')
  with_set_at(destination) do |set|
    set.replace(sinter(*keys))
  end
  scard(destination)
end

#sismember(key, member) ⇒ Object 



72
73
74
75
 
# File 'lib/mock_redis/set_methods.rb', line 72

def sismember(key, member)
  assert_type(key, member)
  with_set_at(key) { |s| s.include?(member.to_s) }
end

#smembers(key) ⇒ Object 



86
87
88
89
 
# File 'lib/mock_redis/set_methods.rb', line 86

def smembers(key)
  assert_type(key)
  with_set_at(key, &:to_a).map(&:dup).reverse
end

#smismember(key, *members) ⇒ Object 



77
78
79
80
81
82
83
84
 
# File 'lib/mock_redis/set_methods.rb', line 77

def smismember(key, *members)
  members.flatten!

  assert_type(key, *members)
  with_set_at(key) do |set|
    members.map { |m| set.include?(m.to_s) }
  end
end

#smove(src, dest, member) ⇒ Object 



91
92
93
94
95
96
97
98
99
100
101
102
 
# File 'lib/mock_redis/set_methods.rb', line 91

def smove(src, dest, member)
  member = member.to_s

  with_sets_at(src, dest) do |src_set, dest_set|
    if src_set.delete?(member)
      dest_set.add(member)
      true
    else
      false
    end
  end
end

#spop(key, count = nil) ⇒ Object 



104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
 
# File 'lib/mock_redis/set_methods.rb', line 104

def spop(key, count = nil)
  assert_type(key)
  with_set_at(key) do |set|
    if count.nil?
      member = set.first
      set.delete(member)
      member
    else
      members = []
      count.times do
        member = set.first
        break if member.nil?
        set.delete(member)
        members << member
      end
      members
    end
  end
end

#srandmember(key, count = nil) ⇒ Object 



124
125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/mock_redis/set_methods.rb', line 124

def srandmember(key, count = nil)
  assert_type(key)
  members = with_set_at(key, &:to_a)
  if count
    if count > 0
      members.sample(count)
    else
      Array.new(count.abs) { members[rand(members.length)] }
    end
  else
    members[rand(members.length)]
  end
end

#srem(key, *members) ⇒ Object 



138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
 
# File 'lib/mock_redis/set_methods.rb', line 138

def srem(key, *members)
  members = members.flatten.uniq
  assert_type(key, *members)

  with_set_at(key) do |s|
    if members.is_a?(Array)
      orig_size = s.size
      members = members.map(&:to_s)
      s.delete_if { |m| members.include?(m) }
      orig_size - s.size
    else
      !!s.delete?(members.to_s)
    end
  end
end

#srem?(key, members) ⇒ Boolean

Returns:

  • (Boolean) 


154
155
156
157
 
# File 'lib/mock_redis/set_methods.rb', line 154

def srem?(key, members)
  res = srem(key, members)
  res.is_a?(Numeric) ? res > 0 : res
end

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



159
160
161
 
# File 'lib/mock_redis/set_methods.rb', line 159

def sscan(key, cursor, opts = {})
  common_scan(smembers(key), cursor, opts)
end

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



163
164
165
166
167
168
169
170
171
 
# File 'lib/mock_redis/set_methods.rb', line 163

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

#sunion(*keys) ⇒ Object 



173
174
175
176
 
# File 'lib/mock_redis/set_methods.rb', line 173

def sunion(*keys)
  assert_has_args(keys, 'sunion')
  with_sets_at(*keys) { |*sets| sets.reduce(&:+).to_a }
end

#sunionstore(destination, *keys) ⇒ Object 



178
179
180
181
182
183
184
 
# File 'lib/mock_redis/set_methods.rb', line 178

def sunionstore(destination, *keys)
  assert_has_args(keys, 'sunionstore')
  with_set_at(destination) do |dest_set|
    dest_set.replace(sunion(*keys))
  end
  scard(destination)
end