Class: Redis::List

Inherits:
BaseObject show all
Includes:
Enumerable, Helpers::CoreCommands
Defined in:
lib/redis/list.rb

Overview

Class representing a Redis list. Instances of Redis::List are designed to behave as much like Ruby arrays as possible.

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods included from Helpers::CoreCommands

#exists?, #expire, #expireat, #marshal, #move, #persist, #rename, #renamenx, #sort, #ttl, #type, #unmarshal

Methods inherited from BaseObject

#allow_expiration, #initialize, #redis, #set_expiration, #to_hash, #to_json

Constructor Details

This class inherits a constructor from Redis::BaseObject

Instance Attribute Details

#keyObject (readonly)

Returns the value of attribute key


14
15
16
# File 'lib/redis/list.rb', line 14

def key
  @key
end

#optionsObject (readonly)

Returns the value of attribute options


14
15
16
# File 'lib/redis/list.rb', line 14

def options
  @options
end

Instance Method Details

#<<(value) ⇒ Object

Works like push. Can chain together: list << 'a' << 'b'


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

def <<(value)
  push(value) # marshal in push()
  self  # for << 'a' << 'b'
end

#==(x) ⇒ Object


163
164
165
# File 'lib/redis/list.rb', line 163

def ==(x)
  values == x
end

#[](index, length = nil) ⇒ Object Also known as: slice

Same functionality as Ruby arrays. If a single number is given, return just the element at that index using Redis: LINDEX. Otherwise, return a range of values using Redis: LRANGE.


94
95
96
97
98
99
100
101
102
103
104
105
106
# File 'lib/redis/list.rb', line 94

def [](index, length=nil)
  if index.is_a? Range
    range(index.first, index.max)
  elsif length
    case length <=> 0
    when 1  then range(index, index + length - 1)
    when 0  then []
    when -1 then nil  # Ruby does this (a bit weird)
    end
  else
    at(index)
  end
end

#[]=(index, value) ⇒ Object

Same functionality as Ruby arrays.


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

def []=(index, value)
  allow_expiration do
    redis.lset(key, index, marshal(value))
  end
end

#as_jsonObject


171
172
173
# File 'lib/redis/list.rb', line 171

def as_json(*)
  to_hash
end

#at(index) ⇒ Object

Return the value at the given index. Can also use familiar list syntax. Redis: LINDEX


138
139
140
# File 'lib/redis/list.rb', line 138

def at(index)
  unmarshal redis.lindex(key, index)
end

#delete(name, count = 0) ⇒ Object

Delete the element(s) from the list that match name. If count is specified, only the first-N (if positive) or last-N (if negative) will be removed. Use .del to completely delete the entire key. Redis: LREM


120
121
122
# File 'lib/redis/list.rb', line 120

def delete(name, count=0)
  redis.lrem(key, count, marshal(name))  # weird api
end

#each(&block) ⇒ Object

Iterate through each member of the set. Redis::Objects mixes in Enumerable, so you can also use familiar methods like collect, detect, and so forth.


126
127
128
# File 'lib/redis/list.rb', line 126

def each(&block)
  values.each(&block)
end

#empty?Boolean

Returns true if there are no elements in the list. Redis: LLEN == 0

Returns:

  • (Boolean)

159
160
161
# File 'lib/redis/list.rb', line 159

def empty?
  length == 0
end

#firstObject

Return the first element in the list. Redis: LINDEX(0)


143
144
145
# File 'lib/redis/list.rb', line 143

def first
  at(0)
end

#insert(where, pivot, value) ⇒ Object

Add a member before or after pivot in the list. Redis: LINSERT


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

def insert(where,pivot,value)
  allow_expiration do
    redis.linsert(key,where,marshal(pivot),marshal(value))
  end
end

#lastObject

Return the last element in the list. Redis: LINDEX(-1)


148
149
150
# File 'lib/redis/list.rb', line 148

def last
  at(-1)
end

#lengthObject Also known as: size

Return the length of the list. Aliased as size. Redis: LLEN


153
154
155
# File 'lib/redis/list.rb', line 153

def length
  redis.llen(key)
end

#pop(n = nil) ⇒ Object

Remove a member from the end of the list. Redis: RPOP


38
39
40
41
42
43
44
45
46
47
48
# File 'lib/redis/list.rb', line 38

def pop(n=nil)
  if n
    result, = redis.multi do
      redis.lrange(key, -n, -1)
      redis.ltrim(key, 0, -n - 1)
    end
    unmarshal result
  else
    unmarshal redis.rpop(key)
  end
end

#push(*values) ⇒ Object

Add a member to the end of the list. Redis: RPUSH


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

def push(*values)
  allow_expiration do
    redis.rpush(key, values.map{|v| marshal(v) })
    redis.ltrim(key, -options[:maxlength], -1) if options[:maxlength]
  end
end

#range(start_index, end_index) ⇒ Object

Return a range of values from start_index to end_index. Can also use the familiar list Ruby syntax. Redis: LRANGE


132
133
134
# File 'lib/redis/list.rb', line 132

def range(start_index, end_index)
  redis.lrange(key, start_index, end_index).map{|v| unmarshal(v) }
end

#rpoplpush(destination) ⇒ Object

Atomically pops a value from one list, pushes to another and returns the value. Destination can be a String or a Redis::List

list.rpoplpush(destination)

Returns the popped/pushed value.

Redis: RPOPLPUSH


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

def rpoplpush(destination)
  unmarshal redis.rpoplpush(key, destination.is_a?(Redis::List) ? destination.key : destination.to_s)
end

#shift(n = nil) ⇒ Object

Remove a member from the start of the list. Redis: LPOP


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

def shift(n=nil)
  if n
    result, = redis.multi do
      redis.lrange(key, 0, n - 1)
      redis.ltrim(key, n, -1)
    end
    unmarshal result
  else
    unmarshal redis.lpop(key)
  end
end

#to_sObject


167
168
169
# File 'lib/redis/list.rb', line 167

def to_s
  values.join(', ')
end

#unshift(*values) ⇒ Object

Add a member to the start of the list. Redis: LPUSH


63
64
65
66
67
68
# File 'lib/redis/list.rb', line 63

def unshift(*values)
  allow_expiration do
    redis.lpush(key, values.map{|v| marshal(v) })
    redis.ltrim(key, 0, options[:maxlength] - 1) if options[:maxlength]
  end
end

#valuesObject Also known as: get, value

Return all values in the list. Redis: LRANGE(0,-1)


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

def values
  vals = range(0, -1)
  vals.nil? ? [] : vals
end