plucky 0.5.2 → 0.6.0

data/lib/plucky/query.rb

@@ -1,36 +1,43 @@
 # encoding: UTF-8
+require 'set'
 require 'forwardable'
+
 module Plucky
   class Query
     include Enumerable
     extend  Forwardable
 
-    OptionKeys = [
+    # Private
+    OptionKeys = Set[
       :select, :offset, :order,                         # MM
       :fields, :skip, :limit, :sort, :hint, :snapshot,  # Ruby Driver
-      :batch_size, :timeout, :transformer,              # Ruby Driver
-      :max_scan, :show_disk_loc, :return_key,           # Ruby Driver
+      :batch_size, :timeout, :max_scan, :return_key,    # Ruby Driver
+      :transformer, :show_disk_loc, :comment, :read,    # Ruby Driver
+      :tag_sets, :acceptable_latency,                   # Ruby Driver
     ]
 
     attr_reader    :criteria, :options, :collection
-    def_delegator  :criteria, :simple?
-    def_delegator  :options,  :fields?
+
+    def_delegator  :@criteria, :simple?
+    def_delegator  :@options,  :fields?
     def_delegators :to_a, :include?
 
-    def initialize(collection, opts={})
+    # Public
+    def initialize(collection, query_options = {})
       @collection, @options, @criteria = collection, OptionsHash.new, CriteriaHash.new
-      opts.each { |key, value| self[key] = value }
+      query_options.each { |key, value| self[key] = value }
     end
 
-    def initialize_copy(source)
+    def initialize_copy(original)
       super
       @criteria = @criteria.dup
       @options  = @options.dup
     end
 
+    # Public
     def object_ids(*keys)
-      return criteria.object_ids if keys.empty?
-      criteria.object_ids = *keys
+      return @criteria.object_ids if keys.empty?
+      @criteria.object_ids = *keys
       self
     end
 
@@ -48,30 +55,39 @@ module Plucky
         limit     = opts.delete(:per_page) || per_page
         query     = clone.amend(opts)
         paginator = Pagination::Paginator.new(query.count, page, limit)
-        query.amend(:limit => paginator.limit, :skip => paginator.skip).all.tap do |docs|
-          docs.extend(Pagination::Decorator)
-          docs.paginator(paginator)
-        end
+        docs      = query.amend({
+          :limit => paginator.limit,
+          :skip  => paginator.skip,
+        }).all
+
+        docs.extend(Pagination::Decorator)
+        docs.paginator(paginator)
+        docs
       end
 
       def find_each(opts={}, &block)
         query = clone.amend(opts)
-        cursor = query.collection.find(query.criteria.to_hash, query.options.to_hash)
+        cursor = query.cursor
+
         if block_given?
           cursor.each { |doc| yield doc }
           cursor.rewind!
         end
+
         cursor
       end
 
       def find_one(opts={})
         query = clone.amend(opts)
-        query.collection.find_one(query.criteria.to_hash, query.options.to_hash)
+        query.collection.find_one(query.criteria_hash, query.options_hash)
       end
 
       def find(*ids)
         return nil if ids.empty?
-        if ids.size == 1 && !ids[0].is_a?(Array)
+
+        single_id_find = ids.size == 1 && !ids[0].is_a?(Array)
+
+        if single_id_find
           first(:_id => ids[0])
         else
           all(:_id => ids.flatten)
@@ -96,12 +112,12 @@ module Plucky
 
       def remove(opts={}, driver_opts={})
         query = clone.amend(opts)
-        query.collection.remove(query.criteria.to_hash, driver_opts)
+        query.collection.remove(query.criteria_hash, driver_opts)
       end
 
       def count(opts={})
         query = clone.amend(opts)
-        cursor = query.collection.find(query.criteria.to_hash, query.options.to_hash)
+        cursor = query.cursor
         cursor.count
       end
 
@@ -111,7 +127,7 @@ module Plucky
 
       def distinct(key, opts = {})
         query = clone.amend(opts)
-        query.collection.distinct(key, query.criteria.to_hash)
+        query.collection.distinct(key, query.criteria_hash)
       end
 
       def fields(*args)
@@ -119,11 +135,11 @@ module Plucky
       end
 
       def ignore(*args)
-        set_fields(args, 0)
+        set_field_inclusion(args, 0)
       end
 
       def only(*args)
-        set_fields(args, 1)
+        set_field_inclusion(args, 1)
       end
 
       def limit(count=nil)
@@ -132,9 +148,10 @@ module Plucky
 
       def reverse
         clone.tap do |query|
-          query[:sort] = query[:sort].map do |s|
-            [s[0], -s[1]]
-          end unless query.options[:sort].nil?
+          sort = query[:sort]
+          unless sort.nil?
+            query.options[:sort] = sort.map { |s| [s[0], -s[1]] }
+          end
         end
       end
 
@@ -149,9 +166,7 @@ module Plucky
       alias order sort
 
       def where(hash={})
-        clone.tap do |query|
-          query.criteria.merge!(CriteriaHash.new(hash))
-        end
+        clone.tap { |query| query.criteria.merge!(CriteriaHash.new(hash)) }
       end
       alias filter where
 
@@ -159,8 +174,8 @@ module Plucky
         count.zero?
       end
 
-      def exists?(options={})
-        !count(options).zero?
+      def exists?(query_options={})
+        !count(query_options).zero?
       end
       alias :exist? :exists?
 
@@ -172,7 +187,7 @@ module Plucky
 
     def update(document, driver_opts={})
       query = clone
-      query.collection.update(query.criteria.to_hash, document, driver_opts)
+      query.collection.update(query.criteria_hash, document, driver_opts)
     end
 
     def amend(opts={})
@@ -181,35 +196,29 @@ module Plucky
     end
 
     def [](key)
-      key = key.to_sym if key.respond_to?(:to_sym)
-      if OptionKeys.include?(key)
-        @options[key]
-      else
-        @criteria[key]
-      end
+      key = symbolized_key(key)
+      source = hash_for_key(key)
+      source[key]
     end
 
     def []=(key, value)
-      key = key.to_sym if key.respond_to?(:to_sym)
-      if OptionKeys.include?(key)
-        @options[key] = value
-      else
-        @criteria[key] = value
-      end
+      key = symbolized_key(key)
+      source = hash_for_key(key)
+      source[key] = value
     end
 
     def merge(other)
-      merged_criteria = criteria.merge(other.criteria).to_hash
-      merged_options  = options.merge(other.options).to_hash
+      merged_criteria = @criteria.merge(other.criteria).to_hash
+      merged_options  = @options.merge(other.options).to_hash
       clone.amend(merged_criteria).amend(merged_options)
     end
 
     def to_hash
-      criteria.to_hash.merge(options.to_hash)
+      criteria_hash.merge(options_hash)
     end
 
     def explain
-      collection.find(criteria.to_hash, options.to_hash).explain
+      @collection.find(criteria_hash, options_hash).explain
     end
 
     def inspect
@@ -219,11 +228,44 @@ module Plucky
       "#<#{self.class}#{as_nice_string}>"
     end
 
+    def criteria_hash
+      @criteria.to_hash
+    end
+
+    def options_hash
+      @options.to_hash
+    end
+
+    def cursor
+      @collection.find(criteria_hash, options_hash)
+    end
+
   private
-    def set_fields(field_list, value)
-      the_fields = {}
-      field_list.each {|field| the_fields[field.to_sym] = value}
-      clone.tap { |query| query.options[:fields] =  the_fields}
+
+    # Private
+    def hash_for_key(key)
+      options_key?(key) ? @options : @criteria
+    end
+
+    # Private
+    def symbolized_key(key)
+      if key.respond_to?(:to_sym)
+        key.to_sym
+      else
+        key
+      end
+    end
+
+    # Private
+    def options_key?(key)
+      OptionKeys.include?(key)
+    end
+
+    # Private
+    def set_field_inclusion(fields, value)
+      fields_option = {}
+      fields.each { |field| fields_option[symbolized_key(field)] = value }
+      clone.tap { |query| query.options[:fields] = fields_option }
     end
   end
 end

data/lib/plucky/version.rb

@@ -1,4 +1,4 @@
 # encoding: UTF-8
 module Plucky
-  Version = '0.5.2'
+  Version = '0.6.0'
 end

data/script/criteria_hash.rb

@@ -0,0 +1,21 @@
+require 'pp'
+require 'pathname'
+require 'benchmark'
+require 'rubygems'
+require 'bundler'
+
+Bundler.require :default, :performance
+
+root_path = Pathname(__FILE__).dirname.join('..').expand_path
+lib_path  = root_path.join('lib')
+$:.unshift(lib_path)
+require 'plucky'
+
+criteria = Plucky::CriteriaHash.new(:foo => 'bar')
+
+PerfTools::CpuProfiler.start("/tmp/criteria_hash") do
+  1_000_000.times { criteria[:foo] = 'bar' }
+end
+
+puts system "pprof.rb --gif /tmp/criteria_hash > /tmp/criteria_hash.gif"
+puts system "open /tmp/criteria_hash.gif"

data/{test → spec}/helper.rb

@@ -1,15 +1,15 @@
+$:.unshift(File.expand_path('../../lib', __FILE__))
+
 require 'rubygems'
 require 'bundler'
 
 Bundler.require(:default, :test)
 
-$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
 require 'plucky'
 
 require 'fileutils'
 require 'logger'
 require 'pp'
-require 'set'
 
 log_dir = File.expand_path('../../log', __FILE__)
 FileUtils.mkdir_p(log_dir)
@@ -20,17 +20,21 @@ 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
+RSpec.configure do |config|
+  config.filter_run :focused => true
+  config.alias_example_to :fit, :focused => true
+  config.alias_example_to :xit, :pending => true
+  config.run_all_when_everything_filtered = true
+
+  config.before(:suite) do
     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] }
