plucky 0.5.2 → 0.6.0

data/.bundle/config

@@ -0,0 +1,4 @@
+---
+BUNDLE_BIN: bin
+BUNDLE_DISABLE_SHARED_GEMS: "1"
+BUNDLE_PATH: vendor/gems

data/.gitignore

@@ -1,4 +1,6 @@
 *.project
 log
 *.gem
-Gemfile.lock
+Gemfile.lock
+bin
+vendor

data/.travis.yml

@@ -2,8 +2,8 @@ language: ruby
 rvm:
   - 1.8.7
   - ree
-  - 1.9.2
   - 1.9.3
 notifications:
   email: false
-bundler_args: --without debug
+bundler_args: --without debug guard performance
+services: mongodb

data/Gemfile

@@ -4,14 +4,24 @@ gemspec
 gem 'bson_ext', '~> 1.5'
 gem 'rake'
 
+group :performance do
+  gem 'perftools.rb', :require => 'perftools'
+end
+
 group(:debug) do
   platforms(:mri_18) { gem 'ruby-debug' }
   platforms(:mri_19) { gem 'ruby-debug19' }
 end
 
 group(:test) do
-  gem 'shoulda',            '~> 2.11'
-  gem 'jnunemaker-matchy',  '~> 0.4.0', :require => 'matchy'
-  gem 'mocha',              '~> 0.9.8'
+  gem 'rspec'
   gem 'log_buddy'
 end
+
+group(:guard) do
+  gem 'guard'
+  gem 'guard-rspec'
+  gem 'guard-bundler'
+  gem 'terminal-notifier-guard'
+  gem 'rb-fsevent'
+end

data/Guardfile

@@ -0,0 +1,13 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'bundler' do
+  watch('Gemfile')
+  watch(/^.+\.gemspec/)
+end
+
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/helper.rb')  { "spec" }
+end

data/README.md

