nest 1.1.2 → 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 610bc2190ba05babfba5f60c066cc5490275ec84
+  data.tar.gz: ab916a8881519a70bb419e6123a110e1ac5b2b8d
+SHA512:
+  metadata.gz: 082e573734a5b6ea7fb562d53738140bd0508fbe3b7dba6f5608f545e220b70bf8aff329019982f5e6592cda997f4846ff2734cea11e89b6ad122e459c88f518
+  data.tar.gz: e3cc7a3c657c56c0de9255b045fc932498d753906aa68faac7fc6e789aeb7b8cb5de24c94d16989dd525b48ddb2cce075730038ba497a4f7ee63e97e976fbffe

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010 Michel Martens & Damian Janowski
+Copyright (c) 2010-2015 Michel Martens & Damian Janowski
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -6,104 +6,117 @@ Object Oriented Keys for Redis.
 Description
 -----------
 
-If you are familiar with databases like [Redis](http://code.google.com/p/redis)
+If you are familiar with databases like [Redis](http://redis.io)
 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 = Redis.new
-    >> redis.sadd("event:3:attendees", "Albert")
-    >> redis.smembers("event:3:attendees")
-    => ["Albert"]
+```ruby
+>> redis = Redic.new
+>> redis.call("SADD", "event:3:attendees", "Albert")
+>> redis.call("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).
+Twitter clone](http://redis.io/topics/twitter-clone).
 
 Nest helps you generate those keys by providing chainable namespaces that are
 already connected to Redis:
 
-    >> event = Nest.new("event")
-    >> event[3][:attendees].sadd("Albert")
-    >> event[3][:attendees].smembers
-    => ["Albert"]
+```ruby
+>> event = Nest.new("event")
+>> event[3][:attendees].sadd("Albert")
+>> event[3][:attendees].smembers
+=> ["Albert"]
+```
 
 Usage
 -----
 
 To create a new namespace:
 
-    >> ns = Nest.new("foo")
-    => "foo"
+```ruby
+>> ns = Nest.new("foo")
+=> "foo"
 
-    >> ns["bar"]
-    => "foo:bar"
+>> ns["bar"]
+=> "foo:bar"
 
-    >> ns["bar"]["baz"]["qux"]
-    => "foo:bar:baz:qux"
+>> ns["bar"]["baz"]["qux"]
+=> "foo:bar:baz:qux"
+```
 
 And you can use any object as a key, not only strings:
 
-    >> ns[:bar][42]
-    => "foo:bar:42"
+```ruby
+>> ns[:bar][42]
+=> "foo:bar:42"
+```
 
 In a more realistic tone, lets assume you are working with Redis and
 dealing with events:
 
-    >> events = Nest.new("events")
-    => "events"
+```ruby
+>> events = Nest.new("events")
+=> "events"
 
-    >> id = events[:id].incr
-    => 1
+>> id = events[:id].incr
+=> 1
 
-    >> events[id][:attendees].sadd("Albert")
-    => "OK"
+>> events[id][:attendees].sadd("Albert")
+=> "OK"
 
-    >> meetup = events[id]
-    => "events:1"
+>> meetup = events[id]
+=> "events:1"
 
-    >> meetup[:attendees].smembers
-    => ["Albert"]
+>> meetup[:attendees].smembers
+=> ["Albert"]
+```
 
 Supplying your existing Redis instance
 --------------------------------------
 
-You can supply a `Redis` instance as a second parameter. If you don't, a default
-instance is created for you:
+You can supply a [Redic](https://github.com/amakawa/redic) instance as
+a second parameter. If you don't, a default instance is created for you:
 
-    >> redis = Redis.new
-    => #<Redis::Client...>
+```ruby
+>> redis = Redic.new("redis://localhost:6379")
+=> #<Redic:0x007fa640845f10 ...>
 
-    >> users = Nest.new("users", redis)
-    => "users"
+>> users = Nest.new("users", redis)
+=> "users"
 
-    >> id = users[:id].incr
-    => 1
+>> id = users[:id].incr
+=> 1
 
-    >> users[id].hset(:name, "Albert")
-    => "OK"
+>> users[id].hset(:name, "Albert")
+=> "OK"
+```
 
-`Nest` objects respond to `redis` and return a `Redis` instance. It is
+`Nest` objects respond to `redis` and return a `Redic` 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"
+```ruby
+>> events = Nest.new("events", meetup.redis)
+=> "events"
 
-    >> events.sadd(meetup)
-    => true
+>> events.sadd(meetup)
+=> true
 
-    >> events.sismember(meetup)
-    => true
+>> events.sismember(meetup)
+=> true
 
-    >> events.smembers
-    => ["events:1"]
+>> events.smembers
+=> ["events:1"]
 
-    >> events.del
-    >> true
+>> events.del
+>> true
+```
 
 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.
+first parameter.
 
 Differences with redis-namespace
 --------------------------------
@@ -138,30 +151,6 @@ of Nest will let you extend Ohm to suit your needs.
 Installation
 ------------
 
-    $ gem install nest
-
-License
--------
-
-Copyright (c) 2010 Michel Martens & Damian Janowski
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
+```
+$ gem install nest
+```

data/Rakefile

@@ -7,7 +7,6 @@ task :default => :test
 
 task :commands do
   require "open-uri"
-  require "par"
   require "json"
 
   file = File.expand_path("lib/nest.rb", File.dirname(__FILE__))
@@ -31,7 +30,7 @@ task :commands do
   commands.delete(:mget)
 
   source = File.read(file).sub(/  METHODS = .+?\n\n/m) do
-    Par.new("  METHODS = #{commands.inspect}\n\n", p: 2)
+    "  METHODS = #{commands.inspect}\n\n"
   end
 
   File.open(file, "w") { |f| f.write source }

data/lib/nest.rb

@@ -1,25 +1,27 @@
-require "redis"
+require "redic"
 
 class Nest < String
-  METHODS = [:append, :bitcount, :blpop, :brpop, :brpoplpush, :decr,
-  :decrby, :del, :dump, :exists, :expire, :expireat, :get, :getbit,
-  :getrange, :getset, :hdel, :hexists, :hget, :hgetall, :hincrby,
-  :hincrbyfloat, :hkeys, :hlen, :hmget, :hmset, :hset, :hsetnx, :hvals,
-  :incr, :incrby, :incrbyfloat, :lindex, :linsert, :llen, :lpop,
-  :lpush, :lpushx, :lrange, :lrem, :lset, :ltrim, :move, :persist,
-  :pexpire, :pexpireat, :psetex, :pttl, :publish, :rename, :renamenx,
-  :restore, :rpop, :rpoplpush, :rpush, :rpushx, :sadd, :scard,
-  :sdiff, :sdiffstore, :set, :setbit, :setex, :setnx, :setrange,
-  :sinter, :sinterstore, :sismember, :smembers, :smove, :sort, :spop,
-  :srandmember, :srem, :strlen, :subscribe, :sunion, :sunionstore,
-  :ttl, :type, :unsubscribe, :watch, :zadd, :zcard, :zcount,
-  :zincrby, :zinterstore, :zrange, :zrangebyscore, :zrank, :zrem,
-  :zremrangebyrank, :zremrangebyscore, :zrevrange, :zrevrangebyscore,
-  :zrevrank, :zscore, :zunionstore]
+  METHODS = [:append, :bitcount, :bitpos, :blpop, :brpop, :brpoplpush,
+    :decr, :decrby, :del, :dump, :exists, :expire, :expireat, :get,
+    :getbit, :getrange, :getset, :hdel, :hexists, :hget, :hgetall,
+    :hincrby, :hincrbyfloat, :hkeys, :hlen, :hmget, :hmset, :hset,
+    :hsetnx, :hstrlen, :hvals, :incr, :incrby, :incrbyfloat, :lindex,
+    :linsert, :llen, :lpop, :lpush, :lpushx, :lrange, :lrem, :lset,
+    :ltrim, :move, :persist, :pexpire, :pexpireat, :pfadd, :pfcount,
+    :pfmerge, :psetex, :pttl, :publish, :rename, :renamenx, :restore,
+    :rpop, :rpoplpush, :rpush, :rpushx, :sadd, :scard, :sdiff, :sdiffstore,
+    :set, :setbit, :setex, :setnx, :setrange, :sinter, :sinterstore,
+    :sismember, :smembers, :smove, :sort, :spop, :srandmember, :srem,
+    :strlen, :subscribe, :sunion, :sunionstore, :ttl, :type, :unsubscribe,
+    :watch, :zadd, :zcard, :zcount, :zincrby, :zinterstore, :zlexcount,
+    :zrange, :zrangebylex, :zrevrangebylex, :zrangebyscore, :zrank,
+    :zrem, :zremrangebylex, :zremrangebyrank, :zremrangebyscore,
+    :zrevrange, :zrevrangebyscore, :zrevrank, :zscore, :zunionstore,
+    :sscan, :hscan, :zscan]
 
   attr :redis
 
-  def initialize(key, redis = Redis.current)
+  def initialize(key, redis = Redic.new)
     super(key.to_s)
     @redis = redis
   end
@@ -29,8 +31,8 @@ class Nest < String
   end
 
   METHODS.each do |meth|
-    define_method(meth) do |*args, &block|
-      redis.send(meth, self, *args, &block)
+    define_method(meth) do |*args|
+      redis.call(meth, self, *args)
     end
   end
 end

data/nest.gemspec

@@ -1,13 +1,14 @@
 Gem::Specification.new do |s|
   s.name              = "nest"
-  s.version           = "1.1.2"
+  s.version           = "2.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.licenses          = ["MIT"]
   s.authors           = ["Michel Martens"]
   s.email             = ["michel@soveran.com"]
   s.homepage          = "http://github.com/soveran/nest"
 
-  s.add_dependency "redis"
+  s.add_dependency "redic"
 
   s.files = Dir[
     "LICENSE",

data/test/helper.rb

@@ -0,0 +1 @@
+require_relative "../lib/nest"

data/test/nest_test.rb

@@ -1,4 +1,4 @@
-require File.expand_path("test_helper", File.dirname(__FILE__))
+require_relative "helper"
 
 # Creating namespaces.
 scope do
@@ -37,8 +37,8 @@ end
 # Operating with redis.
 scope do
   prepare do
-    @redis = Redis.new
-    @redis.flushdb
+    @redis = Redic.new
+    @redis.call("FLUSHDB")
   end
 
   test "work if no redis instance was passed" do
@@ -58,53 +58,6 @@ scope do
   test "pass the redis instance to new keys" do
     n1 = Nest.new("foo", @redis)
 
-    assert @redis.id == n1["bar"].redis.id
-  end
-
-  test "PubSub" do
-    foo = Nest.new("foo", @redis)
-    listening = false
-    message_received = false
-
-    Thread.new do
-      while !listening; end
-      Nest.new("foo", Redis.new(:db => 15)).publish("")
-    end
-
-    foo.subscribe do |on|
-      on.message do
-        message_received = true
-
-        foo.unsubscribe
-      end
-
-      listening = true
-    end
-
-    assert message_received
-  end
-end
-
-scope do
-  prepare do
-    @redis1 = Redis.connect(:db => 15)
-    @redis2 = Redis.connect(:db => 14)
-
-    @redis1.flushdb
-    @redis2.flushdb
-  end
-
-  test "honors Redis.current" do
-    Redis.current = @redis1
-
-    foo = Nest.new("foo")
-
-    foo.set("bar")
-
-    assert_equal "bar", foo.get
-
-    Redis.current = @redis2
-
-    assert_equal nil, Nest.new("foo").get
+    assert @redis.object_id == n1["bar"].redis.object_id
   end
 end

metadata

@@ -1,38 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: nest
 version: !ruby/object:Gem::Version
-  version: 1.1.2
-  prerelease: 
+  version: 2.0.0
 platform: ruby
 authors:
 - Michel Martens
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-01 00:00:00.000000000 Z
+date: 2015-03-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: redis
-  requirement: &2156217380 !ruby/object:Gem::Requirement
-    none: false
+  name: redic
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2156217380
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: cutest
-  requirement: &2156229820 !ruby/object:Gem::Requirement
-    none: false
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2156229820
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 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:
@@ -46,30 +51,30 @@ files:
 - Rakefile
 - lib/nest.rb
 - nest.gemspec
+- test/helper.rb
 - test/nest_test.rb
-- test/test_helper.rb
 homepage: http://github.com/soveran/nest
-licenses: []
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 2.0.14
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Object-oriented keys for Redis.
 test_files: []

data/test/test_helper.rb

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