Class: ActiveOrm::Redis::List

Inherits:
Base
  • Object
show all
Defined in:
lib/active_orm/redis/list.rb

Class Method Summary collapse

Methods inherited from Base

client, evaluate

Class Method Details

.all(key) ⇒ Object 



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

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

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



26
27
28
29
 
# File 'lib/active_orm/redis/list.rb', line 26

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

.count(key) ⇒ Object 



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

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

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



40
41
42
43
44
 
# File 'lib/active_orm/redis/list.rb', line 40

def create(key, value, order = :prepend)
  normalized_key = normalize_key(key)

  append?(order) ? client.rpush(normalized_key, value) : client.lpush(normalized_key, value)
end

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



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

def create!(key, value, order = :prepend)
  normalized_key = normalize_key(key)

  append?(order) ? client.rpushx(normalized_key, value) : client.lpushx(normalized_key, value)
end

.create_after(key, pivot, value) ⇒ Object 



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

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

.create_before(key, pivot, value) ⇒ Object 



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

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

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



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

def create_limit(key, value, limit, order = :prepend)
  normalized_key = normalize_key(key)

  append?(order) ? client.rpush(normalized_key, value) : client.lpush(normalized_key, value)
  client.ltrim(normalized_key, 0, (limit - 1))
end

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



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

def create_limit!(key, value, limit, order = :prepend)
  normalized_key = normalize_key(key)

  append?(order) ? client.rpushx(normalized_key, value) : client.lpushx(normalized_key, value)
  client.ltrim(normalized_key, 0, (limit - 1))
end

.destroy(key, count, value) ⇒ Object 



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

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

.destroy_all(key) ⇒ Object 



106
107
108
 
# File 'lib/active_orm/redis/list.rb', line 106

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

.destroy_except(key, start, finish) ⇒ Object 



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

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

.destroy_first(key, limit = 1) ⇒ Object 



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

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

.destroy_last(key, limit = 1) ⇒ Object 



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

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

.find(key, position = 1) ⇒ Object 



6
7
8
9
10
 
# File 'lib/active_orm/redis/list.rb', line 6

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

.first(key, limit = 1) ⇒ Object 



12
13
14
15
16
17
 
# File 'lib/active_orm/redis/list.rb', line 12

def 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 



19
20
21
22
23
24
 
# File 'lib/active_orm/redis/list.rb', line 19

def 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 



78
79
80
81
82
 
# File 'lib/active_orm/redis/list.rb', line 78

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

.move_blocking(key, desination) ⇒ Object 



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

def move_blocking(key, desination)
  value = brpoplpush(normalize_key(key), normalize_key(desination))
  value = metamorph(value) if evaluate?
  value
end

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



110
111
112
113
114
 
# File 'lib/active_orm/redis/list.rb', line 110

def 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 



116
117
118
119
120
121
122
123
124
125
126
 
# File 'lib/active_orm/redis/list.rb', line 116

def pop_blocking(keys, opts = {})
  timeout = opts[:timeout] || 0
  value = if append?(opts[:order] || :prepend)
            client.brpop(keys, timeout)
          else
            client.blpop(keys, timeout)
          end

  value = metamorph(value) if evaluate?
  value
end

.update(key, index, value) ⇒ Object 



74
75
76
 
# File 'lib/active_orm/redis/list.rb', line 74

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