pwnash-mongo_mapper 0.7.5 → 0.7.6

data/lib/mongo_mapper/plugins/indexes.rb

@@ -0,0 +1,11 @@
+module MongoMapper
+  module Plugins
+    module Indexes
+      module ClassMethods
+        def ensure_index(spec, options={})
+          collection.create_index(spec, options)
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/inspect.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Inspect

data/lib/mongo_mapper/plugins/keys.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Keys
@@ -9,7 +10,6 @@ module MongoMapper
 
       module ClassMethods
         def inherited(descendant)
-          key :_type, String unless keys.keys.include?(:_type)
           descendant.instance_variable_set(:@keys, keys.dup)
           super
         end
@@ -36,9 +36,12 @@ module MongoMapper
           object_id_key?(:_id)
         end
 
+        def object_id_keys
+          keys.keys.select { |key| keys[key].type == ObjectId }.map(&:to_sym)
+        end
+
         def object_id_key?(name)
-          key = keys[name.to_s]
-          key && key.type == ObjectId
+          object_id_keys.include?(name.to_sym)
         end
 
         def to_mongo(instance)
@@ -53,6 +56,7 @@ module MongoMapper
 
         # load is overridden in identity map to ensure same objects are loaded
         def load(attrs)
+          return nil if attrs.nil?
           begin
             klass = attrs['_type'].present? ? attrs['_type'].constantize : self
             klass.new(attrs, true)
@@ -161,8 +165,6 @@ module MongoMapper
             @new = true
             assign(attrs)
           end
-
-          assign_type
         end
 
         def persisted?
@@ -275,10 +277,6 @@ module MongoMapper
             end
           end
 
-          def assign_type
-            self._type = self.class.name if respond_to?(:_type=)
-          end
-
           def ensure_key_exists(name)
             self.class.key(name) unless respond_to?("#{name}=")
           end

data/lib/mongo_mapper/plugins/keys/key.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Keys
@@ -8,7 +9,7 @@ module MongoMapper
           options = args.extract_options!
           @name, @type = args.shift.to_s, args.shift
           self.options = (options || {}).symbolize_keys
-          self.default_value = self.options.delete(:default)
+          self.default_value = self.options[:default]
         end
 
         def ==(other)
@@ -36,8 +37,17 @@ module MongoMapper
         end
 
         def set(value)
-          type.to_mongo(value)
+          type.to_mongo(value).tap do |values|
+            if options[:typecast].present?
+              values.map! { |v| typecast_class.to_mongo(v) }
+            end
+          end
         end
+        
+        private
+          def typecast_class
+            options[:typecast].constantize
+          end
       end
     end
   end

data/lib/mongo_mapper/plugins/logger.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Logger

data/lib/mongo_mapper/plugins/modifiers.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Modifiers
@@ -29,7 +30,7 @@ module MongoMapper
             criteria = {:id => ids}
           end
 
-          criteria  = to_criteria(criteria)
+          criteria  = criteria_hash(criteria).to_hash
           modifiers = keys.inject({}) { |hash, key| hash[key] = 1; hash }
           collection.update(criteria, {'$unset' => modifiers}, :multi => true)
         end
@@ -68,7 +69,7 @@ module MongoMapper
           def criteria_and_keys_from_args(args)
             keys     = args.pop
             criteria = args[0].is_a?(Hash) ? args[0] : {:id => args}
-            [to_criteria(criteria), keys]
+            [criteria_hash(criteria).to_hash, keys]
           end
       end
 

data/lib/mongo_mapper/plugins/pagination.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Pagination

data/lib/mongo_mapper/plugins/pagination/proxy.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Pagination

data/lib/mongo_mapper/plugins/persistence.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Persistence

data/lib/mongo_mapper/plugins/protected.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Protected

data/lib/mongo_mapper/plugins/query_logger.rb

@@ -4,6 +4,7 @@ module MongoMapper
     module QueryLogger
 
       module ClassMethods
