plucky 0.5.2 → 0.6.0

data/spec/plucky_spec.rb

@@ -0,0 +1,68 @@
+require 'helper'
+
+describe Plucky do
+  describe ".to_object_id" do
+    before do
+      @id = BSON::ObjectId.new
+    end
+
+    it "converts nil to nil" do
+      Plucky.to_object_id(nil).should be_nil
+    end
+
+    it "converts blank to nil" do
+      Plucky.to_object_id('').should be_nil
+    end
+
+    it "leaves object id alone" do
+      Plucky.to_object_id(@id).should equal(@id)
+    end
+
+    it "converts string to object id" do
+      Plucky.to_object_id(@id.to_s).should == @id
+    end
+
+    it "not convert string that is not legal object id" do
+      Plucky.to_object_id('foo').should == 'foo'
+      Plucky.to_object_id(1).should == 1
+    end
+  end
+
+  describe ".modifier?" do
+    context "with a string" do
+      it "returns true if modifier" do
+        Plucky.modifier?('$in').should be_true
+      end
+
+      it "returns false if not modifier" do
+        Plucky.modifier?('nope').should be_false
+      end
+    end
+
+    context "with a symbol" do
+      it "returns true if modifier" do
+        Plucky.modifier?(:$in).should be_true
+      end
+
+      it "returns false if not modifier" do
+        Plucky.modifier?(:nope).should be_false
+      end
+    end
+  end
+
+  describe "::Methods" do
+    it "returns array of methods" do
+      Plucky::Methods.should == [
+        :where, :filter,
+        :sort, :order, :reverse,
+        :paginate, :per_page, :limit, :skip, :offset,
+        :fields, :ignore, :only,
+        :each, :find_each, :find_one, :find,
+        :count, :size, :distinct,
+        :last, :first, :all, :to_a,
+        :exists?, :exist?, :empty?,
+        :remove,
+      ].sort_by(&:to_s)
+    end
+  end
+end

data/{test/test_symbol_operator.rb → spec/symbol_operator_spec.rb}

@@ -1,55 +1,53 @@
 require 'helper'
 
-class SymbolOperatorTest < Test::Unit::TestCase
+describe SymbolOperator do
   context "SymbolOperator" do
-    setup   { @operator = SymbolOperator.new(:foo, 'in') }
+    before  { @operator = SymbolOperator.new(:foo, 'in') }
     subject { @operator }
 
-    should "have field" do
+    it "has field" do
       subject.field.should == :foo
     end
 
-    should "have operator" do
+    it "has operator" do
       subject.operator.should == 'in'
     end
 
     context "==" do
-      should "be true if field and operator are equal" do
+      it "returns true if field and operator are equal" do
         SymbolOperator.new(:foo, 'in').should == SymbolOperator.new(:foo, 'in')
       end
 
-      should "be false if fields are equal but operators are not" do
+      it "returns false if fields are equal but operators are not" do
         SymbolOperator.new(:foo, 'in').should_not == SymbolOperator.new(:foo, 'all')
       end
 
-      should "be false if operators are equal but fields are not" do
+      it "returns false if operators are equal but fields are not" do
         SymbolOperator.new(:foo, 'in').should_not == SymbolOperator.new(:bar, 'in')
       end
 
-      should "be false if neither are equal" do
+      it "returns false if neither are equal" do
         SymbolOperator.new(:foo, 'in').should_not == SymbolOperator.new(:bar, 'all')
       end
 
-      should "be false if other isn't an symbol operator" do
-        assert_nothing_raised do
-          SymbolOperator.new(:foo, 'in').should_not == 'foo.in'
-        end
+      it "returns false if other isn't an symbol operator" do
+        SymbolOperator.new(:foo, 'in').should_not == 'foo.in'
       end
     end
 
     context "<=>" do
-      should "same field, different operator" do
+      it "returns string comparison of operator for same field, different operator" do
         (SymbolOperator.new(:foo, 'in') <=> SymbolOperator.new(:foo, 'all')).should ==  1
         (SymbolOperator.new(:foo, 'all') <=> SymbolOperator.new(:foo, 'in')).should == -1
       end
 
-      should "same field same operator" do
+      it "returns 0 for same field same operator" do
         (SymbolOperator.new(:foo, 'in') <=> SymbolOperator.new(:foo, 'in')).should == 0
       end
 
-      should "different field" do
+      it "returns 1 for different field" do
         (SymbolOperator.new(:foo, 'in') <=> SymbolOperator.new(:bar, 'in')).should == 1
       end
     end
   end
