ohm 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 879b753fd8424a547c5cf83753b2f4d7dd817a14
-  data.tar.gz: fab1f4b6971328047ed17e37d589ebc47c32d082
+  metadata.gz: 9c7c0f6876c2563f59ad8e20dcbab465e5cffcb8
+  data.tar.gz: e4f06f406172d073ff4ae25ac2d4f9ebad74c034
 SHA512:
-  metadata.gz: 3538cccef143743083a6a31c672e4e5bacec42f743196fbcf52f1c68ca4ca3bcc3169f9633a40cdfc1633d48428c60e53e999641e252b640767d85b6b8db3117
-  data.tar.gz: b51d4ad91623b2357492837a37d1f0f03928e4a2e526849afe4cd558987089fab2a930233065d1230e6dd82c70c6c0341435c0fbbf7f9a467953480e09ec99c4
+  metadata.gz: 9a55ef1b2043b4950a617ffa984a01a410a2aea17d656072c4732a995d7dcff550b38437a60ad382b9f30f9b87a2541064597ccb40c3e70043cf38f2cb77638e
+  data.tar.gz: ef38056726cf8956480bf728150168a1d2dd1337b5987b9ce6845c771c05f1c53fc38d84d92bab4c8fa015e3069ddfb141f548eee6d68b051417608a9dd2cc23

data/.gems

@@ -1,4 +1,5 @@
-cutest -v 1.2.1
 msgpack -v 0.5.8
 nido -v 0.0.1
-redic -v 1.1.0
+redic -v 1.3.0
+cutest -v 1.2.2
+stal -v 0.1.0

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 2.2.0
+
+- Use Stal for set operations
+
+## 2.1.0
+
+- Add `combine` filter
+
 ## 2.0.0
 
 - Lists now respond to range.
@@ -228,6 +236,10 @@
 [scrivener]: https://github.com/soveran/scrivener
 [redic]: https://github.com/amakawa/redic
 
+## 1.4.0
+
+- Add `combine` filter
+
 ## 1.3.2
 
 - Fetching a batch of objects is now done in batches of 1000 objects at

data/examples/activity-feed.rb

@@ -29,18 +29,18 @@ class User < Ohm::Model
   # Because a `User` literally has a `list` of activities, using a Redis
   # `list` to model the activities would be a good choice. We default to
   # getting the first 100 activities, and use
-  # [lrange](http://code.google.com/p/redis/wiki/LrangeCommand) directly.
+  # [lrange](http://redis.io/commands/lrange) directly.
   def activities(start = 0, limit = 100)
-    key[:activities].lrange(start, start + limit)
+    redis.call 'LRANGE', key[:activities], start, start + limit
   end
 
   # Broadcasting a message to all the `followers` of a user would simply
   # be prepending the message for each if his `followers`. We also use
   # the Redis command
-  # [lpush](http://code.google.com/p/redis/wiki/RpushCommand) directly.
+  # [lpush](http://redis.io/commands/lpush) directly.
   def broadcast(str)
     followers.each do |user|
-      user.key[:activities].lpush(str)
+      redis.call 'LPUSH', user.key[:activities], str
     end
   end
 
@@ -81,8 +81,8 @@ end
 test "jane following john" do |john, jane|
   jane.follow(john)
 
-  assert [john] == jane.following.to_a
-  assert [jane] == john.followers.to_a
+  assert_equal [john], jane.following.to_a
+  assert_equal [jane], john.followers.to_a
 end
 
 # Broadcasting a message should simply notify all the followers of the
@@ -125,17 +125,12 @@ class User
   # We define a constant where we set the maximum number of activity entries.
   MAX = 10
 
-  # Using `MAX` as the reference, we check if the number of activities exceeds
-  # `MAX`, and use
-  # [ltrim](http://code.google.com/p/redis/wiki/LtrimCommand) to truncate
-  # the activities.
+  # Using `MAX` as the reference, we truncate the activities feed using
+  # [ltrim](http://redis.io/commands/ltrim).
   def broadcast(str)
     followers.each do |user|
