Class: STRC

Inherits:
Object
  • Object
show all
Defined in:
lib/strc.rb

Constant Summary collapse

Exception = 
Class.new(StandardError)

Instance Method Summary collapse

Constructor Details

#initialize ⇒ STRC

Returns a new instance of STRC.



6
7
8
 
# File 'lib/strc.rb', line 6

def initialize
	@dict = {}
end

Instance Method Details

#append(key, value) ⇒ Object

Append a value to a key



31
32
33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/strc.rb', line 31

def append(key, value)
	if exists(key)
		item = get(key)
		if item.class == String and value.class == String
			set(key, item + value)
		else
			raise STRC::Exception.new "ERR Operation against a key holding the wrong kind of value"
		end
	else
		set(key, value)
	end
	return get(key).length
end

#decr(key) ⇒ Object

Decrement an integer



46
47
48
 
# File 'lib/strc.rb', line 46

def decr(key)
	decrby(key, 1)
end

#decrby(key, decrement) ⇒ Object

Decrement an integer by a certain amount



51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/strc.rb', line 51

def decrby(key, decrement)
	unless exists(key)
		set(key, 0)
	end
	value = get(key)
	if value.class == Fixnum
		set(key, value - decrement)
	else
		raise STRC::Exception.new "ERR Operation against a key holding the wrong kind of value"
	end
	get(key)
end

#del(*keys) ⇒ Object

Delete a key



86
87
88
89
90
91
 
# File 'lib/strc.rb', line 86

def del(*keys)
	keys.each do |key|
		@dict.delete(key)
	end
	return keys.length
end

#exists(key) ⇒ Object

Returns if key exists



94
95
96
 
# File 'lib/strc.rb', line 94

def exists(key)
	@dict.has_key?(key)
end

#get(key) ⇒ Object

Get the value for the given key



26
27
28
 
# File 'lib/strc.rb', line 26

def get(key)
	@dict[key]
end

#hdel(key, *fields) ⇒ Object

Deletes fields from hash



399
400
401
402
403
404
405
406
407
408
409
 
# File 'lib/strc.rb', line 399

def hdel(key, *fields)
	hash = get_h(key)
	deleted = 0
	fields.each do |field|
		unless hash.delete(field).nil?
			deleted += 1
		end
	end
	set(key, hash)
	return deleted
end

#hexists(key, field) ⇒ Object

Returns whether or not the field exists in key



412
413
414
 
# File 'lib/strc.rb', line 412

def hexists(key, field)
	get_h(key).has_key?(field)
end

#hget(key, field) ⇒ Object

Get value at field in hash at key



394
395
396
 
# File 'lib/strc.rb', line 394

def hget(key, field)
	get_h(key)[field]
end

#hgetall(key) ⇒ Object

Returns an array of all fields and values in hash



417
418
419
 
# File 'lib/strc.rb', line 417

def hgetall(key)
	get_h(key).flatten
end

#hkeys(key) ⇒ Object

Returns array of all keys in hash at key



422
423
424
 
# File 'lib/strc.rb', line 422

def hkeys(key)
	get_h(key).keys
end

#hlen(key) ⇒ Object

Returns number of fields in the hash



432
433
434
 
# File 'lib/strc.rb', line 432

def hlen(key)
	get_h(key).length
end

#hset(key, field, value) ⇒ Object

Set file in hash stored at key to value.



378
379
380
381
382
 
# File 'lib/strc.rb', line 378

def hset(key, field, value)
	hash = get_h(key)
	hash[field] = value
	set(key, hash)
end

#hsetnx(key, field, value) ⇒ Object

Sets field in key only if it doesn’t exist



385
386
387
388
389
390
391
 
# File 'lib/strc.rb', line 385

def hsetnx(key, field, value)
	unless hexists(key, field)
		hset(key, field, value)
		return true
	end
	return false
end

#hvals(key) ⇒ Object

Returns array of all values in hash at key



427
428
429
 
# File 'lib/strc.rb', line 427

def hvals(key)
	get_h(key).values
end

#incr(key) ⇒ Object

Increment an integer



65
66
67
 
# File 'lib/strc.rb', line 65

def incr(key)
	incrby(key, 1)
end

#incrby(key, increment) ⇒ Object

Increment an integer by a certain amount



