nest 0.0.2 → 0.0.3

data/README.markdown

@@ -7,7 +7,8 @@ Description
 -----------
 
 If you are familiar with databases like
-[Redis](http://code.google.com/p/redis) and libraries like [Ohm](http://ohm.keyvalue.org) or
+[Redis](http://code.google.com/p/redis) and
+libraries like [Ohm](http://ohm.keyvalue.org) or
 [redis-namespace](http://github.com/defunkt/redis-namespace), you
 already know how important it is to craft the keys that will hold the
 data.
@@ -17,8 +18,8 @@ data.
     => "Redis Meetup"
 
 It is a design pattern in key-value databases to use the key to simulate
-structure, and you can read more about this in the [Twitter case
-study](http://code.google.com/p/redis/wiki/TwitterAlikeExample).
+structure, and you can read more about this in the [case study for a
+Twitter clone](http://code.google.com/p/redis/wiki/TwitterAlikeExample).
 
 Nest helps you generate those keys by providing chainable namespaces:
 
@@ -43,14 +44,14 @@ To create a new namespace:
 
 And you can use any object as a key, not only strings:
 
-    >> ns[:foo][42]
-    => "foo:42"
+    >> ns[:bar][42]
+    => "foo:bar:42"
 
 In a more realistic tone, lets assume you are working with Redis and
 dealing with events:
 
-    >> event = Nest.new("event")
-    => "event"
+    >> events = Nest.new("events")
+    => "events"
 
     >> redis = Redis.new
     => #<Redis::Client...>
@@ -58,20 +59,47 @@ dealing with events:
     >> id = redis.incr(event)
     => 1
 
-    >> redis.set event[id][:name], "Redis Meetup"
+    >> redis.set events[id][:name], "Redis Meetup"
     => "OK"
 
-    >> redis.get event[id][:name]
+    >> redis.get events[id][:name]
     => "Redis Meetup"
 
-    >> meetup = event[id]
-    => "event:1"
+    >> meetup = events[id]
+    => "events:1"
 
     >> redis.get meetup[:name]
     => "Redis Meetup"
 
+Using Nest as an object oriented Redis key
+------------------------------------------
+
+If you supply a Redis client as a second parameter, you can operate with
+Redis directly:
+
+    >> redis = Redis.new
+    => #<Redis::Client...>
+
+    >> events = Nest.new("events", redis)
+    => "events"
+
+    >> events.sadd(meetup)
+    => true
+
+    >> events.sismember(meetup)
+    => true
+
+    >> events.smembers
+    => ["events:1"]
+
+    >> events.del
+    >> true
+
+It allows you to execute all the Redis commands that expect a key as the
+first parameter. Think of it as a curried Redis client.
+
 Differences with redis-namespace
--------------------------------
+--------------------------------
 
 [redis-namespace](http://github.com/defunkt/redis-namespace) wraps Redis
 and translates the keys back and forth transparently.
@@ -82,7 +110,7 @@ different scope.
 Use Nest when you want to use the keys to represent structure.
 
 Differences with Ohm
--------------------
+--------------------
 
 [Ohm](http://ohm.keyvalue.org) lets you map Ruby objects to Redis with
 little effort. It not only alleviates you from the pain of generating

data/lib/nest.rb

@@ -1,9 +1,34 @@
-#! /usr/bin/env ruby
-
 class Nest < String
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
+
+  def initialize(key, redis = nil)
+    super(key)
+    @redis = redis
+  end
 
   def [](key)
     self.class.new("#{self}:#{key}")
   end
+
+  [:append, :blpop, :brpop, :decr, :decrby, :del, :exists, :expire,
+  :expireat, :get, :getset, :hdel, :hexists, :hget, :hgetall,
+  :hincrby, :hkeys, :hlen, :hmset, :hset, :hvals, :incr, :incrby,
+  :lindex, :llen, :lpop, :lpush, :lrange, :lrem, :lset, :ltrim, :move,
+  :rename, :renamenx, :rpop, :rpoplpush, :rpush, :sadd, :scard,
+  :sdiff, :sdiffstore, :set, :setex, :setnx, :sinter, :sinterstore,
+  :sismember, :smembers, :smove, :sort, :spop, :srandmember, :srem,
+  :substr, :sunion, :sunionstore, :ttl, :type, :zadd, :zcard,
+  :zincrby, :zinterstore, :zrange, :zrangebyscore, :zrank, :zrem,
+  :zremrangebyrank, :zremrangebyscore, :zrevrange, :zrevrank, :zscore,
+  :zunionstore].each do |meth|
+    define_method(meth) do |*args|
+      redis.send(meth, self, *args)
+    end
+  end
+
+private
+
+  def redis
+    @redis
+  end
 end

data/nest.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name              = "nest"
-  s.version           = "0.0.2"
+  s.version           = "0.0.3"
   s.summary           = "Generate nested namespaced keys for key-value databases."
   s.description       = "It is a design pattern in key-value databases to use the key to simulate structure, and Nest can take care of that."
   s.authors           = ["Michel Martens"]

data/test/nest_test.rb

@@ -1,34 +1,63 @@
 require File.join(File.dirname(__FILE__), "test_helper")
 
 class TestNest < Test::Unit::TestCase
-  should "return the namespace" do
-    n1 = Nest.new("foo")
-    assert_equal "foo", n1
-  end
+  context "creating namespaces" do
+    should "return the namespace" do
+      n1 = Nest.new("foo")
+      assert_equal "foo", n1
+    end
 
-  should "prepend the namespace" do
-    n1 = Nest.new("foo")
-    assert_equal "foo:bar", n1["bar"]
-  end
+    should "prepend the namespace" do
+      n1 = Nest.new("foo")
+      assert_equal "foo:bar", n1["bar"]
+    end
 
-  should "work in more than one level" do
-    n1 = Nest.new("foo")
-    n2 = Nest.new(n1["bar"])
-    assert_equal "foo:bar:baz", n2["baz"]
-  end
+    should "work in more than one level" do
+      n1 = Nest.new("foo")
+      n2 = Nest.new(n1["bar"])
+      assert_equal "foo:bar:baz", n2["baz"]
+    end
 
-  should "be chainable" do
-    n1 = Nest.new("foo")
-    assert_equal "foo:bar:baz", n1["bar"]["baz"]
-  end
+    should "be chainable" do
+      n1 = Nest.new("foo")
+      assert_equal "foo:bar:baz", n1["bar"]["baz"]
+    end
+
+    should "accept symbols" do
+      n1 = Nest.new(:foo)
+      assert_equal "foo:bar", n1[:bar]
+    end
 
-  should "accept symbols" do
-    n1 = Nest.new(:foo)
-    assert_equal "foo:bar", n1[:bar]
+    should "accept numbers" do
+      n1 = Nest.new("foo")
+      assert_equal "foo:3", n1[3]
+    end
   end
 
-  should "accept numbers" do
-    n1 = Nest.new("foo")
-    assert_equal "foo:3", n1[3]
+  context "operating with redis" do
+    require "redis"
+
+    setup do
+      @redis = Redis.new :db => 15
+      @redis.flushdb
+    end
+
+    should "raise if no redis instance was passed" do
+      n1 = Nest.new("foo")
+
+      assert_raises NoMethodError do
+        n1.set("s1")
+      end
+    end
+
+    should "work if a redis instance is supplied" do
+      n1 = Nest.new("foo", @redis)
+      n1.set("s")
+      n1.append("1")
+
+      assert_equal "s1", n1.get
+      assert_equal "string", n1.type
+      assert_equal true, n1.exists
+    end
   end
 end

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: nest
 version: !ruby/object:Gem::Version 
+  hash: 25
   prerelease: false
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Michel Martens
@@ -14,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-06 00:00:00 -03:00
+date: 2010-05-18 00:00:00 -03:00
 default_executable: 
 dependencies: []
 
@@ -45,23 +46,27 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Generate nested namespaced keys for key-value databases.