-      user.key[:activities].lpush(str)
-
-      if user.key[:activities].llen > MAX
-        user.key[:activities].ltrim(0, MAX - 1)
-      end
+      redis.call 'LPUSH', user.key[:activities], str
+      redis.call 'LTRIM', user.key[:activities], 0, MAX - 1
     end
   end
 end
@@ -158,5 +153,5 @@ end
 #
 # As a final note, keep in mind that the Ohm solution would still need
 # sharding for large datasets, but that would be again trivial to implement
-# using [redis-rb](http://github.com/ezmobius/redis-rb)'s distributed support
+# using [redis-rb](http://github.com/redis/redis-rb)'s distributed support
 # and sharding it against the *user_id*.

data/examples/one-to-many.rb

@@ -29,11 +29,11 @@ require "ohm"
 
 # We define both a `Video` and `Audio` model, with a `list` of *comments*.
 class Video < Ohm::Model
-  list :comments, Comment
+  list :comments, :Comment
 end
 
 class Audio < Ohm::Model
-  list :comments, Comment
+  list :comments, :Comment
 end
 
 # The `Comment` model for this example will just contain one attribute called
@@ -65,10 +65,10 @@ test "adding all sorts of comments" do
   audio.comments.push(audio_comment)
 
   assert video.comments.include?(video_comment)
-  assert video.comments.size == 1
+  assert_equal video.comments.size, 1
 
   assert audio.comments.include?(audio_comment)
-  assert audio.comments.size == 1
+  assert_equal audio.comments.size, 1
 end
 
 
@@ -100,14 +100,8 @@ test "getting paged chunks of comments" do
 
   20.times { |i| video.comments.push(Comment.create(:body => "C#{i + 1}")) }
 
-  assert %w(C1 C2 C3 C4 C5)      ==  video.comments[0, 4].map(&:body)
-  assert %w(C6 C7 C8 C9 C10)     ==  video.comments[5, 9].map(&:body)
-
-  # ** Range style is also supported.
-  assert %w(C11 C12 C13 C14 C15) ==  video.comments[10..14].map(&:body)
-
-  # ** Also you can just pass in a single number.
-  assert "C16" == video.comments[15].body
+  assert_equal %w(C1 C2 C3 C4 C5),  video.comments.range(0, 4).map(&:body)
+  assert_equal %w(C6 C7 C8 C9 C10), video.comments.range(5, 9).map(&:body)
 end
 
 #### Caveats
@@ -121,4 +115,4 @@ end
 # `SORTED SET`, and to use the timestamp (or the negative of the timestamp) as
 # the score to maintain the desired order. Deleting a comment from a
 # `SORTED SET` would be a simple
-# [ZREM](http://code.google.com/p/redis/wiki/ZremCommand) call.
+# [ZREM](http://redis.io/commands/zrem) call.

data/lib/ohm.rb

@@ -3,8 +3,7 @@
 require "msgpack"
 require "nido"
 require "redic"
-require "securerandom"
-require_relative "ohm/command"
+require "stal"
 
 module Ohm
   LUA_CACHE   = Hash.new { |h, k| h[k] = Hash.new }
@@ -76,7 +75,7 @@ module Ohm
       Hash[*arr]
     end
 
-    def self.sort(redis, key, options)
+    def self.sort_options(options)
       args = []
 
       args.concat(["BY", options[:by]]) if options[:by]
@@ -85,7 +84,7 @@ module Ohm
       args.concat(options[:order].split(" ")) if options[:order]
       args.concat(["STORE", options[:store]]) if options[:store]
 
-      redis.call("SORT", key, *args)
+      return args
     end
   end
 
@@ -285,6 +284,7 @@ module Ohm
     #   # => true
     #
     def delete(model)
