plucky 0.4.0 → 0.4.1

data/UPGRADES

@@ -0,0 +1,2 @@
+Apr 23, 2011 0.3.8 => 0.4
+  * Query#update was renamed to #amend.

data/lib/plucky.rb

@@ -14,17 +14,25 @@ module Plucky
     autoload :Paginator,  'plucky/pagination/paginator'
   end
 
+  # Array of methods that actually perform queries
+  Methods = [
+    :where, :filter, :limit, :skip, :offset, :sort, :order,
+    :fields, :ignore, :only,
+    :each, :find_each,
+    :count, :size, :distinct,
+    :last, :first, :all, :paginate,
+    :exists?, :exist?, :empty?,
+    :to_a, :remove,
+  ]
+
   def self.to_object_id(value)
-    if value.nil? || (value.respond_to?(:empty?) && value.empty?)
-      nil
-    elsif value.is_a?(BSON::ObjectId)
-      value
+    return value if value.is_a?(BSON::ObjectId)
+    return nil   if value.nil? || (value.respond_to?(:empty?) && value.empty?)
+
+    if BSON::ObjectId.legal?(value.to_s)
+      BSON::ObjectId.from_string(value.to_s)
     else
-      if BSON::ObjectId.legal?(value.to_s)
-        BSON::ObjectId.from_string(value.to_s)
-      else
-        value
-      end
+      value
     end
   end
 end

data/lib/plucky/new_relic.rb

@@ -0,0 +1,9 @@
+if defined?(NewRelic)
+  Plucky::Query.class_eval do
+    include NewRelic::Agent::MethodTracer
+
+    Plucky::Methods.each do |method_name|
+      add_method_tracer(method_name.to_sym)
+    end
+  end
+end

data/lib/plucky/query.rb

@@ -8,7 +8,8 @@ module Plucky
     OptionKeys = [
       :select, :offset, :order,                         # MM
       :fields, :skip, :limit, :sort, :hint, :snapshot,  # Ruby Driver
-      :batch_size, :timeout, :transformer               # Ruby Driver
+      :batch_size, :timeout, :transformer,              # Ruby Driver
+      :max_scan, :show_disk_loc, :return_key,           # Ruby Driver
     ]
 
     attr_reader    :criteria, :options, :collection
@@ -85,9 +86,14 @@ module Plucky
       find_each.each { |doc| yield(doc) }
     end
 
-    def remove(opts={})
+    def remove(opts={}, driver_opts={})
       query = clone.amend(opts)
-      query.collection.remove(query.criteria.to_hash)
+      query.collection.remove(query.criteria.to_hash, driver_opts)
+    end
+
+    def update(document, driver_opts={})
+      query = clone
+      query.collection.update(query.criteria.to_hash, document, driver_opts)
     end
 
     def count(opts={})

data/lib/plucky/version.rb

@@ -1,5 +1,5 @@
 # encoding: UTF-8
 module Plucky
-  Version = '0.4.0'
-  MongoVersion = '~> 1.3'
+  Version = '0.4.1'
+  MongoVersion = '~> 1.3.1'
 end

data/test/helper.rb

@@ -0,0 +1,45 @@
+require 'rubygems'
+gem 'jnunemaker-matchy', '~> 0.4.0'
+gem 'log_buddy'
+gem 'shoulda',           '~> 2.11'
+gem 'mocha',             '~> 0.9.8'
+
+$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+require 'plucky'
+
+require 'fileutils'
+require 'logger'
+require 'pp'
+
+require 'log_buddy'
+require 'shoulda'
+require 'matchy'
+require 'mocha'
+
+log_dir = File.expand_path('../../log', __FILE__)
+FileUtils.mkdir_p(log_dir)
+Log = Logger.new(File.join(log_dir, 'test.log'))
+
+LogBuddy.init :logger => Log
+
+connection = Mongo::Connection.new('127.0.0.1', 27017, :logger => Log)
+DB = connection.db('test')
+
+class Test::Unit::TestCase
+  def setup
+    DB.collections.map do |collection|
+      collection.remove
+      collection.drop_indexes
+    end
+  end
+
+  def oh(*args)
+    BSON::OrderedHash.new.tap do |hash|
+      args.each { |a| hash[a[0]] = a[1] }
+    end
+  end
+end
+
+operators = %w{gt lt gte lte ne in nin mod all size exists}
+operators.delete('size') if RUBY_VERSION >= '1.9.1'
+SymbolOperators = operators

data/test/plucky/pagination/test_decorator.rb

@@ -0,0 +1,34 @@
+require 'helper'
+
+class PaginatorTest < Test::Unit::TestCase
+  include Plucky::Pagination
+
+  context "Object decorated with Decorator with paginator set" do
+    setup do
+      @object    = [1, 2, 3, 4]
+      @object_id = @object.object_id
+      @paginator = Paginator.new(20, 2, 10)
+      @object.extend(Decorator)
+      @object.paginator(@paginator)
+    end
+    subject { @object }
+
+    should "be able to get paginator" do
+      subject.paginator.should == @paginator
+    end
+
+    [:total_entries, :current_page, :per_page, :total_pages, :out_of_bounds?,
+     :previous_page, :next_page, :skip, :limit, :offset].each do |method|
+      should "delegate #{method} to paginator" do
+        subject.send(method).should == @paginator.send(method)
+      end
+    end
+
+    should "not interfere with other methods on the object" do
+      @object.object_id.should  == @object_id
+      @object.should            == [1, 2, 3, 4]
+      @object.size.should       == 4
+      @object.select { |o| o > 2 }.should == [3, 4]
+    end
+  end
+end

data/test/plucky/pagination/test_paginator.rb

@@ -0,0 +1,120 @@
+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

@@ -0,0 +1,296 @@
+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 "#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
+    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
+        @criteria = CriteriaHash.new({:_id => {'$in' => [@id1.to_s, @id2.to_s]}}, :object_ids => [:_id])
+      end
+
+      should "convert strings to object ids" do
+        @criteria[:_id].should == {'$in' => [@id1, @id2]}
+      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