pwnash-mongo_mapper 0.7.5 → 0.7.6

data/lib/mongo_mapper.rb

@@ -1,10 +1,8 @@
-# Make sure you have the following libs in your load path or you could have issues:
-#   gem 'activesupport', '>= 2.3.4'
-#   gem 'mongo', '1.0'
-#   gem 'jnunemaker-validatable', '1.8.4'
+# encoding: UTF-8
+# Make sure you have the correct versions of the gems (see gemspec) in your load path.
 require 'set'
 require 'uri'
-require 'mongo'
+require 'plucky'
 require 'validatable'
 require 'active_support/all'
 
@@ -92,8 +90,7 @@ module MongoMapper
   end
 
   def self.setup(config, environment, options={})
-    using_passenger = options.delete(:passenger)
-    handle_passenger_forking if using_passenger
+    handle_passenger_forking
     self.config = config
     connect(environment, options)
   end
@@ -106,11 +103,12 @@ module MongoMapper
     end
   end
 
-  autoload :Query,            'mongo_mapper/query'
   autoload :Document,         'mongo_mapper/document'
   autoload :EmbeddedDocument, 'mongo_mapper/embedded_document'
+  autoload :Query,            'mongo_mapper/query'
   autoload :Version,          'mongo_mapper/version'
 end
 
+require 'mongo_mapper/extensions'
 require 'mongo_mapper/support'
 require 'mongo_mapper/plugins'

data/lib/mongo_mapper/document.rb

@@ -1,19 +1,21 @@
+# encoding: UTF-8
 module MongoMapper
   module Document
     extend Support::DescendantAppends
 
     def self.included(model)
       model.class_eval do
-        include InstanceMethods
-        extend  Support::Find
-        extend  ClassMethods
         extend  Plugins
 
+        plugin Plugins::Document
+        plugin Plugins::Querying # for now needs to be before associations (save_to_collection)
         plugin Plugins::Associations
         plugin Plugins::Clone
         plugin Plugins::Descendants
+        plugin Plugins::DynamicQuerying
         plugin Plugins::Equality
         plugin Plugins::Inspect
+        plugin Plugins::Indexes
         plugin Plugins::Keys
         plugin Plugins::Dirty # for now dirty needs to be after keys
         plugin Plugins::Logger
@@ -22,6 +24,7 @@ module MongoMapper
         plugin Plugins::Persistence
         plugin Plugins::Protected
         plugin Plugins::Rails
+        plugin Plugins::Sci
         plugin Plugins::Serialization
         plugin Plugins::Timestamps
         plugin Plugins::Userstamps
@@ -29,286 +32,8 @@ module MongoMapper
         plugin Plugins::Callbacks # for now callbacks needs to be after validations
         plugin Plugins::QueryLogger
 
-        extend Plugins::Validations::DocumentMacros
       end
-
       super
     end