70
71
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/strc.rb', line 70

def incrby(key, increment)
	unless exists(key)
		set(key, 0)
	end
	value = get(key)
	if value.class == Fixnum
		set(key, value + increment)
	else
		raise STRC::Exception.new "ERR Operation against a key holding the wrong kind of value"
	end
	get(key)
end

#lindex(key, index) ⇒ Object

Get an element from a list by its index



339
340
341
 
# File 'lib/strc.rb', line 339

def lindex(key, index)
	get_l(key)[index]
end

#llen(key) ⇒ Object

Returns length of list



288
289
290
 
# File 'lib/strc.rb', line 288

def llen(key)
	get_l(key).length
end

#lpop(key) ⇒ Object

Remove and get the first element in a list



331
332
333
334
335
336
 
# File 'lib/strc.rb', line 331

def lpop(key)
	list = get_l(key)
	element = list.shift
	set(key, list)
	return element
end

#lpush(key, *values) ⇒ Object

Prepend values to a list



316
317
318
319
320
321
 
# File 'lib/strc.rb', line 316

def lpush(key, *values)
	list = get_l(key)
	list = values + list
	set(key, list)
	return list.length
end

#lpushx(key, *values) ⇒ Object

LPUSH if the list exists



324
325
326
327
328
 
# File 'lib/strc.rb', line 324

def lpushx(key, *values)
	if exists(key)
		lpush(key, *values)
	end
end

#lrange(key, start, stop) ⇒ Object

Returns elements from key in the given range



282
283
284
285
 
# File 'lib/strc.rb', line 282

def lrange(key, start, stop)
	list = get_l(key)[start..stop]
	return list.nil? ? [] : list
end

#lset(key, index, value) ⇒ Object

Set value for an element at index in a list



344
345
346
347
348
 
# File 'lib/strc.rb', line 344

def lset(key, index, value)
	list = get_l(key)
	list[index] = value
	set(key, list)
end

#ltrim(key, start, stop) ⇒ Object

Trim a list to the specified range



351
352
353
 
# File 'lib/strc.rb', line 351

def ltrim(key, start, stop)
	set(key, lrange(key, start, stop))
end

#randomkey ⇒ Object

Returns a random key



99
100
101
 
# File 'lib/strc.rb', line 99

def randomkey
	@dict.keys.sample
end

#rename(key, newkey) ⇒ Object

Renames a key. Overwrites destination.



104
105
106
107
108
109
110
111
 
# File 'lib/strc.rb', line 104

def rename(key, newkey)
	if key == newkey
		raise STRC::Exception.new "ERR Source and destination objects are the same"
	end
	@dict[newkey] = @dict[key]
	del(key)
	return "OK"
end

#renamenx(key, newkey) ⇒ Object

Renames a key. Does not overwrite destination.



114
115
116
117
118
119
120
121
 
# File 'lib/strc.rb', line 114

def renamenx(key, newkey)
	if exists(newkey)
		return false
	else
		rename(key, newkey)
		return true
	end
end

#rpop(key) ⇒ Object

Remove and get the last element in a list



308
309
310
311
312
313
 
# File 'lib/strc.rb', line 308

def rpop(key)
	list = get_l(key)
	element = list.pop
	set(key, list)
	return element
end

#rpoplpush(source, destination) ⇒ Object

Removes an element from the end of one list and puts it at the beginning of another



357
358
359
 
# File 'lib/strc.rb', line 357

def rpoplpush(source, destination)
	lpush(destination, rpop(source))
end

#rpush(key, *values) ⇒ Object

Append values to a list



293
294
295
296
297
298
 
# File 'lib/strc.rb', line 293

def rpush(key, *values)
	list = get_l(key)
	list += values
	set(key, list)
	return list.length
end

#rpushx(key, *values) ⇒ Object

RPUSH if the list exists



301
302
303
304
305
 
# File 'lib/strc.rb', line 301

def rpushx(key, *values)
	if exists(key)
		rpush(key, *values)
	end
end

#sadd(key, *args) ⇒ Object

Add a member to a set



128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
 
# File 'lib/strc.rb', line 128

def sadd(key, *args)
	if args.length < 1
		raise STRC::Exception.new "Wrong number of arguments (1 for 2)"
	end
	set = get_s(key)
	added = 0
	args.each do |arg|
		unless set.include?(arg)
			set << arg
			added += 1
		end
	end
	@dict[key] = set
	return added
