Module: MockRedis::HashMethods

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

Instance Method Summary collapse

Instance Method Details

#hdel(key, *fields) ⇒ Object 



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

def hdel(key, *fields)
  assert_type(key)

  with_hash_at(key) do |hash|
    orig_size = hash.size
    fields = Array(fields).flatten.map(&:to_s)

    assert_type(*fields)

    if fields.empty?
      raise Error.command_error("ERR wrong number of arguments for 'hdel' command", self)
    end

    hash.delete_if { |k, _v| fields.include?(k) }
    orig_size - hash.size
  end
end

#hexists(key, field) ⇒ Object 



28
29
30
31
32
 
# File 'lib/mock_redis/hash_methods.rb', line 28

def hexists(key, field)
  assert_type(key, field)

  with_hash_at(key) { |h| h.key?(field.to_s) }
end

#hget(key, field) ⇒ Object 



34
35
36
37
38
 
# File 'lib/mock_redis/hash_methods.rb', line 34

def hget(key, field)
  assert_type(key, field)

  with_hash_at(key) { |h| h[field.to_s] }
end

#hgetall(key) ⇒ Object 



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

def hgetall(key)
  assert_type(key)

  with_hash_at(key) { |h| h }
end

#hincrby(key, field, increment) ⇒ Object 



46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/mock_redis/hash_methods.rb', line 46

def hincrby(key, field, increment)
  assert_type(key, field)

  with_hash_at(key) do |hash|
    field = field.to_s
    increment = Integer(increment)
    unless can_incr?(data[key][field])
      raise Error.command_error('ERR hash value is not an integer', self)
    end

    new_value = (hash[field] || '0').to_i + increment.to_i
    hash[field] = new_value.to_s
    new_value
  end
end

#hincrbyfloat(key, field, increment) ⇒ Object 



62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/mock_redis/hash_methods.rb', line 62

def hincrbyfloat(key, field, increment)
  assert_type(key, field)

  with_hash_at(key) do |hash|
    field = field.to_s
    increment = Float(increment)
    unless can_incr_float?(data[key][field])
      raise Error.command_error('ERR hash value is not a float', self)
    end

    new_value = (hash[field] || '0').to_f + increment.to_f
    new_value = new_value.to_i if new_value % 1 == 0
    hash[field] = new_value.to_s
    new_value
  end
end

#hkeys(key) ⇒ Object 



79
80
81
82
83
 
# File 'lib/mock_redis/hash_methods.rb', line 79

def hkeys(key)
  assert_type(key)

  with_hash_at(key, &:keys)
end

#hlen(key) ⇒ Object 



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

def hlen(key)
  assert_type(key)

  hkeys(key).length
end

#hmget(key, *fields) ⇒ Object 



91
92
93
94
95
96
97
 
# File 'lib/mock_redis/hash_methods.rb', line 91

def hmget(key, *fields)
  fields.flatten!

  assert_type(key, *fields)
  assert_has_args(fields, 'hmget')
  fields.map { |f| hget(key, f) }
end

#hmset(key, *kvpairs) ⇒ Object 



110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
 
# File 'lib/mock_redis/hash_methods.rb', line 110

def hmset(key, *kvpairs)
  if key.is_a? Array
    err_msg = 'ERR wrong number of arguments for \'hmset\' command'
    kvpairs = key[1..]
    key = key[0]
  end

  kvpairs.flatten!

  assert_type(key, *kvpairs)
  assert_has_args(kvpairs, 'hmset')

  if kvpairs.length.odd?
    raise Error.command_error(
      err_msg || "ERR wrong number of arguments for 'hmset' command",
      self
    )
  end

  kvpairs.each_slice(2) do |(k, v)|
    hset(key, k, v)
  end
  'OK'
end

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



147
148
149
150
151
152
 
# File 'lib/mock_redis/hash_methods.rb', line 147

def hscan(key, cursor, opts = {})
  assert_type(key, cursor)

  opts = opts.merge(key: lambda { |x| x[0] })
  common_scan(hgetall(key).to_a, cursor, opts)
end

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



154
155
156
157
158
159
160
161
162
163
164
 
# File 'lib/mock_redis/hash_methods.rb', line 154

def hscan_each(key, opts = {}, &block)
  assert_type(key)

  return to_enum(:hscan_each, key, opts) unless block_given?
  cursor = 0
  loop do
    cursor, values = hscan(key, cursor, opts)
    values.each(&block)
    break if cursor == '0'
  end
end

#hset(key, *args) ⇒ Object 



166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
 
# File 'lib/mock_redis/hash_methods.rb', line 166

def hset(key, *args)
  added = 0
  args.flatten!(1)
  assert_type(key)

  with_hash_at(key) do |hash|
    if args.length == 1 && args[0].is_a?(Hash)
      args = args[0].to_a.flatten
    end

    assert_type(*args)

    args.each_slice(2) do |field, value|
      added += 1 unless hash.key?(field.to_s)
      hash[field.to_s] = value.to_s
    end
  end
  added
end

#hsetnx(key, field, value) ⇒ Object 



186
187
188
189
190
191
192
193
194
 
# File 'lib/mock_redis/hash_methods.rb', line 186

def hsetnx(key, field, value)
  assert_type(key, field, value)
  if hget(key, field)
    false
  else
    hset(key, field, value)
    true
  end
end

#hvals(key) ⇒ Object 



196
197
198
199
200
 
# File 'lib/mock_redis/hash_methods.rb', line 196

def hvals(key)
  assert_type(key)

  with_hash_at(key, &:values)
end

#mapped_hmget(key, *fields) ⇒ Object 



99
100
101
102
103
104
105
106
107
108
 
# File 'lib/mock_redis/hash_methods.rb', line 99

def mapped_hmget(key, *fields)
  fields.flatten!

  reply = hmget(key, *fields)
  if reply.is_a?(Array)
    Hash[fields.zip(reply)]
  else
    reply
  end
end

#mapped_hmset(key, hash) ⇒ Object 



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

def mapped_hmset(key, hash)
  kvpairs = hash.flatten

  assert_type(key, *kvpairs)
  assert_has_args(kvpairs, 'hmset')
  if kvpairs.length.odd?
    raise Error.command_error("ERR wrong number of arguments for 'hmset' command", self)
  end

  hmset(key, *kvpairs)
end