Class: RedisBrowser::Browser

Inherits:
Object
  • Object
show all
Defined in:
lib/redis-browser/browser.rb

Instance Method Summary collapse

Constructor Details

#initialize(conn = {}) ⇒ Browser

Returns a new instance of Browser.



3
4
5
 
# File 'lib/redis-browser/browser.rb', line 3

def initialize(conn = {})
  @conn = conn
end

Instance Method Details

#delete(pattern) ⇒ Object 



100
101
102
 
# File 'lib/redis-browser/browser.rb', line 100

def delete(pattern)
  redis.del(redis.keys(pattern))
end

#get(key, opts = {}) ⇒ Object 



104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
 
# File 'lib/redis-browser/browser.rb', line 104

def get(key, opts = {})
  type = redis.type(key)
  data = case type
  when "string"
    type, value = item_type(redis.get(key))
    {:value => value, :type => type}
  when "list"
    get_list(key, opts)
  when "set"
    get_set(key)
  when "zset"
    get_zset(key)
  when "hash"
    get_hash(key)
  else
    get_keys(key)
  end

  {
    :full => key,
    :type => type
  }.merge(data)
end

#get_hash(key) ⇒ Object 



80
81
82
83
84
85
86
87
 
# File 'lib/redis-browser/browser.rb', line 80

def get_hash(key)
  value = Hash[redis.hgetall(key).map do |k,v|
    type, value = item_type(v)
    [k, {:type => type, :value => value}]
  end]

  {:value => value}
end

#get_keys(key) ⇒ Object 



89
90
91
92
93
94
95
96
97
98
 
# File 'lib/redis-browser/browser.rb', line 89

def get_keys(key)
  key ||= ""
  key << "*" unless key.end_with?("*")

  values = redis.keys(key).map do |k|
    {:name => k, :full => k}
  end

  {:values => values}
end

#get_list(key, opts = {}) ⇒ Object 



49
50
51
52
53
54
55
56
57
58
59
60
 
# File 'lib/redis-browser/browser.rb', line 49

def get_list(key, opts = {})
  start = opts[:start] ? opts[:start].to_i : 0
  stop  = opts[:stop] ? opts[:stop].to_i : 99

  length = redis.llen(key)
  values = redis.lrange(key, start, stop).map.with_index do |e, i|
    type, value = item_type(e)
    {:type => type, :value => value, :index => start + i}
  end

  {:length => length, :values => values}
end

#get_set(key) ⇒ Object 



62
63
64
65
66
67
68
69
 
# File 'lib/redis-browser/browser.rb', line 62

def get_set(key)
  values = redis.smembers(key).map do |e|
    type, value = item_type(e)
    {:type => type, :value => value}
  end

  {:values => values }
end

#get_zset(key) ⇒ Object 



71
72
73
74
75
76
77
78
 
# File 'lib/redis-browser/browser.rb', line 71

def get_zset(key)
  values = redis.zrange(key, 0, -1, :withscores => true).map do |e, score|
    type, value = item_type(e)
    {:type => type, :value => value, :score => score}
  end

  {:values => values }
end

#item_type(e) ⇒ Object 



41
42
43
44
45
46
47
 
# File 'lib/redis-browser/browser.rb', line 41

def item_type(e)
  begin
    ["json", MultiJson.decode(e)]
  rescue MultiJson::LoadError => ex
    ["string", e]
  end
end

#keys(namespace = nil) ⇒ Object 



15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
# File 'lib/redis-browser/browser.rb', line 15

def keys(namespace = nil)
  if namespace.to_s.strip.empty?
    pattern = "*"
    namespace = ""
  else
    pattern = namespace + "*"
  end

  redis.keys(pattern).inject({}) do |acc, key|
    key.slice!(namespace) if namespace

    ns, sep = split_key(key)

    unless ns.strip.empty?
      acc[ns] ||= {
        :name => ns,
        :full => namespace + ns + sep.to_s,
        :count => 0
      }
      acc[ns][:count] += 1
    end

    acc
  end.values.sort_by {|e| e[:name] }
end

#ping ⇒ Object 



128
129
130
131
132
133
 
# File 'lib/redis-browser/browser.rb', line 128

def ping
  redis.ping == "PONG"
  {:ok => 1}
rescue => ex
  {:error => ex.message}
end

#redis ⇒ Object 



135
136
137
138
139
140
141
142
 
# File 'lib/redis-browser/browser.rb', line 135

def redis
  @redis ||= begin
    r = Redis.new(@conn)
    auth = @conn['auth']
    r.auth(auth) if auth
    r
  end
end

#split_key(key) ⇒ Object 



7
8
9
10
11
12
13
 
# File 'lib/redis-browser/browser.rb', line 7

def split_key(key)
  if key =~ /^(.+?)(:+|\/+|\.+).+$/
    [$1, $2]
  else
    [key, nil]
  end
end