+  config.before(:each) do
+    DB.collections.map do |collection|
+      collection.remove
     end
   end
 end

data/spec/plucky/criteria_hash_spec.rb

@@ -0,0 +1,166 @@
+require 'helper'
+
+describe Plucky::CriteriaHash do
+  context "#initialize_copy" do
+    before do
+      @original = described_class.new({
+        :comments => {:_id => 1}, :tags => ['mongo', 'ruby'],
+      }, :object_ids => [:_id])
+      @cloned   = @original.clone
+    end
+
+    it "duplicates source hash" do
+      @cloned.source.should_not equal(@original.source)
+    end
+
+    it "duplicates options hash" do
+      @cloned.options.should_not equal(@original.options)
+    end
+
+    it "clones duplicable? values" do
+      @cloned[:comments].should_not equal(@original[:comments])
+      @cloned[:tags].should_not equal(@original[:tags])
+    end
+  end
+
+  context "#object_ids=" do
+    it "works with array" do
+      criteria = described_class.new
+      criteria.object_ids = [:_id]
+      criteria.object_ids.should == [:_id]
+    end
+
+    it "flattens multi-dimensional array" do
+      criteria = described_class.new
+      criteria.object_ids = [[:_id]]
+      criteria.object_ids.should == [:_id]
+    end
+
+    it "raises argument error if not array" do
+      expect { described_class.new.object_ids = {} }.to raise_error(ArgumentError)
+      expect { described_class.new.object_ids = nil }.to raise_error(ArgumentError)
+      expect { described_class.new.object_ids = 'foo' }.to raise_error(ArgumentError)
+    end
+  end
+
+  context "#[]=" do
+    context "with key and value" do
+      let(:key_normalizer)   { lambda { |*args| :normalized_key    } }
+      let(:value_normalizer) { lambda { |*args| 'normalized_value' } }
+
+      it "sets normalized key to normalized value in source" do
+        criteria = described_class.new({}, :value_normalizer => value_normalizer, :key_normalizer => key_normalizer)
+        criteria[:foo] = 'bar'
+        criteria.source[:normalized_key].should eq('normalized_value')
+      end
+    end
+
+    context "with conditions" do
+      it "sets each of conditions keys in source" do
+        criteria = described_class.new
+        criteria[:conditions] = {:_id => 'john', :foo => 'bar'}
+        criteria.source[:_id].should eq('john')
+        criteria.source[:foo].should eq('bar')
+      end
+    end
+
+    context "with symbol operators" do
+      it "sets nests key with operator and value" do
+        criteria = described_class.new
+        criteria[:age.gt] = 20
+        criteria[:age.lt] = 10
+        criteria.source[:age].should eq({:$gt => 20, :$lt => 10})
+      end
+    end
+  end
+
+  context "#merge" do
+    it "works when no keys match" do
+      c1 = described_class.new(:foo => 'bar')
+      c2 = described_class.new(:baz => 'wick')
+      c1.merge(c2).source.should eq(:foo => 'bar', :baz => 'wick')
+    end
+
+    it "turns matching keys with simple values into array" do
+      c1 = described_class.new(:foo => 'bar')
+      c2 = described_class.new(:foo => 'baz')
+      c1.merge(c2).source.should eq(:foo => {:$in => %w[bar baz]})
+    end
+
+    it "uniques matching key values" do
+      c1 = described_class.new(:foo => 'bar')
+      c2 = described_class.new(:foo => 'bar')
+      c1.merge(c2).source.should eq(:foo => {:$in => %w[bar]})
+    end
+
+    it "correctly merges arrays and non-arrays" do
+      c1 = described_class.new(:foo => 'bar')
+      c2 = described_class.new(:foo => %w[bar baz])
+      c1.merge(c2).source.should eq(:foo => {:$in => %w[bar baz]})
+      c2.merge(c1).source.should eq(:foo => {:$in => %w[bar baz]})
+    end
+
+    it "is able to merge two modifier hashes" do
+      c1 = described_class.new(:$in => [1, 2])
+      c2 = described_class.new(:$in => [2, 3])
+      c1.merge(c2).source.should eq(:$in => [1, 2, 3])
+    end
+
+    it "is able to merge two modifier hashes with hash values" do
+      c1 = described_class.new(:arr => {:$elemMatch => {:foo => 'bar'}})
+      c2 = described_class.new(:arr => {:$elemMatch => {:omg => 'ponies'}})
+      c1.merge(c2).source.should eq(:arr => {:$elemMatch => {:foo => 'bar', :omg => 'ponies'}})
+    end
+
+    it "merges matching keys with a single modifier" do
+      c1 = described_class.new(:foo => {:$in => [1, 2, 3]})
+      c2 = described_class.new(:foo => {:$in => [1, 4, 5]})
+      c1.merge(c2).source.should eq(:foo => {:$in => [1, 2, 3, 4, 5]})
+    end
+
+    it "merges matching keys with multiple modifiers" do
+      c1 = described_class.new(:foo => {:$in => [1, 2, 3]})
+      c2 = described_class.new(:foo => {:$all => [1, 4, 5]})
+      c1.merge(c2).source.should eq(:foo => {:$in => [1, 2, 3], :$all => [1, 4, 5]})
+    end
+
+    it "does not update mergee" do
+      c1 = described_class.new(:foo => 'bar')
+      c2 = described_class.new(:foo => 'baz')
+      c1.merge(c2).should_not equal(c1)
+      c1[:foo].should == 'bar'
+    end
+  end
+
+  context "#merge!" do
+    it "updates mergee" do
+      c1 = described_class.new(:foo => 'bar')
+      c2 = described_class.new(:foo => 'baz')
+      c1.merge!(c2).should equal(c1)
+      c1[:foo].should == {:$in => ['bar', 'baz']}
+    end
+  end
+
+  context "#simple?" do
+    it "returns true if only filtering by _id" do
+      described_class.new(:_id => 'id').should be_simple
+    end
+
+    it "returns true if only filtering by Sci" do
+      described_class.new(:_id => 'id', :_type => 'Foo').should be_simple
+      described_class.new(:_type => 'Foo', :_id => 'id').should be_simple # reverse order
+    end
+
+    it "returns false if querying by more than max number of simple keys" do
+      described_class.new(:one => 1, :two => 2, :three => 3).should_not be_simple
+    end
+
+    it "returns false if querying by anthing other than _id/Sci" do
+      described_class.new(:foo => 'bar').should_not be_simple
+    end
+
+    it "returns false if querying only by _type" do
+      described_class.new(:_type => 'Foo').should_not be_simple
+    end
+  end
+end