-
-    module ClassMethods
-      def inherited(subclass)
-        subclass.set_collection_name(collection_name)
-        super
-      end
-
-      def ensure_index(spec, options={})
-        collection.create_index(spec, options)
-      end
-
-      def find(*args)
-        assert_no_first_last_or_all(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)
-        assert_no_first_last_or_all(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={})
-        criteria, options = to_query(options)
-        collection.find(criteria, options).each do |doc|
-          yield load(doc)
-        end
-      end
-
-      def find_by_id(id)
-        find(id)
-      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 first(options={})
-        find_one(options)
-      end
-
-      def last(options={})
-        raise ':order option must be provided when using last' if options[:order].blank?
-        find_one(options.merge(:order => invert_order_clause(options[:order])))
-      end
-
-      def all(options={})
-        find_many(options)
-      end
-
-      def count(options={})
-        collection.find(to_criteria(options)).count
-      end
-
-      def exists?(options={})
-        !count(options).zero?
-      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)
-        collection.remove(to_criteria(:_id => ids.flatten))
-      end
-
-      def delete_all(options={})
-        collection.remove(to_criteria(options))
-      end
-
-      def destroy(*ids)
-        find_some!(ids.flatten).each(&:destroy)
-      end
-
-      def destroy_all(options={})
-        find_each(options) { |document| document.destroy }
-      end
-
-      def embeddable?
-        false
-      end
-
-      def single_collection_inherited?
-        keys.key?(:_type) && single_collection_inherited_superclass?
-      end
-
-      def single_collection_inherited_superclass?
-        superclass.respond_to?(:keys) && superclass.keys.key?(:_type)
-      end
-
-      private
-        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 assert_no_first_last_or_all(args)
-          if args[0] == :first || args[0] == :last || args[0] == :all
-            raise ArgumentError, "#{self}.find(:#{args}) is no longer supported, use #{self}.#{args} instead."
-          end
-        end
-
-        def find_some(ids, options={})
-          ids = ids.flatten.compact.uniq
-          find_many(options.merge(:_id => ids)).compact
-        end
-
-        def find_some!(ids, options={})
-          ids = ids.flatten.compact.uniq
-          documents = find_some(ids, options)
-
-          if ids.size == documents.size
-            documents
-          else
-            raise DocumentNotFound, "Couldn't find all of the ids (#{ids.to_sentence}). Found #{documents.size}, but was expecting #{ids.size}"
-          end
-        end
-
-        # All query methods that load documents pass through find_one or find_many
-        def find_one(options={})
-          criteria, options = to_query(options)
-          if doc = collection.find_one(criteria, options)
-            load(doc)
-          end
-        end
-
-        # All query methods that load documents pass through find_one or find_many
-        def find_many(options)
-          criteria, options = to_query(options)
-          collection.find(criteria, options).to_a.map do |doc|
-            load(doc)
-          end
-        end
-
-        def invert_order_clause(order)
-          order.split(',').map do |order_segment|
-            if order_segment =~ /\sasc/i
-              order_segment.sub /\sasc/i, ' desc'
-            elsif order_segment =~ /\sdesc/i
-              order_segment.sub /\sdesc/i, ' asc'
-            else
-              "#{order_segment.strip} desc"
-            end
-          end.join(',')
-        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
-
-          doc = find(id)
-          doc.update_attributes(attrs)
-          doc
-        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
-
-        def to_criteria(options={})
-          Query.new(self, options).criteria
-        end
-
-        def to_query(options={})
-          Query.new(self, options).to_a
-        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
-
-      def new?
-        @new
-      end
-
-      def destroyed?
-        @_destroyed == true
-      end
-
-      def reload
-        if attrs = collection.find_one({:_id => _id})
-          self.class.associations.each { |name, assoc| send(name).reset if respond_to?(name) }
-          self.attributes = attrs
-          self
-        else
-          raise DocumentNotFound, "Document match #{_id.inspect} does not exist in #{collection.name} collection"
-        end
-      end
-
-      # Used by embedded docs to find root easily without if/respond_to? stuff.
-      # Documents are always root documents.
-      def _root_document
-        self
-      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 # Document
 end # MongoMapper

data/lib/mongo_mapper/embedded_document.rb

@@ -1,13 +1,13 @@
+# encoding: UTF-8
 module MongoMapper
   module EmbeddedDocument
     extend Support::DescendantAppends
 
     def self.included(model)
       model.class_eval do
-        include InstanceMethods
-        extend  ClassMethods
         extend  Plugins
 
+        plugin Plugins::EmbeddedDocument
         plugin Plugins::Associations
         plugin Plugins::Clone
         plugin Plugins::Descendants
@@ -18,54 +18,14 @@ module MongoMapper
         plugin Plugins::Persistence
         plugin Plugins::Protected
         plugin Plugins::Rails
+        plugin Plugins::Sci
         plugin Plugins::Serialization
         plugin Plugins::Validations
         plugin Plugins::Callbacks
         plugin Plugins::QueryLogger
 
-        attr_reader :_root_document, :_parent_document
       end
-
       super
     end
-
-    module ClassMethods
-      def embeddable?
-        true
-      end
-
-      def embedded_in(owner_name)
-        define_method(owner_name) { _parent_document }
-      end
-    end
-
-    module InstanceMethods
-      def destroyed?
-        !!_root_document.try(:destroyed?)
-      end
-
-      def new?
-        _root_document.try(:new?) || @new
-      end
-
-      def save(options={})
-        if result = _root_document.try(:save, options)
-          @new = false
-        end
-        result
-      end
-
-      def save!(options={})
-        if result = _root_document.try(:save!, options)
-          @new = false
-        end
-        result
-      end
-
-      def _parent_document=(value)
-        @_root_document   = value._root_document
-        @_parent_document = value
-      end
-    end # InstanceMethods
-  end # EmbeddedDocument
-end # MongoMapper
+  end
+end