+
         def find_one(options={})
           criteria, query_options = to_query(options)
           log(query_options.inspect, 'find_one') do
@@ -26,9 +27,9 @@ module MongoMapper
         end 
 
         def log_info(query, name, ms)
-          if self.logger && self.logger.debug?
+          if self.logger && self.logger.info?
             name = '%s (%.1fms)' % [name || 'query', ms]
-            self.logger.debug(format_log_entry(name, query))
+            self.logger.info(format_log_entry(name, query))
           end
         end
 
@@ -45,14 +46,8 @@ module MongoMapper
         end
         
         def format_log_entry(message, dump = nil)
-          if false # ActiveRecord::Base.colorize_logging
-            if @@row_even
-              @@row_even = false
-              message_color, dump_color = "4;36;1", "0;1"
-            else
-              @@row_even = true
-              message_color, dump_color = "4;35;1", "0"
-            end
+          if ActiveRecord::Base.colorize_logging
+            message_color, dump_color = "4;36;1", "0;1"
 
             log_entry = "  \e[#{message_color}m#{message}\e[0m   "
             log_entry << "\e[#{dump_color}m%#{String === dump ? 's' : 'p'}\e[0m" % dump if dump

data/lib/mongo_mapper/plugins/querying.rb

@@ -0,0 +1,236 @@
+module MongoMapper
+  module Plugins
+    module Querying
+      module ClassMethods
+        def find(*args)
+          options = args.extract_options!
+          return nil if args.size == 0
+
+          if args.first.is_a?(Array) || args.size > 1
+            find_some(args, options)
+          else
+            find_one(options.merge(:_id => args[0]))
+          end
+        end
+
+        def find!(*args)
+          options = args.extract_options!
+          raise DocumentNotFound, "Couldn't find without an ID" if args.size == 0
+
+          if args.first.is_a?(Array) || args.size > 1
+            find_some!(args, options)
+          else
+            find_one(options.merge(:_id => args[0])) ||
+              raise(DocumentNotFound, "Document match #{options.inspect} does not exist
+                                        in #{collection.name} collection")
+          end
+        end
+
+        def find_each(options={})
+          query(options).query.find().each { |doc| yield load(doc) }
+        end
+
+        def find_by_id(id)
+          find_one(:_id => id)
+        end
+
+        def first(options={})
+          find_one(options)
+        end
+
+        # All bets are off an actual order if you provide none.
+        def last(options={})
+          find_one(query(options).reverse.to_hash)
+        end
+
+        def all(options={})
+          find_many(options)
+        end
+
+        def count(options={})
+          query(options).count
+        end
+
+        def exists?(options={})
+          !count(options).zero?
+        end
+
+        def first_or_create(args)
+          first(args) || create(args.reject { |key, value| !key?(key) })
+        end
+
+        def first_or_new(args)
+          first(args) || new(args.reject { |key, value| !key?(key) })
+        end
+
+        def create(*docs)
+          initialize_each(*docs) { |doc| doc.save }
+        end
+
+        def create!(*docs)
+          initialize_each(*docs) { |doc| doc.save! }
+        end
+
+        def update(*args)
+          if args.length == 1
+            update_multiple(args[0])
+          else
+            id, attributes = args
+            update_single(id, attributes)
+          end
+        end
+
+        def delete(*ids)
+          query(:_id => ids.flatten).query.remove
+        end
+
+        def delete_all(options={})
+          query(options).query.remove
+        end
+
+        def destroy(*ids)
+          find_some!(ids.flatten).each(&:destroy)
+        end
+
+        def destroy_all(options={})
+          find_each(options) { |document| document.destroy }
+        end
+
+        def where(options={})
+          query.where(options)
+        end
+        
+        def fields(*args)
+          query.fields(*args)
+        end
+
+        def limit(*args)
+          query.limit(*args)
+        end
+
+        def skip(*args)
+          query.skip(*args)
+        end
+
+        def sort(*args)
+          query.sort(*args)
+        end
+
+        # @api private for now
+        def query(options={})
+          Query.new(self).update(options)
+        end
+
+        # @api private for now
+        def criteria_hash(criteria={})
+          Plucky::CriteriaHash.new(criteria, :object_ids => object_id_keys)
+        end
+
+        # @api private for now
+        def options_hash(options={})
+          Plucky::OptionsHash.new(options)
+        end
+
+        private
+          def find_some(ids, options={})
+            query = query(options).update(:_id => ids.flatten.compact.uniq)
+            find_many(query.to_hash).compact
+          end
+
+          def find_some!(ids, options={})
+            ids  = ids.flatten.compact.uniq
+            docs = find_some(ids, options)
+
+            if ids.size != docs.size
+              raise DocumentNotFound, "Couldn't find all of the ids (#{ids.to_sentence}). Found #{docs.size}, but was expecting #{ids.size}"
+            end
+
+            docs
+          end
+
+          # All query methods that load documents pass through find_one or find_many
+          def find_one(options={})
+            query(options).first
+          end
+
+          # All query methods that load documents pass through find_one or find_many
+          def find_many(options)
+            query(options).all
+          end
+
+          def initialize_each(*docs)
+            instances = []
+            docs = [{}] if docs.blank?
+            docs.flatten.each do |attrs|
+              doc = new(attrs)
+              yield(doc)
+              instances << doc
+            end
+            instances.size == 1 ? instances[0] : instances
+          end
+
+          def update_single(id, attrs)
+            if id.blank? || attrs.blank? || !attrs.is_a?(Hash)
+              raise ArgumentError, "Updating a single document requires an id and a hash of attributes"
+            end
+
+            find(id).tap do |doc|
+              doc.update_attributes(attrs)
+            end
+          end
+
+          def update_multiple(docs)
+            unless docs.is_a?(Hash)
+              raise ArgumentError, "Updating multiple documents takes 1 argument and it must be hash"
+            end
+
+            instances = []
+            docs.each_pair { |id, attrs| instances << update(id, attrs) }
+            instances
+          end
+      end
+
+      module InstanceMethods
+        def save(options={})
+          options.assert_valid_keys(:validate, :safe)
+          options.reverse_merge!(:validate => true)
+          !options[:validate] || valid? ? create_or_update(options) : false
+        end
+
+        def save!(options={})
+          options.assert_valid_keys(:safe)
+          save(options) || raise(DocumentNotValid.new(self))
+        end
+
+        def destroy
+          delete
+        end
+
+        def delete
+          @_destroyed = true
+          self.class.delete(id) unless new?
+        end
+
+        private
+          def create_or_update(options={})
+            result = new? ? create(options) : update(options)
+            result != false
+          end
+
+          def create(options={})
+            save_to_collection(options)
+          end
+
+          def update(options={})
+            save_to_collection(options)
+          end
+
+          def save_to_collection(options={})
+            safe = options[:safe] || false
+            @new = false
+            collection.save(to_mongo, :safe => safe)
+          end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/plugins/rails.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 module MongoMapper
   module Plugins
     module Rails

data/lib/mongo_mapper/plugins/sci.rb

@@ -0,0 +1,31 @@
+module MongoMapper
+  module Plugins
+    module Sci
+      module ClassMethods
+        def inherited(subclass)
+          key :_type, String unless key?(:_type)
+          subclass.instance_variable_set("@single_collection_inherited", true)
+          subclass.set_collection_name(collection_name) unless subclass.embeddable?
+          super
+        end
+
+        def single_collection_inherited?
+          @single_collection_inherited == true
+        end
+
+        def query(options={})
+          super.tap do |query|
+            query[:_type] = name if single_collection_inherited?
+          end
+        end
+      end
+
+      module InstanceMethods
+        def initialize(*args)
+          super
+          write_key :_type, self.class.name if self.class.key?(:_type)
+        end
+      end
+    end
+  end
+end