nest 0.0.7 → 1.0.0

data/README.markdown

@@ -1,32 +1,31 @@
 Nest
 ====
 
-Generate nested namespaced keys for key-value databases.
+Object Oriented Keys for Redis.
 
 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-namespace](http://github.com/defunkt/redis-namespace), you
-already know how important it is to craft the keys that will hold the
-data.
+If you are familiar with databases like [Redis](http://code.google.com/p/redis)
+and libraries like [Ohm](http://ohm.keyvalue.org) you already know how
+important it is to craft the keys that will hold the data.
 
-    >> @redis.set "event:3:name", "Redis Meetup"
-    >> @redis.get "event:3:name"
-    => "Redis Meetup"
+    >> redis = Redis.new
+    >> redis.sadd("event:3:attendees", "Albert")
+    >> redis.smembers("event:3:attendees")
+    => ["Albert"]
 
 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 [case study for a
 Twitter clone](http://code.google.com/p/redis/wiki/TwitterAlikeExample).
 
-Nest helps you generate those keys by providing chainable namespaces:
+Nest helps you generate those keys by providing chainable namespaces that are
+already connected to Redis:
 
     >> event = Nest.new("event")
-    >> @redis.set event[3][:name], "Redis Meetup"
-    >> @redis.get event[3][:name]
-    => "Redis Meetup"
+    >> event[3][:attendees].sadd("Albert")
+    >> event[3][:attendees].smembers
+    => ["Albert"]
 
 Usage
 -----
@@ -53,34 +52,41 @@ dealing with events:
     >> events = Nest.new("events")
     => "events"
 
-    >> redis = Redis.new
-    => #<Redis::Client...>
-
-    >> id = redis.incr(event)
+    >> id = events[:id].incr
     => 1
 
-    >> redis.set events[id][:name], "Redis Meetup"
+    >> events[id][:attendees].sadd("Albert")
     => "OK"
 
-    >> redis.get events[id][:name]
-    => "Redis Meetup"
-
     >> meetup = events[id]
     => "events:1"
 
-    >> redis.get meetup[:name]
-    => "Redis Meetup"
+    >> meetup[:attendees].smembers
+    => ["Albert"]
 
-Using Nest as an object oriented Redis key
-------------------------------------------
+Supplying your existing Redis instance
+--------------------------------------
 
-If you supply a Redis client as a second parameter, you can operate with
-Redis directly:
+You can supply a `Redis` instance as a second parameter. If you don't, a default
+instance is created for you:
 
     >> redis = Redis.new
     => #<Redis::Client...>
 
-    >> events = Nest.new("events", redis)
+    >> users = Nest.new("users", redis)
+    => "users"
+
+    >> id = users[:id].incr
+    => 1
+
+    >> users[id].hset(:name, "Albert")
+    => "OK"
+
+`Nest` objects respond to `redis` and return a `Redis` instance. It is
+automatically reused when you create a new namespace, and you can reuse it when
+creating a new instance of Nest:
+
+    >> events = Nest.new("events", meetup.redis)
     => "events"
 
     >> events.sadd(meetup)
@@ -95,8 +101,9 @@ Redis directly:
     >> 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.
+Nest allows you to execute all the Redis commands that expect a key as the
+first parameter. Think of it as a
+[curried](http://en.wikipedia.org/wiki/Currying) Redis client.
 
 Differences with redis-namespace
 --------------------------------
@@ -109,6 +116,10 @@ different scope.
 
 Use Nest when you want to use the keys to represent structure.
 
+Tip: instead of using redis-namespace, it is recommended that you run a
+different instance of `redis-server`. Translating keys back and forth is not
+only delicate, but unnecessary and counterproductive.
+
 Differences with Ohm
 --------------------
 
@@ -119,12 +130,15 @@ between objects.
 
 Use Ohm when you want to use Redis as your database.
 
-Use Nest when mapping objects with Ohm is not possible.
+Use Nest when mapping objects with Ohm is not possible or overkill.
+
+Tip: Ohm uses Nest internally to deal with keys. Having a good knowledge
+of Nest will let you extend Ohm to suit your needs.
 
 Installation
 ------------
 
-    $ sudo gem install nest
+    $ gem install nest
 
 License
 -------

data/Rakefile

@@ -1,5 +1,6 @@
 task :test do
-  system "cd test && ruby nest_test.rb"
+  require "cutest"
+  Cutest.run(Dir["test/nest*"])
 end
 
 task :default => :test

data/lib/nest.rb

@@ -1,5 +1,7 @@
+require "redis"
+
 class Nest < String
-  VERSION = "0.0.7"
+  VERSION = "1.0.0"
 
   METHODS = [:append, :blpop, :brpop, :decr, :decrby, :del, :exists,
   :expire, :expireat, :get, :getset, :hdel, :hexists, :hget, :hgetall,
@@ -15,7 +17,9 @@ class Nest < String
   :zrem, :zremrangebyrank, :zremrangebyscore, :zrevrange, :zrevrank,
   :zscore, :zunionstore]
 
-  def initialize(key, redis = nil)
+  attr :redis
+
+  def initialize(key, redis = Redis.connect)
     super(key.to_s)
     @redis = redis
   end
@@ -29,10 +33,4 @@ class Nest < String
       redis.send(meth, self, *args, &block)
     end
   end
-
-private
-
-  def redis
-    @redis
-  end
 end

data/nest.gemspec

@@ -1,10 +1,12 @@
 Gem::Specification.new do |s|
   s.name              = "nest"
-  s.version           = "0.0.7"
-  s.summary           = "Generate nested namespaced keys for key-value databases."
+  s.version           = "1.0.0"
+  s.summary           = "Object Oriented Keys for Redis."
   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"]
   s.email             = ["michel@soveran.com"]
   s.homepage          = "http://github.com/soveran/nest"
   s.files = ["LICENSE", "README.markdown", "Rakefile", "lib/nest.rb", "nest.gemspec", "test/nest_test.rb", "test/test_helper.rb"]
+  s.add_dependency "redis", "~> 2.0.0"
+  s.add_development_dependency "cutest", "~> 0.1"
 end

data/test/nest_test.rb

@@ -1,91 +1,86 @@
 require File.expand_path("test_helper", File.dirname(__FILE__))
 
-class TestNest < Test::Unit::TestCase
-  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 "work in more than one level" do
-      n1 = Nest.new("foo")
-      n2 = Nest.new(n1["bar"])
-      assert_equal "foo:bar:baz", n2["baz"]
-    end
+# Creating namespaces.
+scope do
+  test "return the namespace" do
+    n1 = Nest.new("foo")
+    assert "foo" == n1
+  end
 
-    should "be chainable" do
-      n1 = Nest.new("foo")
-      assert_equal "foo:bar:baz", n1["bar"]["baz"]
-    end
+  test "prepend the namespace" do
+    n1 = Nest.new("foo")
+    assert "foo:bar" == n1["bar"]
+  end
 
-    should "accept symbols" do
-      n1 = Nest.new(:foo)
-      assert_equal "foo:bar", n1[:bar]
-    end
+  test "work in more than one level" do
+    n1 = Nest.new("foo")
+    n2 = Nest.new(n1["bar"])
+    assert "foo:bar:baz" == n2["baz"]
+  end
 
-    should "accept numbers" do
-      n1 = Nest.new("foo")
-      assert_equal "foo:3", n1[3]
-    end
+  test "be chainable" do
+    n1 = Nest.new("foo")
+    assert "foo:bar:baz" == n1["bar"]["baz"]
   end
 
-  context "operating with redis" do
-    require "redis"
+  test "accept symbols" do
+    n1 = Nest.new(:foo)
+    assert "foo:bar" == n1[:bar]
+  end
 
-    setup do
-      @redis = Redis.new :db => 15
-      @redis.flushdb
-    end
+  test "accept numbers" do
+    n1 = Nest.new("foo")
+    assert "foo:3" == n1[3]
+  end
+end
 
-    should "raise if no redis instance was passed" do
-      n1 = Nest.new("foo")
+# Operating with redis.
+scope do
+  prepare do
+    @redis = Redis.new
+    @redis.flushdb
+  end
 
-      assert_raises NoMethodError do
-        n1.set("s1")
-      end
-    end
+  test "work if no redis instance was passed" do
+    n1 = Nest.new("foo")
+    n1.set("s1")
 
-    should "work if a redis instance is supplied" do
-      n1 = Nest.new("foo", @redis)
-      n1.set("s1")
+    assert "s1" == n1.get
+  end
 
-      assert_equal "s1", n1.get
-    end
+  test "work if a redis instance is supplied" do
+    n1 = Nest.new("foo", @redis)
+    n1.set("s1")
 
-    should "pass the redis instance to new keys" do
-      n1 = Nest.new("foo", @redis)
-      n1["bar"].set("s2")
+    assert "s1" == n1.get
+  end
 
-      assert_equal nil, n1.get
-      assert_equal "s2", n1["bar"].get
-    end
+  test "pass the redis instance to new keys" do
+    n1 = Nest.new("foo", @redis)
 
-    should "PubSub" do
-      foo = Nest.new("foo", @redis)
-      listening = false
-      message_received = false
+    assert @redis.id == n1["bar"].redis.id
+  end
 
-      Thread.new do
-        while !listening; end
-        Nest.new("foo", Redis.new(:db => 15)).publish("")
-      end
+  test "PubSub" do
+    foo = Nest.new("foo", @redis)
+    listening = false
+    message_received = false
 
-      foo.subscribe do |on|
-        on.message do
-          message_received = true
+    Thread.new do
+      while !listening; end
+      Nest.new("foo", Redis.new(:db => 15)).publish("")
+    end
 
-          foo.unsubscribe
-        end
+    foo.subscribe do |on|
+      on.message do
+        message_received = true
 
-        listening = true
+        foo.unsubscribe
       end
 
-      assert message_received
+      listening = true
     end
+
+    assert message_received
   end
 end

data/test/test_helper.rb

@@ -1,3 +1,3 @@
 require "rubygems"
-require "contest"
+require "cutest"
 require File.join(File.dirname(__FILE__), "..", "lib", "nest")

metadata

@@ -3,10 +3,10 @@ name: nest
 version: !ruby/object:Gem::Version 
   prerelease: false
   segments: 
+  - 1
   - 0
   - 0
-  - 7
-  version: 0.0.7
+  version: 1.0.0
 platform: ruby
 authors: 
 - Michel Martens
@@ -14,10 +14,38 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-08-05 00:00:00 -03:00
+date: 2010-10-22 00:00:00 -03:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: redis
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        - 0
+        version: 2.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: cutest
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        version: "0.1"
+  type: :development
+  version_requirements: *id002
 description: It is a design pattern in key-value databases to use the key to simulate structure, and Nest can take care of that.
 email: 
 - michel@soveran.com
@@ -66,6 +94,6 @@ rubyforge_project:
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: Generate nested namespaced keys for key-value databases.
+summary: Object Oriented Keys for Redis.
 test_files: []