data/lib/mongo_mapper/extensions.rb

@@ -0,0 +1,190 @@
+# encoding: UTF-8
+class Array
+  def self.to_mongo(value)
+    value = value.respond_to?(:lines) ? value.lines : value
+    value.to_a
+  end
+
+  def self.from_mongo(value)
+    value || []
+  end
+end
+
+class Binary
+  def self.to_mongo(value)
+    if value.is_a?(BSON::Binary)
+      value
+    else
+      value.nil? ? nil : BSON::Binary.new(value)
+    end
+  end
+
+  def self.from_mongo(value)
+    value
+  end
+end
+
+class Boolean
+  BOOLEAN_MAPPING = {
+    true => true, 'true' => true, 'TRUE' => true, 'True' => true, 't' => true, 'T' => true, '1' => true, 1 => true, 1.0 => true,
+    false => false, 'false' => false, 'FALSE' => false, 'False' => false, 'f' => false, 'F' => false, '0' => false, 0 => false, 0.0 => false, nil => nil
+  }
+
+  def self.to_mongo(value)
+    if value.is_a?(Boolean)
+      value
+    else
+      BOOLEAN_MAPPING[value]
+    end
+  end
+
+  def self.from_mongo(value)
+    !!value
+  end
+end
+
+class Date
+  def self.to_mongo(value)
+    if value.nil? || value == ''
+      nil
+    else
+      date = value.is_a?(Date) || value.is_a?(Time) ? value : Date.parse(value.to_s)
+      Time.utc(date.year, date.month, date.day)
+    end
+  rescue
+    nil
+  end
+
+  def self.from_mongo(value)
+    value.to_date if value.present?
+  end
+end
+
+class Float
+  def self.to_mongo(value)
+    value.nil? ? nil : value.to_f
+  end
+end
+
+class Hash
+  def self.from_mongo(value)
+    HashWithIndifferentAccess.new(value || {})
+  end
+
+  def to_mongo
+    self
+  end
+end
+
+class Integer
+  def self.to_mongo(value)
+    value_to_i = value.to_i
+    if value_to_i == 0 && value != value_to_i
+      value.to_s =~ /^(0x|0b)?0+/ ? 0 : nil
+    else
+      value_to_i
+    end
+  end
+end
+
+class NilClass
+  def to_mongo(value)
+    value
+  end
+
+  def from_mongo(value)
+    value
+  end
+end
+
+class Object
+  # The hidden singleton lurks behind everyone
+  def metaclass
+    class << self; self end
+  end
+
+  def meta_eval(&blk)
+    metaclass.instance_eval(&blk)
+  end
+
+  # Adds methods to a metaclass
+  def meta_def(name, &blk)
+    meta_eval { define_method(name, &blk) }
+  end
+
+  # Defines an instance method within a class
+  def class_def(name, &blk)
+    class_eval { define_method(name, &blk) }
+  end
+
+  def self.to_mongo(value)
+    value
+  end
+
+  def self.from_mongo(value)
+    value
+  end
+end
+
+class ObjectId
+  def self.to_mongo(value)
+    Plucky.to_object_id(value)
+  end
+
+  def self.from_mongo(value)
+    value
+  end
+end
+
+class Set
+  def self.to_mongo(value)
+    value.to_a
+  end
+
+  def self.from_mongo(value)
+    Set.new(value || [])
+  end
+end
+
+class String
+  def self.to_mongo(value)
+    value.nil? ? nil : value.to_s
+  end
+
+  def self.from_mongo(value)
+    value.nil? ? nil : value.to_s
+  end
+end
+
+class Time
+  def self.to_mongo(value)
+    if value.nil? || value == ''
+      nil
+    else
+      time_class = Time.try(:zone).present? ? Time.zone : Time
+      time = value.is_a?(Time) ? value : time_class.parse(value.to_s)
+      # strip milliseconds as Ruby does micro and bson does milli and rounding rounded wrong
+      at(time.to_i).utc if time
+    end
+  end
+
+  def self.from_mongo(value)
+    if Time.try(:zone).present? && value.present?
+      value.in_time_zone(Time.zone)
+    else
+      value
+    end
+  end
+end
+
+class BSON::ObjectID
+  alias_method :original_to_json, :to_json
+
+  def as_json(options=nil)
+    to_s
+  end
+
+  def to_json(options = nil)
+    as_json.to_json
+  end
+end