-end
+end

data/spec/symbol_spec.rb

@@ -0,0 +1,9 @@
+require 'helper'
+
+describe Symbol do
+  SymbolOperators.each do |operator|
+    it "responds to #{operator}" do
+      :foo.send(operator).should be_instance_of(SymbolOperator)
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: plucky
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.6.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-12 00:00:00.000000000 Z
+date: 2012-12-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongo
-  requirement: &70317435688340 !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,7 +21,12 @@ dependencies:
         version: '1.5'
   type: :runtime
   prerelease: false
-  version_requirements: *70317435688340
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
 description: 
 email:
 - nunemaker@gmail.com
@@ -29,9 +34,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- .bundle/config
 - .gitignore
 - .travis.yml
 - Gemfile
+- Guardfile
 - LICENSE
 - README.md
 - Rakefile
@@ -43,6 +50,13 @@ files:
 - lib/plucky/extensions/duplicable.rb
 - lib/plucky/extensions/symbol.rb
 - lib/plucky/new_relic.rb
+- lib/plucky/normalizers/criteria_hash_key.rb
+- lib/plucky/normalizers/criteria_hash_value.rb
+- lib/plucky/normalizers/fields_value.rb
+- lib/plucky/normalizers/integer.rb
+- lib/plucky/normalizers/options_hash_key.rb
+- lib/plucky/normalizers/options_hash_value.rb
+- lib/plucky/normalizers/sort_value.rb
 - lib/plucky/options_hash.rb
 - lib/plucky/pagination.rb
 - lib/plucky/pagination/decorator.rb
@@ -50,16 +64,24 @@ files:
 - lib/plucky/query.rb
 - lib/plucky/version.rb
 - plucky.gemspec
+- script/criteria_hash.rb
+- spec/helper.rb
+- spec/plucky/criteria_hash_spec.rb
+- spec/plucky/normalizers/criteria_hash_key_spec.rb
+- spec/plucky/normalizers/criteria_hash_value_spec.rb
+- spec/plucky/normalizers/fields_value_spec.rb
+- spec/plucky/normalizers/integer_spec.rb
+- spec/plucky/normalizers/options_hash_key_spec.rb
+- spec/plucky/normalizers/options_hash_value_spec.rb
+- spec/plucky/normalizers/sort_value_spec.rb
+- spec/plucky/options_hash_spec.rb
+- spec/plucky/pagination/decorator_spec.rb
+- spec/plucky/pagination/paginator_spec.rb
+- spec/plucky/query_spec.rb
+- spec/plucky_spec.rb
+- spec/symbol_operator_spec.rb
+- spec/symbol_spec.rb
 - specs.watchr
-- test/helper.rb
-- test/plucky/pagination/test_decorator.rb
-- test/plucky/pagination/test_paginator.rb
-- test/plucky/test_criteria_hash.rb
-- test/plucky/test_options_hash.rb
-- test/plucky/test_query.rb
-- test/test_plucky.rb
-- test/test_symbol.rb
-- test/test_symbol_operator.rb
 homepage: http://jnunemaker.github.com/plucky/
 licenses: []
 post_install_message: 
@@ -72,26 +94,39 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 3663631979890408625
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: 3663631979890408625
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Thin layer over the ruby driver that allows you to quickly grab hold of your
   data (pluck it!).
 test_files:
-- test/helper.rb
-- test/plucky/pagination/test_decorator.rb
-- test/plucky/pagination/test_paginator.rb
-- test/plucky/test_criteria_hash.rb
-- test/plucky/test_options_hash.rb
-- test/plucky/test_query.rb
-- test/test_plucky.rb
-- test/test_symbol.rb
-- test/test_symbol_operator.rb
+- spec/helper.rb
+- spec/plucky/criteria_hash_spec.rb
+- spec/plucky/normalizers/criteria_hash_key_spec.rb
+- spec/plucky/normalizers/criteria_hash_value_spec.rb
+- spec/plucky/normalizers/fields_value_spec.rb
+- spec/plucky/normalizers/integer_spec.rb
+- spec/plucky/normalizers/options_hash_key_spec.rb
+- spec/plucky/normalizers/options_hash_value_spec.rb
+- spec/plucky/normalizers/sort_value_spec.rb
+- spec/plucky/options_hash_spec.rb
+- spec/plucky/pagination/decorator_spec.rb
+- spec/plucky/pagination/paginator_spec.rb
+- spec/plucky/query_spec.rb
+- spec/plucky_spec.rb
+- spec/symbol_operator_spec.rb
+- spec/symbol_spec.rb