@@ -11,7 +11,7 @@ gem install plucky
 ## Examples
 
 ```ruby
-connection = Mongo::Connection.new
+connection = Mongo::MongoClient.new
 db = connection.db('test')
 collection = db['users']
 collection.remove # clear out the collection

data/Rakefile

@@ -1,21 +1,7 @@
-require 'rubygems'
-require 'rake'
-require 'rake/testtask'
-require File.expand_path('../lib/plucky/version', __FILE__)
-
 require 'bundler'
 Bundler::GemHelper.install_tasks
 
-namespace :test do
-  Rake::TestTask.new(:all) do |test|
-    test.libs      << 'lib' << 'test'
-    test.pattern   = 'test/**/test_*.rb'
-    test.verbose   = true
-  end
-end
-
-task :test do
-  Rake::Task['test:all'].invoke
-end
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
 
-task :default => :test
+task :default => :spec

data/examples/query.rb

@@ -7,7 +7,7 @@ lib_path  = root_path.join('lib')
 $:.unshift(lib_path)
 require 'plucky'
 
-connection = Mongo::Connection.new
+connection = Mongo::MongoClient.new
 db = connection.db('test')
 collection = db['users']
 collection.remove # clear out the collection

data/lib/plucky.rb

@@ -13,6 +13,11 @@ module Plucky
   # Array of finder DSL methods to delegate
   Methods = Plucky::Query::DSL.instance_methods.sort.map(&:to_sym)
 
+  # Public: Converts value to object id if possible
+  #
+  # value - The value to attempt converation of
+  #
+  # Returns BSON::ObjectId or value
   def self.to_object_id(value)
     return value if value.is_a?(BSON::ObjectId)
     return nil   if value.nil? || (value.respond_to?(:empty?) && value.empty?)
@@ -23,4 +28,12 @@ module Plucky
       value
     end
   end
+
+  # Private
+  ModifierString = '$'
+
+  # Internal
+  def self.modifier?(key)
+    key.to_s[0, 1] == ModifierString
+  end
 end

data/lib/plucky/criteria_hash.rb

@@ -1,51 +1,85 @@
 # encoding: UTF-8
+require 'set'
+require 'plucky/normalizers/criteria_hash_value'
+require 'plucky/normalizers/criteria_hash_key'
+
 module Plucky
   class CriteriaHash
-    attr_reader :source, :options
+    # Private: The Hash that stores query criteria
+    attr_reader :source
+
+    # Private: The Hash that stores options
+    attr_reader :options
+
+    # Internal: Used to determine if criteria keys match simple id lookup.
+    SimpleIdQueryKeys = [:_id].to_set
 
-    NestingOperators = [:$or, :$and, :$nor]
+    # Internal: Used to determine if criteria keys match simple id and type
+    # lookup (for single collection inheritance).
+    SimpleIdAndTypeQueryKeys = [:_id, :_type].to_set
 
+    # Internal: Used to quickly check if it is possible that the
+    # criteria hash is simple.
+    SimpleQueryMaxSize = [SimpleIdQueryKeys.size, SimpleIdAndTypeQueryKeys.size].max
+
+    # Public
     def initialize(hash={}, options={})
       @source, @options = {}, options
       hash.each { |key, value| self[key] = value }
     end
 
-    def initialize_copy(source)
+    def initialize_copy(original)
       super
       @options = @options.dup
       @source  = @source.dup
-      each do |key, value|
+      @source.each do |key, value|
         self[key] = value.clone if value.duplicable?
       end
     end
 
+    # Public
+    def [](key)
+      @source[key]
+    end
+
+    # Public
+    # The contents of this make me sad...need to clean it up
     def []=(key, value)
       normalized_key = normalized_key(key)
+
       if key.is_a?(SymbolOperator)
-        operator = "$#{key.operator}"
+        operator = :"$#{key.operator}"
         normalized_value = normalized_value(normalized_key, operator, value)
-        source[normalized_key] ||= {}
-        source[normalized_key][operator] = normalized_value
+        @source[normalized_key] ||= {}
+        @source[normalized_key][operator] = normalized_value
       else
         if key == :conditions
           value.each { |k, v| self[k] = v }
         else
           normalized_value = normalized_value(normalized_key, normalized_key, value)
-          source[normalized_key] = normalized_value
+          @source[normalized_key] = normalized_value
         end
       end
     end
 
+    # Public
+    def keys
+      @source.keys
+    end
+
+    # Public
     def ==(other)
-      source == other.source
+      @source == other.source
     end
 
+    # Public
     def to_hash
-      source
+      @source
     end
 
+    # Public and completely disgusting
     def merge(other)
-      target = source.dup
+      target = @source.dup
       other.source.each_key do |key|
         value, other_value = target[key], other[key]
         target[key] =
@@ -55,16 +89,20 @@ module Plucky
 
             if value_is_hash && other_is_hash
               value.update(other_value) do |key, old_value, new_value|
-                Array(old_value).concat(Array(new_value)).uniq
+                if old_value.is_a?(Hash) && new_value.is_a?(Hash)
+                  self.class.new(old_value).merge(self.class.new(new_value)).to_hash
+                else
+                  Array(old_value).concat(Array(new_value)).uniq
+                end
               end
             elsif value_is_hash && !other_is_hash
-              if modifier_key = value.keys.detect { |k| k.to_s[0, 1] == '$' }
+              if modifier_key = value.keys.detect { |k| Plucky.modifier?(k) }
                 value[modifier_key].concat(Array(other_value)).uniq!
               else
                 # kaboom! Array(value).concat(Array(other_value)).uniq
               end
             elsif other_is_hash && !value_is_hash
-              if modifier_key = other_value.keys.detect { |k| k.to_s[0, 1] == '$' }
+              if modifier_key = other_value.keys.detect { |k| Plucky.modifier?(k) }
                 other_value[modifier_key].concat(Array(value)).uniq!
               else
                 # kaboom! Array(value).concat(Array(other_value)).uniq
@@ -79,71 +117,62 @@ module Plucky
       self.class.new(target)
     end
 
+    # Public
     def merge!(other)
       merge(other).to_hash.each do |key, value|
         self[key] = value
       end
+      self
     end
 
+    # Private
     def object_ids
       @options[:object_ids] ||= []
     end
 
+    # Private
     def object_ids=(value)
       raise ArgumentError unless value.is_a?(Array)
       @options[:object_ids] = value.flatten
     end
 
-    # The definition of simple is querying by only _id or _id and _type.
+    # Public: The definition of simple is querying by only _id or _id and _type.
     # If this is the case, you can use IdentityMap in library to not perform
     # query and instead just return from map.
+    #
+    # Returns true or false
     def simple?
+      return false if keys.size > SimpleQueryMaxSize
       key_set = keys.to_set
-      key_set == [:_id].to_set || key_set == [:_id, :_type].to_set
+      key_set == SimpleIdQueryKeys || key_set == SimpleIdAndTypeQueryKeys
     end
 
-    private
-      def method_missing(method, *args, &block)
-        @source.send(method, *args, &block)
-      end
+    def object_id?(key)
+      object_ids.include?(key.to_sym)
+    end
 
-      def object_id?(key)
-        object_ids.include?(key.to_sym)
-      end
+    # Private
+    def normalized_key(key)
+      key_normalizer.call(key)
+    end
 
-      def normalized_key(key)
-        key = key.to_sym                 if key.respond_to?(:to_sym)
-        return normalized_key(key.field) if key.respond_to?(:field)
-        return :_id                      if key == :id
-        key
-      end
+    # Private
+    def key_normalizer
+      @key_normalizer ||= @options.fetch(:key_normalizer) {
+        Normalizers::CriteriaHashKey.new
+      }
+    end
 
-      def normalized_value(parent_key, key, value)
-        case value
-          when Array, Set
-            value = value.map { |v| Plucky.to_object_id(v) } if object_id?(parent_key)
-            if NestingOperators.include?(key)
-              value.map  { |v| CriteriaHash.new(v, options).to_hash }
-            elsif parent_key == key
-              # we're not nested and not the value for a symbol operator
-              {'$in' => value.to_a}
-            else
-              # we are a value for a symbol operator or nested hash
-              value.to_a
-            end
-          when Time
-            value.utc
-          when String
-            return Plucky.to_object_id(value) if object_id?(key)
-            value
-          when Hash
-            value.each { |k, v| value[k] = normalized_value(key, k, v) }
-            value
-          when Regexp
-            Regexp.new(value)
-          else
-            value
-        end
-      end
+    # Private
+    def normalized_value(parent_key, key, value)
+      value_normalizer.call(parent_key, key, value)
+    end
+
+    # Private
+    def value_normalizer
+      @value_normalizer ||= @options.fetch(:value_normalizer) {
+        Normalizers::CriteriaHashValue.new(self)
+      }
+    end
   end
 end

data/lib/plucky/normalizers/criteria_hash_key.rb

@@ -0,0 +1,17 @@
+module Plucky
+  module Normalizers
+    class CriteriaHashKey
+      # Public: Returns key normalized for Mongo
+      #
+      # key - The key to normalize
+      #
+      # Returns key as Symbol if possible, else key with no changes
+      def call(key)
+        key = key.to_sym       if key.respond_to?(:to_sym)
+        return call(key.field) if key.respond_to?(:field)
+        return :_id            if key == :id
+        key
+      end
+    end
+  end
+end

data/lib/plucky/normalizers/criteria_hash_value.rb

@@ -0,0 +1,83 @@
+module Plucky
+  module Normalizers
+    class CriteriaHashValue
+
+      # Internal: Used by normalized_value to determine if we need to run the
+      # value through another criteria hash to normalize it.
+      NestingOperators = [:$or, :$and, :$nor]
+
+      def initialize(criteria_hash)
+        @criteria_hash = criteria_hash
+      end
+
+      # Public: Returns value normalized for Mongo
+      #
+      # parent_key - The parent key if nested, otherwise same as key
+      # key - The key we are currently normalizing
+      # value - The value that should be normalized
+      #
+      # Returns value normalized for Mongo
+      def call(parent_key, key, value)
+        case value
+          when Array, Set
+            if object_id?(parent_key)
+              value = value.map { |v| to_object_id(v) }
+            end
+
+            if nesting_operator?(key)
+              value.map  { |v| criteria_hash_class.new(v, options).to_hash }
+            elsif parent_key == key && !modifier?(key)
+              # we're not nested and not the value for a symbol operator
+              {:$in => value.to_a}
+            else
+              # we are a value for a symbol operator or nested hash
+              value.to_a
+            end
+          when Time
+            value.utc
+          when String
+            if object_id?(key)
+              return to_object_id(value)
+            end
+            value
+          when Hash
+            value.each { |k, v| value[k] = call(key, k, v) }
+            value
+          when Regexp
+            Regexp.new(value)
+          else
+            value
+        end
+      end
+
+      # Private: Ensures value is object id if possible
+      def to_object_id(value)
+        Plucky.to_object_id(value)
+      end
+
+      # Private: Returns class of provided criteria hash
+      def criteria_hash_class
+        @criteria_hash.class
+      end
+
+      # Private: Returns options of provided criteria hash
+      def options
+        @criteria_hash.options
+      end
+
+      # Private: Returns true or false if key should be converted to object id
+      def object_id?(key)
+        @criteria_hash.object_id?(key)
+      end
+
+      # Private: Returns true or false if key is a nesting operator
+      def nesting_operator?(key)
+        NestingOperators.include?(key)
+      end
+
+      def modifier?(key)
+        Plucky.modifier?(key)
+      end
+    end
+  end
+end