+
       # LREM key 0 <id> means remove all elements matching <id>
       # @see http://redis.io/commands/lrem
       redis.call("LREM", key, 0, model.id)
@@ -321,27 +321,103 @@ module Ohm
     end
   end
 
-  # Defines most of the methods used by `Set` and `MultiSet`.
-  class BasicSet
+  class Set
     include Collection
 
-    # Allows you to sort by any attribute in the hash, this doesn't include
-    # the +id+. If you want to sort by ID, use #sort.
+    attr :key
+    attr :model
+    attr :namespace
+
+    def initialize(model, namespace, key)
+      @model = model
+      @namespace = namespace
+      @key = key
+    end
+
+    # Retrieve a specific element using an ID from this set.
+    #
+    # Example:
+    #
+    #   # Let's say we got the ID 1 from a request parameter.
+    #   id = 1
+    #
+    #   # Retrieve the post if it's included in the user's posts.
+    #   post = user.posts[id]
+    #
+    def [](id)
+      model[id] if exists?(id)
+    end
+
+    # Returns an array with all the ID's of the set.
+    #
+    #   class Post < Ohm::Model
+    #   end
     #
     #   class User < Ohm::Model
     #     attribute :name
+    #     index :name
+    #
+    #     set :posts, :Post
     #   end
     #
-    #   User.all.sort_by(:name, :order => "ALPHA")
-    #   User.all.sort_by(:name, :order => "ALPHA DESC")
-    #   User.all.sort_by(:name, :order => "ALPHA DESC", :limit => [0, 10])
+    #   User.create(name: "John")
+    #   User.create(name: "Jane")
     #
-    # Note: This is slower compared to just doing `sort`, specifically
-    # because Redis has to read each individual hash in order to sort
-    # them.
+    #   User.all.ids
+    #   # => ["1", "2"]
     #
-    def sort_by(att, options = {})
-      sort(options.merge(:by => to_key(att)))
+    #   User.find(name: "John").union(name: "Jane").ids
+    #   # => ["1", "2"]
+    #
+    def ids
+      if Array === key
+        Stal.solve(redis, key)
+      else
+        redis.call("SMEMBERS", key)
+      end
+    end
+
+    # Returns the total size of the set using SCARD.
+    def size
+      Stal.solve(redis, ["SCARD", key])
+    end
+
+    # Returns +true+ if +id+ is included in the set. Otherwise, returns +false+.
+    #
+    # Example:
+    #
+    #   class Post < Ohm::Model
+    #   end
+    #
+    #   class User < Ohm::Model
+    #     set :posts, :Post
+    #   end
+    #
+    #   user = User.create
+    #   post = Post.create
+    #   user.posts.add(post)
+    #
+    #   user.posts.exists?('nonexistent') # => false
+    #   user.posts.exists?(post.id)       # => true
+    #
+    def exists?(id)
+      Stal.solve(redis, ["SISMEMBER", key, id]) == 1
+    end
+
+    # Check if a model is included in this set.
+    #
+    # Example:
+    #
+    #   u = User.create
+    #
+    #   User.all.include?(u)
+    #   # => true
+    #
+    # Note: Ohm simply checks that the model's ID is included in the
+    # set. It doesn't do any form of type checking.
+    #
+    def include?(model)
+      exists?(model.id)
     end
 
     # Allows you to sort your models using their IDs. This is much
@@ -370,31 +446,30 @@ module Ohm
     def sort(options = {})
       if options.has_key?(:get)
         options[:get] = to_key(options[:get])
-        return execute { |key| Utils.sort(redis, key, options) }
-      end
 
-      fetch(execute { |key| Utils.sort(redis, key, options) })
+        Stal.solve(redis, ["SORT", key, *Utils.sort_options(options)])
+      else
+        fetch(Stal.solve(redis, ["SORT", key, *Utils.sort_options(options)]))
+      end
     end
 