end

#scard(key) ⇒ Object

Gets the length of a set



248
249
250
251
 
# File 'lib/strc.rb', line 248

def scard(key)
	set = get_s(key)
	return set.length
end

#sdiff(*keys) ⇒ Object

Returns a list of the difference between the first set and subsequent sets



175
176
177
178
179
180
181
182
183
184
185
 
# File 'lib/strc.rb', line 175

def sdiff(*keys)
	sets = []
	keys.each do |key|
		sets << get_s(key)
	end
	diff = sets.shift
	sets.each do |set|
		diff -= set
	end
	return diff.to_a
end

#sdiffstore(destination, *keys) ⇒ Object

Similar to SDIFF, but stores in destination instead of returning



188
189
190
191
 
# File 'lib/strc.rb', line 188

def sdiffstore(destination, *keys)
	elements = sdiff(*keys)
	sadd(destination, *elements)
end

#set(key, value) ⇒ Object

Set a given key to a value



11
12
13
14
 
# File 'lib/strc.rb', line 11

def set(key, value)
	@dict[key] = value
	return "OK"
end

#setnx(key, value) ⇒ Object

Set the value of a key only if it doesn’t already exist.



17
18
19
20
21
22
23
 
# File 'lib/strc.rb', line 17

def setnx(key, value)
	unless exists(key)
		set(key, value)
		return true
	end
	return false
end

#sinter(*keys) ⇒ Object

Returns a list of m



155
156
157
158
159
160
161
162
163
164
165
 
# File 'lib/strc.rb', line 155

def sinter(*keys)
	sets = []
	keys.each do |key|
		sets << get_s(key)
	end
	inter = sets.shift
	sets.each do |set|
		inter &= set
	end
	return inter.to_a
end

#sinterstore(destination, *keys) ⇒ Object

Similar to SINTER, but stores in destination instead of returning



168
169
170
171
 
# File 'lib/strc.rb', line 168

def sinterstore(destination, *keys)
	elements = sinter(*keys)
	sadd(destination, *elements)
end

#sismember(key, member) ⇒ Object

Determine if the given value is a member of the set at key



237
238
239
240
 
# File 'lib/strc.rb', line 237

def sismember(key, member)
	set = get_s(key)
	return set.include?(member)
end

#smembers(key) ⇒ Object

Returns an array of members of the set



243
244
245
 
# File 'lib/strc.rb', line 243

def smembers(key)
	get_s(key).to_a
end

#smove(source, destination, member) ⇒ Object

Move an item from one set to another



194
195
196
197
198
199
200
201
202
203
 
# File 'lib/strc.rb', line 194

def smove(source, destination, member)
	unless sismember(source, member)
		return false
	end
	srem(source, member)
	unless sismember(destination, member)
		sadd(destination, member)
	end
	return true
end

#spop(key) ⇒ Object

Randomly remove and return an item from the set



230
231
232
233
234
 
# File 'lib/strc.rb', line 230

def spop(key)
	element = srandmember(key)
	srem(key, element)
	return element
end

#srandmember(key) ⇒ Object

Returns a random element from the set



225
226
227
 
# File 'lib/strc.rb', line 225

def srandmember(key)
	get_s(key).to_a.sample
end

#srem(key, member) ⇒ Object

Remove a member from a set



145
146
147
148
149
150
151
152
 
# File 'lib/strc.rb', line 145

def srem(key, member)
	if sismember(key, member)
		@dict[key].delete(member)
		return true
	else
		return false
	end
end

#sunion(*keys) ⇒ Object

Returs a list of all unique items in the given sets



206
207
208
209
210
211
212
213
214
215
216
 
# File 'lib/strc.rb', line 206

def sunion(*keys)
	sets = []
	keys.each do |key|
		sets << get_s(key)
	end
	union = sets.shift
	sets.each do |set|
		union += set
	end
	return union.to_a
end

#sunionstore(destination, *keys) ⇒ Object

Similar to SUNION, but stores in destination instead of returning



219
220
221
222
 
# File 'lib/strc.rb', line 219

def sunionstore(destination, *keys)
	elements = sunion(*keys)
	sadd(destination, *elements)
end