Class: ActiveOrm::Redis::List

Inherits:
ActiveOrm::Redis show all
Defined in:
lib/active_orm/redis/list.rb

Instance Attribute Summary

Attributes inherited from ActiveOrm::Redis

#client

Attributes inherited from Base

#configuration

Class Method Summary collapse

Methods inherited from ActiveOrm::Redis

client, #initialize

Methods included from Base

#evaluate, #evaluate?

Methods inherited from Base

configuration, configuration=, configure

Constructor Details

This class inherits a constructor from ActiveOrm::Redis

Class Method Details

.all(key) ⇒ Object 



29
30
31
32
33
 
# File 'lib/active_orm/redis/list.rb', line 29

def self.all(key)
  value = client.lrange(normalize_key(key), 0, -1)
  value = metatransform(value)
  value
end

.between(key, start = 1, finish = 0) ⇒ Object 



23
24
25
26
27
 
# File 'lib/active_orm/redis/list.rb', line 23

def self.between(key, start=1, finish=0)
  value = client.lrange(normalize_key(key), (start - 1), (finish - 1))
  value = metatransform(value)
  value
end

.count(key) ⇒ Object 



35
36
37
 
# File 'lib/active_orm/redis/list.rb', line 35

def self.count(key)
  client.llen(normalize_key(key))
end

.create(key, value, order = :prepend) ⇒ Object 



39
40
41
 
# File 'lib/active_orm/redis/list.rb', line 39

def self.create(key, value, order=:prepend)
  append?(order) ? client.rpush(normalize_key(key), value) : client.lpush(normalize_key(key), value)
end

.create!(key, value, order = :prepend) ⇒ Object 



43
44
45
 
# File 'lib/active_orm/redis/list.rb', line 43

def self.create!(key, value, order=:prepend)
  append?(order) ? client.rpushx(normalize_key(key), value) : client.lpushx(normalize_key(key), value)
end

.create_after(key, pivot, value) ⇒ Object 



61
62
63
 
# File 'lib/active_orm/redis/list.rb', line 61

def self.create_after(key, pivot, value)
  client.linsert(normalize_key(key), :after, pivot, value)
end

.create_before(key, pivot, value) ⇒ Object 



57
58
59
 
# File 'lib/active_orm/redis/list.rb', line 57

def self.create_before(key, pivot, value)
  client.linsert(normalize_key(key), :before, pivot, value)
end

.create_limit(key, value, limit, order = :prepend) ⇒ Object 



47
48
49
50
 
# File 'lib/active_orm/redis/list.rb', line 47

def self.create_limit(key, value, limit, order=:prepend)
  append?(order) ? client.rpush(normalize_key(key), value) : client.lpush(normalize_key(key), value)
  client.ltrim(normalize_key(key), 0, (limit - 1))
end

.create_limit!(key, value, limit, order = :prepend) ⇒ Object 



52
53
54
55
 
# File 'lib/active_orm/redis/list.rb', line 52

def self.create_limit!(key, value, limit, order=:prepend)
  append?(order) ? client.rpushx(normalize_key(key), value) : client.lpushx(normalize_key(key), value)
  client.ltrim(normalize_key(key), 0, (limit - 1))
end

.destroy(key, count, value) ⇒ Object 



81
82
83
 
# File 'lib/active_orm/redis/list.rb', line 81

def self.destroy(key, count, value)
  client.lrem(normalize_key(key), count, value)
end

.destroy_all(key) ⇒ Object 



97
98
99
 
# File 'lib/active_orm/redis/list.rb', line 97

def self.destroy_all(key)
  client.ltrim(normalize_key(key), -1, 0)
end

.destroy_except(key, start, finish) ⇒ Object 



93
94
95
 
# File 'lib/active_orm/redis/list.rb', line 93

def self.destroy_except(key, start, finish)
  client.ltrim(normalize_key(key), (start - 1), (finish - 1))
end

.destroy_first(key, limit = 1) ⇒ Object 



85
86
87
 
# File 'lib/active_orm/redis/list.rb', line 85

def self.destroy_first(key, limit=1)
  client.ltrim(normalize_key(key), limit, -1)
end

.destroy_last(key, limit = 1) ⇒ Object 



89
90
91
 
# File 'lib/active_orm/redis/list.rb', line 89

def self.destroy_last(key, limit=1)
  client.ltrim(normalize_key(key), 0, -(limit + 1))
end

.find(key, position = 1) ⇒ Object 



3
4
5
6
7
 
# File 'lib/active_orm/redis/list.rb', line 3

def self.find(key, position=1)
  value = client.lindex(normalize_key(key), (position - 1))
  value = metamorph(value) if evaluate?
  value
end

.first(key, limit = 1) ⇒ Object 



9
10
11
12
13
14
 
# File 'lib/active_orm/redis/list.rb', line 9

def self.first(key, limit=1)
  value = client.lrange(normalize_key(key), 0, -1)
  value = ((limit == 1) ? value.first : value.first(limit))
  value = metamorph(value) if evaluate?
  value
end

.last(key, limit = 1) ⇒ Object 



16
17
18
19
20
21
 
# File 'lib/active_orm/redis/list.rb', line 16

def self.last(key, limit=1)
  value = client.lrange(normalize_key(key), 0, -1)
  value = ((limit == 1) ? value.last : value.last(limit))
  value = metamorph(value) if evaluate?
  value
end

.move(key, desination) ⇒ Object 



69
70
71
72
73
 
# File 'lib/active_orm/redis/list.rb', line 69

def self.move(key, desination)
  value = client.rpoplpush(normalize_key(key), normalize_key(desination))
  value = metamorph(value) if evaluate?
  value
end

.move_blocking(key, desination, opts = {}) ⇒ Object 



75
76
77
78
79
 
# File 'lib/active_orm/redis/list.rb', line 75

def self.move_blocking(key, desination, opts={})
  value = brpoplpush(normalize_key(key), normalize_key(desination))
  value = metamorph(value) if evaluate?
  value
end

.pop(key, order = :prepend) ⇒ Object 



101
102
103
104
105
 
# File 'lib/active_orm/redis/list.rb', line 101

def self.pop(key, order=:prepend)
  value = append?(order) ? client.rpop(key) : client.lpop(key)
  value = metamorph(value) if evaluate?
  value
end

.pop_blocking(keys, opts = {}) ⇒ Object 



107
108
109
110
111
 
# File 'lib/active_orm/redis/list.rb', line 107

def self.pop_blocking(keys, opts={})
  value = append?(opts.fetch(:order, :prepend)) ? client.brpop(keys, opts.fetch(:timeout, 0)) : client.blpop(keys, opts.fetch(:timeout, 0))
  value = metamorph(value) if evaluate?
  value
end

.update(key, index, value) ⇒ Object 



65
66
67
 
# File 'lib/active_orm/redis/list.rb', line 65

def self.update(key, index, value)
  client.lset(normalize_key(key), index, value)
end