data/test/plucky/pagination/test_paginator.rb

@@ -1,120 +0,0 @@
-require 'helper'
-
-class PaginatorTest < Test::Unit::TestCase
-  include Plucky::Pagination
-
-  context "#initialize" do
-    context "with total and page" do
-      setup   { @paginator = Paginator.new(20, 2) }
-      subject { @paginator }
-
-      should "set total" do
-        subject.total_entries.should == 20
-      end
-
-      should "set page" do
-        subject.current_page.should == 2
-      end
-
-      should "default per_page to 25" do
-        subject.per_page.should == 25
-      end
-    end
-
-    context "with total, page and per_page" do
-      setup   { @paginator = Paginator.new(20, 2, 10) }
-      subject { @paginator }
-
-      should "set total" do
-        subject.total_entries.should == 20
-      end
-
-      should "set page" do
-        subject.current_page.should == 2
-      end
-
-      should "set per_page" do
-        subject.per_page.should == 10
-      end
-    end
-
-    context "with string values for total, page and per_page" do
-      setup   { @paginator = Paginator.new('20', '2', '10') }
-      subject { @paginator }
-
-      should "set total" do
-        subject.total_entries.should == 20
-      end
-
-      should "set page" do
-        subject.current_page.should == 2
-      end
-
-      should "set per_page" do
-        subject.per_page.should == 10
-      end
-    end
-
-    context "with page less than 1" do
-      setup   { @paginator = Paginator.new(20, -2, 10) }
-      subject { @paginator }
-
-      should "set page to 1" do
-        subject.current_page.should == 1
-      end
-    end
-  end
-
-  should "alias limit to per_page" do
-    Paginator.new(30, 2, 30).limit.should == 30
-  end
-
-  should "be know total number of pages" do
-    Paginator.new(43, 2, 7).total_pages.should == 7
-    Paginator.new(40, 2, 10).total_pages.should == 4
-  end
-
-  context "#out_of_bounds?" do
-    should "be true if current_page is greater than total_pages" do
-      Paginator.new(2, 3, 1).should be_out_of_bounds
-    end
-
-    should "be false if current page is less than total_pages" do
-      Paginator.new(2, 1, 1).should_not be_out_of_bounds
-    end
-
-    should "be false if current page equals total_pages" do
-      Paginator.new(2, 2, 1).should_not be_out_of_bounds
-    end
-  end
-
-  context "#previous_page" do
-    should "be nil if there is no page less than current" do
-      Paginator.new(2, 1, 1).previous_page.should be_nil
-    end
-
-    should "be number less than current page if there is one" do
-      Paginator.new(2, 2, 1).previous_page.should == 1
-    end
-  end
-
-  context "#next_page" do
-    should "be nil if no page greater than current page" do
-      Paginator.new(2, 2, 1).next_page.should be_nil
-    end
-
-    should "be number greater than current page if there is one" do
-      Paginator.new(2, 1, 1).next_page.should == 2
-    end
-  end
-
-  context "#skip" do
-    should "work" do
-      Paginator.new(30, 3, 10).skip.should == 20
-    end
-
-    should "be aliased to offset for will paginate" do
-      Paginator.new(30, 3, 10).offset.should == 20
-    end
-  end
-end

data/test/plucky/test_criteria_hash.rb

