Class: Browser

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

Instance Method Summary collapse

Constructor Details

#initialize(conn = nil, db = 0) ⇒ Browser 



19
20
21
22
 
# File 'lib/redis-browser/app.rb', line 19

def initialize(conn = nil, db = 0)
  @conn = conn
  @db = db
end

Instance Method Details

#delete(pattern) ⇒ Object 



116
117
118
 
# File 'lib/redis-browser/app.rb', line 116

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

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



120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
 
# File 'lib/redis-browser/app.rb', line 120

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 



97
98
99
100
101
102
103
104
 
# File 'lib/redis-browser/app.rb', line 97

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 



106
107
108
109
110
111
112
113
114
 
# File 'lib/redis-browser/app.rb', line 106

def get_keys(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 



66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/redis-browser/app.rb', line 66

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 



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

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 



88
89
90
91
92
93
94
95
 
# File 'lib/redis-browser/app.rb', line 88

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 



58
59
60
61
62
63
64
 
# File 'lib/redis-browser/app.rb', line 58

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

#keys(namespace = nil) ⇒ Object 



32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
# File 'lib/redis-browser/app.rb', line 32

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 



144
145
146
147
148
149
 
# File 'lib/redis-browser/app.rb', line 144

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

#redis ⇒ Object 



151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
 
# File 'lib/redis-browser/app.rb', line 151

def redis
  @redis ||= begin
    conn = @conn || "127.0.0.1:6379"
    db = @db || 0

    opts = if conn.start_with?("/")
      {:path => conn}
    else
      host, port = conn.split(":", 2)
      {:host => host, :port => port}
    end

    r = Redis.new(opts)
    r.select(db)
    r
  end
end

#split_key(key) ⇒ Object 



24
25
26
27
28
29
30
 
# File 'lib/redis-browser/app.rb', line 24

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