-    # Check if a model is included in this set.
-    #
-    # Example:
+    # Allows you to sort by any attribute in the hash, this doesn't include
+    # the +id+. If you want to sort by ID, use #sort.
     #
-    #   u = User.create
+    #   class User < Ohm::Model
+    #     attribute :name
+    #   end
     #
-    #   User.all.include?(u)
-    #   # => true
+    #   User.all.sort_by(:name, :order => "ALPHA")
+    #   User.all.sort_by(:name, :order => "ALPHA DESC")
+    #   User.all.sort_by(:name, :order => "ALPHA DESC", :limit => [0, 10])
     #
-    # Note: Ohm simply checks that the model's ID is included in the
-    # set. It doesn't do any form of type checking.
+    # Note: This is slower compared to just doing `sort`, specifically
+    # because Redis has to read each individual hash in order to sort
+    # them.
     #
-    def include?(model)
-      exists?(model.id)
-    end
-
-    # Returns the total size of the set using SCARD.
-    def size
-      execute { |key| redis.call("SCARD", key) }
+    def sort_by(att, options = {})
+      sort(options.merge(:by => to_key(att)))
     end
 
     # Syntactic sugar for `sort_by` or `sort` when you only need the
@@ -419,88 +494,6 @@ module Ohm
       end
     end
 
-    # Returns an array with all the ID's of the set.
-    #
-    #   class Post < Ohm::Model
-    #   end
-    #
-    #   class User < Ohm::Model
-    #     attribute :name
-    #     index :name
-    #
-    #     set :posts, :Post
-    #   end
-    #
-    #   User.create(name: "John")
-    #   User.create(name: "Jane")
-    #
-    #   User.all.ids
-    #   # => ["1", "2"]
-    #
-    #   User.find(name: "John").union(name: "Jane").ids
-    #   # => ["1", "2"]
-    #
-    def ids
-      execute { |key| redis.call("SMEMBERS", key) }
-    end
-
-    # Retrieve a specific element using an ID from this set.
-    #
-    # Example:
-    #
-    #   # Let's say we got the ID 1 from a request parameter.
-    #   id = 1
-    #
-    #   # Retrieve the post if it's included in the user's posts.
-    #   post = user.posts[id]
-    #
-    def [](id)
-      model[id] if exists?(id)
-    end
-
-    # Returns +true+ if +id+ is included in the set. Otherwise, returns +false+.
-    #
-    # Example:
-    #
-    #   class Post < Ohm::Model
-    #   end
-    #
-    #   class User < Ohm::Model
-    #     set :posts, :Post
-    #   end
-    #
-    #   user = User.create
-    #   post = Post.create
-    #   user.posts.add(post)
-    #
-    #   user.posts.exists?('nonexistent') # => false
-    #   user.posts.exists?(post.id)       # => true
-    #
-    def exists?(id)
-      execute { |key| redis.call("SISMEMBER", key, id) == 1 }
-    end
-
-  private
-    def to_key(att)
-      if model.counters.include?(att)
-        namespace["*:counters->%s" % att]
-      else
-        namespace["*->%s" % att]
-      end
-    end
-  end
-
-  class Set < BasicSet
-    attr :key
-    attr :namespace
-    attr :model
-
-    def initialize(key, namespace, model)
-      @key = key
-      @namespace = namespace
-      @model = model
-    end
-
     # Chain new fiters on an existing set.
     #
     # Example:
@@ -509,8 +502,8 @@ module Ohm
     #   set.find(:age => 30)
     #
     def find(dict)