@@ -1,359 +0,0 @@
-require 'helper'
-
-class CriteriaHashTest < Test::Unit::TestCase
-  include Plucky
-
-  context "Plucky::CriteriaHash" do
-    should "delegate missing methods to the source hash" do
-      hash = {:baz => 'wick', :foo => 'bar'}
-      criteria = CriteriaHash.new(hash)
-      criteria[:foo].should == 'bar'
-      criteria[:baz].should == 'wick'
-      criteria.keys.to_set.should == [:baz, :foo].to_set
-    end
-
-    SymbolOperators.each do |operator|
-      should "work with #{operator} symbol operator" do
-        CriteriaHash.new(:age.send(operator) => 21)[:age].should == {"$#{operator}" => 21}
-      end
-    end
-
-    should "handle multiple symbol operators on the same field" do
-      CriteriaHash.new(:age.gt => 12, :age.lt => 20)[:age].should == {
-        '$gt' => 12, '$lt' => 20
-      }
-    end
-
-    context "nested clauses" do
-      context "::NestingOperators" do
-        should "return array of operators that take nested queries" do
-          CriteriaHash::NestingOperators.should == [:$or, :$and, :$nor]
-        end
-      end
-
-      CriteriaHash::NestingOperators.each do |operator|
-        context "#{operator}" do
-          should "work with symbol operators" do
-            nested1     = {:age.gt   => 12, :age.lt => 20}
-            translated1 = {:age      => {'$gt'  => 12, '$lt'  => 20 }}
-            nested2     = {:type.nin => ['friend', 'enemy']}
-            translated2 = {:type     => {'$nin' => ['friend', 'enemy']}}
-
-            given       = {operator.to_s => [nested1, nested2]}
-
-            CriteriaHash.new(given)[operator].should == [translated1, translated2]
-          end
-
-          should "honor criteria hash options" do
-            nested     = {:post_id  => '4f5ead6378fca23a13000001'}
-            translated = {:post_id  => BSON::ObjectId.from_string('4f5ead6378fca23a13000001')}
-            given      = {operator.to_s => [nested]}
-
-            CriteriaHash.new(given, :object_ids => [:post_id])[operator].should == [translated]
-          end
-        end
-      end
-
-      context "doubly nested" do
-        should "work with symbol operators" do
-          nested1     = {:age.gt   => 12, :age.lt => 20}
-          translated1 = {:age      => {'$gt' => 12, '$lt' => 20}}
-          nested2     = {:type.nin => ['friend', 'enemy']}
-          translated2 = {:type     => {'$nin' => ['friend', 'enemy']}}
-          nested3     = {'$and'    => [nested2]}
-          translated3 = {:$and     => [translated2]}
-
-          given       = {'$or'     => [nested1, nested3]}
-
-          CriteriaHash.new(given)[:$or].should == [translated1, translated3]
-        end
-      end
-    end
-
-    context "#initialize_copy" do
-      setup do
-        @original = CriteriaHash.new({
-          :comments => {:_id => 1}, :tags => ['mongo', 'ruby'],
-        }, :object_ids => [:_id])
-        @cloned   = @original.clone
-      end
-
-      should "duplicate source hash" do
-        @cloned.source.should_not equal(@original.source)
-      end
-
-      should "duplicate options hash" do
-        @cloned.options.should_not equal(@original.options)
-      end
-
-      should "clone duplicable? values" do
-        @cloned[:comments].should_not equal(@original[:comments])
-        @cloned[:tags].should_not equal(@original[:tags])
-      end
-    end
-
-    context "#object_ids=" do
-      should "work with array" do
-        criteria = CriteriaHash.new
-        criteria.object_ids = [:_id]
-        criteria.object_ids.should == [:_id]
-      end
-
-      should "flatten multi-dimensional array" do
-        criteria = CriteriaHash.new
-        criteria.object_ids = [[:_id]]
-        criteria.object_ids.should == [:_id]
-      end
-
-      should "raise argument error if not array" do
-        assert_raises(ArgumentError) { CriteriaHash.new.object_ids = {} }
-        assert_raises(ArgumentError) { CriteriaHash.new.object_ids = nil }
-        assert_raises(ArgumentError) { CriteriaHash.new.object_ids = 'foo' }
-      end
-    end
-
-    context "#[]=" do
-      should "leave string values for string keys alone" do
-        criteria = CriteriaHash.new
-        criteria[:foo] = 'bar'
-        criteria[:foo].should == 'bar'
-      end
-
-      should "convert string values to object ids for object id keys" do
-        id = BSON::ObjectId.new
-        criteria = CriteriaHash.new({}, :object_ids => [:_id])
-        criteria[:_id] = id.to_s
-        criteria[:_id].should == id
-      end
-
-      should "convert sets to arrays" do
-        criteria = CriteriaHash.new
-        criteria[:foo] = [1, 2].to_set
-        criteria[:foo].should == {'$in' => [1, 2]}
-      end
-
-      should "convert times to utc" do
-        time = Time.now
-        criteria = CriteriaHash.new
-        criteria[:foo] = time
-        criteria[:foo].should be_utc
-        criteria[:foo].should == time.utc
-      end
-
-      should "convert :id to :_id" do
-        criteria = CriteriaHash.new
-        criteria[:id] = 1
-        criteria[:_id].should == 1
-        criteria[:id].should be_nil
-      end
-
-      should "work with symbol operators" do
-        criteria = CriteriaHash.new
-        criteria[:_id.in] = ['foo']
-        criteria[:_id].should == {'$in' => ['foo']}
-      end
-
-      should "set each of the conditions pairs" do
-        criteria = CriteriaHash.new
-        criteria[:conditions] = {:_id => 'john', :foo => 'bar'}
-        criteria[:_id].should == 'john'
-        criteria[:foo].should == 'bar'
-      end
-    end
-
-    context "with id key" do
-      should "convert to _id" do
-        id = BSON::ObjectId.new
-        criteria = CriteriaHash.new(:id => id)
-        criteria[:_id].should == id
-        criteria[:id].should be_nil
-      end
-
-      should "convert id with symbol operator to _id with modifier" do
-        id = BSON::ObjectId.new
-        criteria = CriteriaHash.new(:id.ne => id)
-        criteria[:_id].should == {'$ne' => id}
-        criteria[:id].should be_nil
-      end
-    end
-
-    context "with time value" do
-      should "convert to utc if not utc" do
-        CriteriaHash.new(:created_at => Time.now)[:created_at].utc?.should be(true)
-      end
-
-      should "leave utc alone" do
-        CriteriaHash.new(:created_at => Time.now.utc)[:created_at].utc?.should be(true)
-      end
-    end
-
-    context "with array value" do
-      should "default to $in" do
-        CriteriaHash.new(:numbers => [1,2,3])[:numbers].should == {'$in' => [1,2,3]}
-      end
-
-      should "use existing modifier if present" do
-        CriteriaHash.new(:numbers => {'$all' => [1,2,3]})[:numbers].should == {'$all' => [1,2,3]}
-        CriteriaHash.new(:numbers => {'$any' => [1,2,3]})[:numbers].should == {'$any' => [1,2,3]}
-      end
-
-      should "not turn value to $in with $or key" do
-        CriteriaHash.new(:$or => [{:numbers => 1}, {:numbers => 2}] )[:$or].should == [{:numbers=>1}, {:numbers=>2}]
-      end
-
-      should "not turn value to $in with $and key" do
-        CriteriaHash.new(:$and => [{:numbers => 1}, {:numbers => 2}] )[:$and].should == [{:numbers=>1}, {:numbers=>2}]
-      end
-
-      should "not turn value to $in with $nor key" do
-        CriteriaHash.new(:$nor => [{:numbers => 1}, {:numbers => 2}] )[:$nor].should == [{:numbers=>1}, {:numbers=>2}]
-      end
-
-      should "default to $in even with ObjectId keys" do
-        CriteriaHash.new({:mistake_id => [1,2,3]}, :object_ids => [:mistake_id])[:mistake_id].should == {'$in' => [1,2,3]}
-      end
-    end
-
-    context "with set value" do
-      should "default to $in and convert to array" do
-        CriteriaHash.new(:numbers => [1,2,3].to_set)[:numbers].should == {'$in' => [1,2,3]}
-      end
-
-      should "use existing modifier if present and convert to array" do
-        CriteriaHash.new(:numbers => {'$all' => [1,2,3].to_set})[:numbers].should == {'$all' => [1,2,3]}
-        CriteriaHash.new(:numbers => {'$any' => [1,2,3].to_set})[:numbers].should == {'$any' => [1,2,3]}
-      end
-    end
-
-    context "with string ids for string keys" do
-      setup do
-        @id       = BSON::ObjectId.new
-        @room_id  = BSON::ObjectId.new
-        @criteria = CriteriaHash.new(:_id => @id.to_s, :room_id => @room_id.to_s)
-      end
-
-      should "leave string ids as strings" do
-        @criteria[:_id].should     == @id.to_s
-        @criteria[:room_id].should == @room_id.to_s
-        @criteria[:_id].should     be_instance_of(String)
-        @criteria[:room_id].should be_instance_of(String)
-      end
-    end
-
-    context "with string ids for object id keys" do
-      setup do
-        @id       = BSON::ObjectId.new
-        @room_id  = BSON::ObjectId.new
-      end
-
-      should "convert strings to object ids" do
-        criteria = CriteriaHash.new({:_id => @id.to_s, :room_id => @room_id.to_s}, :object_ids => [:_id, :room_id])
-        criteria[:_id].should     == @id
-        criteria[:room_id].should == @room_id
-        criteria[:_id].should     be_instance_of(BSON::ObjectId)
-        criteria[:room_id].should be_instance_of(BSON::ObjectId)
-      end
-
-      should "convert :id with string value to object id value" do
-        criteria = CriteriaHash.new({:id => @id.to_s}, :object_ids => [:_id])
-        criteria[:_id].should == @id
-      end
-    end
-
-    context "with string ids for object id keys (nested)" do
-      setup do
-        @id1      = BSON::ObjectId.new
-        @id2      = BSON::ObjectId.new
-        @ids      = [@id1.to_s, @id2.to_s]
-        @criteria = CriteriaHash.new({:_id => {'$in' => @ids}}, :object_ids => [:_id])
-      end
-
-      should "convert strings to object ids" do
-        @criteria[:_id].should == {'$in' => [@id1, @id2]}
-      end
-
-      should "not modify original array of string ids" do
-        @ids.should == [@id1.to_s, @id2.to_s]
-      end
-    end
-
-    context "#merge" do
-      should "work when no keys match" do
-        c1 = CriteriaHash.new(:foo => 'bar')
-        c2 = CriteriaHash.new(:baz => 'wick')
-        c1.merge(c2).should == CriteriaHash.new(:foo => 'bar', :baz => 'wick')
-      end
-
-      should "turn matching keys with simple values into array" do
-        c1 = CriteriaHash.new(:foo => 'bar')
-        c2 = CriteriaHash.new(:foo => 'baz')
-        c1.merge(c2).should == CriteriaHash.new(:foo => {'$in' => %w[bar baz]})
-      end
-
-      should "unique matching key values" do
-        c1 = CriteriaHash.new(:foo => 'bar')
-        c2 = CriteriaHash.new(:foo => 'bar')
-        c1.merge(c2).should == CriteriaHash.new(:foo => {'$in' => %w[bar]})
-      end
-
-      should "correctly merge arrays and non-arrays" do
-        c1 = CriteriaHash.new(:foo => 'bar')
-        c2 = CriteriaHash.new(:foo => %w[bar baz])
-        c1.merge(c2).should == CriteriaHash.new(:foo => {'$in' => %w[bar baz]})
-        c2.merge(c1).should == CriteriaHash.new(:foo => {'$in' => %w[bar baz]})
-      end
-
-      should "be able to merge two modifier hashes" do
-        c1 = CriteriaHash.new('$in' => [1, 2])
-        c2 = CriteriaHash.new('$in' => [2, 3])
-        c1.merge(c2).should == CriteriaHash.new('$in' => [1, 2, 3])
-      end
-
-      should "merge matching keys with a single modifier" do
-        c1 = CriteriaHash.new(:foo => {'$in' => [1, 2, 3]})
-        c2 = CriteriaHash.new(:foo => {'$in' => [1, 4, 5]})
-        c1.merge(c2).should == CriteriaHash.new(:foo => {'$in' => [1, 2, 3, 4, 5]})
-      end
-
-      should "merge matching keys with multiple modifiers" do
-        c1 = CriteriaHash.new(:foo => {'$in' => [1, 2, 3]})
-        c2 = CriteriaHash.new(:foo => {'$all' => [1, 4, 5]})
-        c1.merge(c2).should == CriteriaHash.new(:foo => {'$in' => [1, 2, 3], '$all' => [1, 4, 5]})
-      end
-
-      should "not update mergee" do
-        c1 = CriteriaHash.new(:foo => 'bar')
-        c2 = CriteriaHash.new(:foo => 'baz')
-        c1.merge(c2).should_not equal(c1)
-        c1[:foo].should == 'bar'
-      end
-    end
-
-    context "#merge!" do
-      should "merge and replace" do
-        c1 = CriteriaHash.new(:foo => 'bar')
-        c2 = CriteriaHash.new(:foo => 'baz')
-        c1.merge!(c2)
-        c1[:foo].should == {'$in' => ['bar', 'baz']}
-      end
-    end
-
-    context "#simple?" do
-      should "be true if only filtering by _id" do
-        CriteriaHash.new(:_id => 'id').should be_simple
-      end
-
-      should "be true if only filtering by Sci" do
-        CriteriaHash.new(:_id => 'id', :_type => 'Foo').should be_simple
-      end
-
-      should "be false if querying by anthing other than _id/Sci" do
-        CriteriaHash.new(:foo => 'bar').should_not be_simple
-      end
-
-      should "be false if querying only by _type" do
-        CriteriaHash.new(:_type => 'Foo').should_not be_simple
-      end
-    end
-  end
-end