-      MultiSet.new(
-        namespace, model, Command[:sinterstore, key, *model.filters(dict)]
+      Ohm::Set.new(
+        model, namespace, [:SINTER, key, *model.filters(dict)]
       )
     end
 
@@ -525,7 +518,9 @@ module Ohm
     #   User.find(:name => "John").except(:country => "US")
     #
     def except(dict)
-      MultiSet.new(namespace, model, key).except(dict)
+      Ohm::Set.new(
+        model, namespace, [:SDIFF, key, [:SUNION, *model.filters(dict)]]
+      )
     end
 
     # Perform an intersection between the existent set and
@@ -539,7 +534,9 @@ module Ohm
     #   # The result will include all users with active status
     #   # and with names "John" or "Jane".
     def combine(dict)
-      MultiSet.new(namespace, model, key).combine(dict)
+      Ohm::Set.new(
+        model, namespace, [:SINTER, key, [:SUNION, *model.filters(dict)]]
+      )
     end
 
     # Do a union to the existing set using any number of filters.
@@ -553,12 +550,18 @@ module Ohm
     #   User.find(:name => "John").union(:name => "Jane")
     #
     def union(dict)
-      MultiSet.new(namespace, model, key).union(dict)
+      Ohm::Set.new(
+        model, namespace, [:SUNION, key, [:SINTER, *model.filters(dict)]]
+      )
     end
 
   private
-    def execute
-      yield key
+    def to_key(att)
+      if model.counters.include?(att)
+        namespace["*:counters->%s" % att]
+      else
+        namespace["*->%s" % att]
+      end
     end
 
     def redis
@@ -567,6 +570,7 @@ module Ohm
   end
 
   class MutableSet < Set
+
     # Add a model directly to the set.
     #
     # Example:
@@ -624,128 +628,6 @@ module Ohm
     end
   end
 
-  # Anytime you filter a set with more than one requirement, you
-  # internally use a `MultiSet`. `MultiSet` is a bit slower than just
-  # a `Set` because it has to `SINTERSTORE` all the keys prior to
-  # retrieving the members, size, etc.
-  #
-  # Example:
-  #
-  #   User.all.kind_of?(Ohm::Set)
-  #   # => true
-  #
-  #   User.find(:name => "John").kind_of?(Ohm::Set)
-  #   # => true
-  #
-  #   User.find(:name => "John", :age => 30).kind_of?(Ohm::MultiSet)
-  #   # => true
-  #
-  class MultiSet < BasicSet
-    attr :namespace
-    attr :model
-    attr :command
-
-    def initialize(namespace, model, command)
-      @namespace = namespace
-      @model = model
-      @command = command
-    end
-
-    # Chain new fiters on an existing set.
-    #
-    # Example:
-    #
-    #   set = User.find(:name => "John", :age => 30)
-    #   set.find(:status => 'pending')
-    #
-    def find(dict)
-      MultiSet.new(
-        namespace, model, Command[:sinterstore, command, intersected(dict)]
-      )
-    end
-
-    # Reduce the set using any number of filters.
-    #
-    # Example:
-    #
-    #   set = User.find(:name => "John")
-    #   set.except(:country => "US")
-    #
-    #   # You can also do it in one line.
-    #   User.find(:name => "John").except(:country => "US")
-    #
-    def except(dict)
-      MultiSet.new(
-        namespace, model, Command[:sdiffstore, command, unioned(dict)]
-      )
-    end
-
-    # Perform an intersection between the existent set and
-    # the new set created by the union of the passed filters.
-    #
-    # Example:
-    #
-    #   set = User.find(:status => "active")
-    #   set.combine(:name => ["John", "Jane"])
-    #   
-    #   # The result will include all users with active status
-    #   # and with names "John" or "Jane".
-    def combine(dict)
-      MultiSet.new(
-        namespace, model, Command[:sinterstore, command, unioned(dict)]
-      )
-    end
-
-    # Do a union to the existing set using any number of filters.
-    #
-    # Example:
-    #
-    #   set = User.find(:name => "John")
-    #   set.union(:name => "Jane")
-    #
-    #   # You can also do it in one line.
-    #   User.find(:name => "John").union(:name => "Jane")
-    #
-    def union(dict)
-      MultiSet.new(
-        namespace, model, Command[:sunionstore, command, intersected(dict)]
-      )
-    end
-
-  private
-    def redis
-      model.redis
-    end
-
-    def intersected(dict)
-      Command[:sinterstore, *model.filters(dict)]
-    end
-
-    def unioned(dict)
-      Command[:sunionstore, *model.filters(dict)]
-    end
-
-    def execute
-      # namespace[:tmp] is where all the temp keys should be stored in.
-      # redis will be where all the commands are executed against.
-      response = command.call(namespace[:tmp], redis)
-
-      begin
-
-        # At this point, we have the final aggregated set, which we yield
-        # to the caller. the caller can do all the normal set operations,
-        # i.e. SCARD, SMEMBERS, etc.
-        yield response
-
-      ensure
-
-        # We have to make sure we clean up the temporary keys to avoid
-        # memory leaks and the unintended explosion of memory usage.
-        command.clean
-      end
-    end
-  end
-
   # The base class for all your models. In order to better understand
   # it, here is a semi-realtime explanation of the details involved
   # when creating a User instance.
@@ -927,9 +809,9 @@ module Ohm
       keys = filters(dict)
 
       if keys.size == 1
-        Ohm::Set.new(keys.first, key, self)
+        Ohm::Set.new(self, key, keys.first)
       else
-        Ohm::MultiSet.new(key, self, Command.new(:sinterstore, *keys))
+        Ohm::Set.new(self, key, [:SINTER, *keys])
       end
     end
 
@@ -980,7 +862,7 @@ module Ohm
       define_method name do
         model = Utils.const(self.class, model)
 
-        Ohm::MutableSet.new(key[name], model.key, model)
+        Ohm::MutableSet.new(model, model.key, key[name])
       end
     end
 
@@ -1190,7 +1072,7 @@ module Ohm
 
     # An Ohm::Set wrapper for Model.key[:all].
     def self.all
-      Set.new(key[:all], key, self)
+      Ohm::Set.new(self, key, key[:all])
     end
 
     # Syntactic sugar for Model.new(atts).save

data/makefile

@@ -1,4 +1,9 @@
-.PHONY: test
+.PHONY: all test examples
+
+all: test
 
 test:
 	cutest -r ./test/helper.rb ./test/*.rb
+
+examples:
+	RUBYLIB="./lib" cutest ./examples/*.rb

data/ohm.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "ohm"
-  s.version = "2.1.0"
+  s.version = "2.2.0"
   s.summary = %{Object-hash mapping library for Redis.}
   s.description = %Q{Ohm is a library that allows to store an object in Redis, a persistent key-value database. It has very good performance.}
   s.authors = ["Michel Martens", "Damian Janowski", "Cyril David"]
@@ -14,6 +14,7 @@ Gem::Specification.new do |s|
 
   s.add_dependency "redic"
   s.add_dependency "nido"
+  s.add_dependency "stal"
   s.add_dependency "msgpack"
 
   s.add_development_dependency "cutest"

data/test/indices.rb

@@ -54,12 +54,6 @@ test "avoid intersections with the all collection" do
   assert_equal "User:indices:email:foo", User.find(:email => "foo").key
 end
 
-test "cleanup the temporary key after use" do
-  assert User.find(:email => "foo", :activation_code => "bar").to_a
-
-  assert Ohm.redis.call("KEYS", "User:temp:*").empty?
-end
-
 test "allow multiple chained finds" do
   assert 1 == User.find(:email => "foo").find(:activation_code => "bar").find(:update => "baz").size
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ohm
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Michel Martens
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-22 00:00:00.000000000 Z
+date: 2015-03-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redic
@@ -40,6 +40,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: stal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: msgpack
   requirement: !ruby/object:Gem::Requirement
@@ -95,14 +109,12 @@ files:
 - examples/slug.rb
 - examples/tagging.rb
 - lib/ohm.rb
-- lib/ohm/command.rb
 - lib/ohm/json.rb
 - lib/ohm/lua/delete.lua
 - lib/ohm/lua/save.lua
 - makefile
 - ohm.gemspec
 - test/association.rb
-- test/command.rb
 - test/connection.rb
 - test/core.rb
 - test/counters.rb
@@ -143,4 +155,3 @@ signing_key:
 specification_version: 4
 summary: Object-hash mapping library for Redis.
 test_files: []
-has_rdoc: 

data/lib/ohm/command.rb

@@ -1,51 +0,0 @@
-module Ohm
-  class Command
-    def self.[](operation, head, *tail)
-      return head if tail.empty?
-
-      new(operation, head, *tail)
-    end
-
-    attr :operation
-    attr :args
-    attr :keys
-
-    def initialize(operation, *args)
-      @operation = operation
-      @args = args
-      @keys = []
-    end
-
-    def call(nido, redis)
-      newkey(nido, redis) do |key|
-        redis.call(@operation, key, *params(nido, redis))
-      end
-    end
-
-    def clean
-      keys.each do |key, redis|
-        redis.call("DEL", key)
-      end
-
-      subcommands.each { |cmd| cmd.clean }
-    end
-
-  private
-    def subcommands
-      args.select { |arg| arg.respond_to?(:call) }
-    end
-
-    def params(nido, redis)
-      args.map { |arg| arg.respond_to?(:call) ? arg.call(nido, redis) : arg }
-    end
-
-    def newkey(nido, redis)
-      key = nido[SecureRandom.hex(32)]
-      keys << [key, redis]
-
-      yield key
-
-      return key
-    end
-  end
-end

data/test/command.rb

@@ -1,55 +0,0 @@
-require_relative "helper"
-
-scope do
-  setup do
-    redis = Redic.new
-    redis.call("FLUSHDB")
-
-    nido = Nido.new("User:tmp")
-
-    [1, 2, 3].each { |i| redis.call("SADD", "A", i) }
-    [1, 4, 5].each { |i| redis.call("SADD", "B", i) }
-
-    [10, 11, 12].each { |i| redis.call("SADD", "C", i) }
-    [11, 12, 13].each { |i| redis.call("SADD", "D", i) }
-    [12, 13, 14].each { |i| redis.call("SADD", "E", i) }
-
-    [10, 11, 12].each { |i| redis.call("SADD", "F", i) }
-    [11, 12, 13].each { |i| redis.call("SADD", "G", i) }
-    [12, 13, 14].each { |i| redis.call("SADD", "H", i) }
-
-    [redis, nido]
-  end
-
-  test "special condition: single argument returns that arg" do
-    assert_equal "A", Ohm::Command[:sinterstore, "A"]
-  end
-
-  test "full stack test"  do |redis, nido|
-    cmd1 = Ohm::Command[:sinterstore, "A", "B"]
-
-    res = cmd1.call(nido, redis)
-    assert_equal ["1"], redis.call("SMEMBERS", res)
-
-    cmd1.clean
-    assert_equal 0, redis.call("EXISTS", res)
-
-    cmd2 = Ohm::Command[:sinterstore, "C", "D", "E"]
-    cmd3 = Ohm::Command[:sunionstore, cmd1, cmd2]
-
-    res = cmd3.call(nido, redis)
-    assert_equal ["1", "12"], redis.call("SMEMBERS", res)
-
-    cmd3.clean
-    assert redis.call("KEYS", nido["*"]).empty?
-
-    cmd4 = Ohm::Command[:sinterstore, "F", "G", "H"]
-    cmd5 = Ohm::Command[:sdiffstore, cmd3, cmd4]
-
-    res = cmd5.call(nido, redis)
-    assert_equal ["1"], redis.call("SMEMBERS", res)
-
-    cmd5.clean
-    assert redis.call("KEYS", nido["*"]).empty?
-  end
-end