mongoid-multi-db 3.0.0

data/lib/mongoid/fields/serializable/symbol.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Fields #:nodoc:
+    module Serializable #:nodoc:
+
+      # Defines the behaviour for symbol fields.
+      class Symbol
+        include Serializable
+
+        # Serialize the object from the type defined in the model to a MongoDB
+        # compatible object to store.
+        #
+        # @example Serialize the field.
+        #   field.serialize(object)
+        #
+        # @param [ Object ] object The object to cast.
+        #
+        # @return [ Symbol ] The converted symbol.
+        #
+        # @since 2.1.0
+        def serialize(object)
+          object.blank? ? nil : object.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/fields/serializable/time.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Fields #:nodoc:
+    module Serializable #:nodoc:
+      # Defines the behaviour for date fields.
+      class Time
+        include Serializable
+        include Timekeeping
+
+        # When reading the field do we need to cast the value? This holds true when
+        # times are stored or for big decimals which are stored as strings.
+        #
+        # @example Typecast on a read?
+        #   field.cast_on_read?
+        #
+        # @return [ true ] Date fields cast on read.
+        #
+        # @since 2.1.0
+        def cast_on_read?; true; end
+      end
+    end
+  end
+end

data/lib/mongoid/fields/serializable/time_with_zone.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Fields #:nodoc:
+    module Serializable #:nodoc:
+      # Defines the behaviour for time with zone fields.
+      class TimeWithZone
+        include Serializable
+        include Timekeeping
+
+        # When reading the field do we need to cast the value? This holds true when
+        # times are stored or for big decimals which are stored as strings.
+        #
+        # @example Typecast on a read?
+        #   field.cast_on_read?
+        #
+        # @return [ true ] Date fields cast on read.
+        #
+        # @since 2.1.0
+        def cast_on_read?; true; end
+      end
+    end
+  end
+end

data/lib/mongoid/fields/serializable/timekeeping.rb

@@ -0,0 +1,106 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Fields #:nodoc:
+    module Serializable #:nodoc:
+
+      # This module contains shared behaviour for date conversions.
+      module Timekeeping
+
+        # When reading the field do we need to cast the value? This holds true when
+        # times are stored or for big decimals which are stored as strings.
+        #
+        # @example Typecast on a read?
+        #   field.cast_on_read?
+        #
+        # @return [ true ] Date fields cast on read.
+        #
+        # @since 2.1.0
+        def cast_on_read?; true; end
+
+        # Deserialize this field from the type stored in MongoDB to the type
+        # defined on the model.
+        #
+        # @example Deserialize the field.
+        #   field.deserialize(object)
+        #
+        # @param [ Object ] object The object to cast.
+        #
+        # @return [ Time ] The converted time.
+        #
+        # @since 2.1.0
+        def deserialize(object)
+          return nil if object.blank?
+          object = object.getlocal unless Mongoid::Config.use_utc?
+          if Mongoid::Config.use_activesupport_time_zone?
+            time_zone = Mongoid::Config.use_utc? ? 'UTC' : ::Time.zone
+            object = object.in_time_zone(time_zone)
+          end
+          object
+        end
+
+        # Serialize the object from the type defined in the model to a MongoDB
+        # compatible object to store.
+        #
+        # @example Serialize the field.
+        #   field.serialize(object)
+        #
+        # @param [ Object ] object The object to cast.
+        #
+        # @return [ Time ] The converted UTC time.
+        #
+        # @since 2.1.0
+        def serialize(object)
+          return nil if object.blank?
+          begin
+            time = convert_to_time(object)
+            strip_milliseconds(time).utc
+          rescue ArgumentError
+            raise Errors::InvalidTime.new(object)
+          end
+        end
+
+        # Convert the provided object to a UTC time to store in the database.
+        #
+        # @example Set the time.
+        #   Time.convert_to_time(Date.today)
+        #
+        # @param [ String, Date, DateTime, Array ] value The object to cast.
+        #
+        # @return [ Time ] The object as a UTC time.
+        #
+        # @since 1.0.0
+        def convert_to_time(value)
+          time = Mongoid::Config.use_activesupport_time_zone? ? ::Time.zone : ::Time
+          case value
+            when ::String
+              time.parse(value)
+            when ::DateTime
+              time.local(value.year, value.month, value.day, value.hour, value.min, value.sec)
+            when ::Date
+              time.local(value.year, value.month, value.day)
+            when ::Array
+              time.local(*value)
+            else
+              value
+          end
+        end
+
+        # Strip the milliseconds off the time.
+        #
+        # @todo Durran: Why is this here? Still need time refactoring.
+        #
+        # @example Strip.
+        #   Time.strip_millseconds(Time.now)
+        #
+        # @param [ Time ] time The time to strip.
+        #
+        # @return [ Time ] The time without millis.
+        #
+        # @since 2.1.0
+        def strip_milliseconds(time)
+          ::Time.at(time.to_i)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/finders.rb

@@ -0,0 +1,152 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  # This module defines the finder methods that hang off the document at the
+  # class level.
+  module Finders
+
+    # Delegate to the criteria methods that are natural for creating a new
+    # criteria.
+    critera_methods = [ :all_in, :all_of, :any_in, :any_of, :asc, :ascending,
+                        :avg, :desc, :descending, :excludes,
+                        :includes, :limit, :max, :min, :not_in, :only,
+                        :order_by, :search, :skip, :sum, :without, :where,
+                        :update, :update_all, :near ]
+    delegate *(critera_methods.dup << { :to => :criteria })
+
+    # Find all documents that match the given conditions.
+    #
+    # @example Find all matching documents given conditions.
+    #   Person.all(:conditions => { :attribute => "value" })
+    #
+    # @param [ Array ] args The conditions with options.
+    #
+    # @return [ Criteria ] The matching documents.
+    def all(*args)
+      find(:all, *args)
+    end
+
+    # Returns a count of matching records in the database based on the
+    # provided arguments.
+    #
+    # @example Get the count of matching documents.
+    #   Person.count(:conditions => { :attribute => "value" })
+    #
+    # @param [ Array ] args The conditions.
+    #
+    # @return [ Integer ] The number of matching documents.
+    def count(*args)
+      find(:all, *args).count
+    end
+
+    # Returns true if count is zero
+    #
+    # @example Are there no saved documents for this model?
+    #   Person.empty?
+    #
+    # @return [ true, false ] If the collection is empty.
+    def empty?
+      count == 0
+    end
+
+    # Returns true if there are on document in database based on the
+    # provided arguments.
+    #
+    # @example Do any documents exist for the conditions?
+    #   Person.exists?(:conditions => { :attribute => "value" })
+    #
+    # @param [ Array ] args The conditions.
+    def exists?(*args)
+       find(:all, *args).count > 0
+    end
+
+    # Find a +Document+ in several different ways.
+    #
+    # If a +String+ is provided, it will be assumed that it is a
+    # representation of a Mongo::ObjectID and will attempt to find a single
+    # +Document+ based on that id. If a +Symbol+ and +Hash+ is provided then
+    # it will attempt to find either a single +Document+ or multiples based
+    # on the conditions provided and the first parameter.
+    #
+    # @example Find the first matching document.
+    #   Person.find(:first, :conditions => { :attribute => "value" })
+    #
+    # @example Find all matching documents.
+    #   Person.find(:all, :conditions => { :attribute => "value" })
+    #
+    # @example Find a single document by an id.
+    #   Person.find(BSON::ObjectId)
+    #
+    # @param [ Array ] args An assortment of finder options.
+    #
+    # @return [ Document, nil, Criteria ] A document or matching documents.
+    def find(*args)
+      criteria.find(*args)
+    end
+
+    # Find the first +Document+ given the conditions, or creates a new document
+    # with the conditions that were supplied.
+    #
+    # @example Find or create the document.
+    #   Person.find_or_create_by(:attribute => "value")
+    #
+    # @param [ Hash ] attrs The attributes to check.
+    #
+    # @return [ Document ] A matching or newly created document.
+    def find_or_create_by(attrs = {}, &block)
+      find_or(:create, attrs, &block)
+    end
+
+    # Find the first +Document+ given the conditions, or initializes a new document
+    # with the conditions that were supplied.
+    #
+    # @example Find or initialize the document.
+    #   Person.find_or_initialize_by(:attribute => "value")
+    #
+    # @param [ Hash ] attrs The attributes to check.
+    #
+    # @return [ Document ] A matching or newly initialized document.
+    def find_or_initialize_by(attrs = {}, &block)
+      find_or(:new, attrs, &block)
+    end
+
+    # Find the first +Document+ given the conditions.
+    #
+    # @example Find the first document.
+    #   Person.first(:conditions => { :attribute => "value" })
+    #
+    # @param [ Array ] args The conditions with options.
+    #
+    # @return [ Document ] The first matching document.
+    def first(*args)
+      find(:first, *args)
+    end
+
+    # Find the last +Document+ given the conditions.
+    #
+    # @example Find the last document.
+    #   Person.last(:conditions => { :attribute => "value" })
+    #
+    # @param [ Array ] args The conditions with options.
+    #
+    # @return [ Document ] The last matching document.
+    def last(*args)
+      find(:last, *args)
+    end
+
+    protected
+
+    # Find the first object or create/initialize it.
+    #
+    # @example Find or perform an action.
+    #   Person.find_or(:create, :name => "Dev")
+    #
+    # @param [ Symbol ] method The method to invoke.
+    # @param [ Hash ] attrs The attributes to query or set.
+    #
+    # @return [ Document ] The first or new document.
+    def find_or(method, attrs = {}, &block)
+      first(:conditions => attrs) || send(method, attrs, &block)
+    end
+  end
+end

data/lib/mongoid/hierarchy.rb

@@ -0,0 +1,120 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Hierarchy #:nodoc
+    extend ActiveSupport::Concern
+
+    included do
+      attr_accessor :_parent
+    end
+
+    module ClassMethods #:nodoc:
+
+      # Determines if the document is a subclass of another document.
+      #
+      # @example Check if the document is a subclass.
+      #   Square.hereditary?
+      #
+      # @return [ true, false ] True if hereditary, false if not.
+      def hereditary?
+        Mongoid::Document > superclass
+      end
+    end
+
+    module InstanceMethods #:nodoc:
+
+      # Get all child +Documents+ to this +Document+, going n levels deep if
+      # necessary. This is used when calling update persistence operations from
+      # the root document, where changes in the entire tree need to be
+      # determined. Note that persistence from the embedded documents will
+      # always be preferred, since they are optimized calls... This operation
+      # can get expensive in domains with large hierarchies.
+      #
+      # @example Get all the document's children.
+      #   person._children
+      #
+      # @return [ Array<Document> ] All child documents in the hierarchy.
+      def _children
+        @_children ||=
+          [].tap do |children|
+            relations.each_pair do |name, metadata|
+              if metadata.embedded?
+                child = send(name)
+                child.to_a.each do |doc|
+                  children.push(doc)
+                  children.concat(doc._children) unless metadata.versioned?
+                end if child
+              end
+            end
+          end
+      end
+
+      # Determines if the document is a subclass of another document.
+      #
+      # @example Check if the document is a subclass
+      #   Square.new.hereditary?
+      #
+      # @return [ true, false ] True if hereditary, false if not.
+      def hereditary?
+        self.class.hereditary?
+      end
+
+      # Sets up a child/parent association. This is used for newly created
+      # objects so they can be properly added to the graph.
+      #
+      # @example Set the parent document.
+      #   document.parentize(parent)
+      #
+      # @param [ Document ] document The parent document.
+      #
+      # @return [ Document ] The parent document.
+      def parentize(document)
+        self._parent = document
+      end
+
+      # Remove a child document from this parent. If an embeds one then set to
+      # nil, otherwise remove from the embeds many.
+      #
+      # This is called from the +RemoveEmbedded+ persistence command.
+      #
+      # @example Remove the child.
+      #   document.remove_child(child)
+      #
+      # @param [ Document ] child The child (embedded) document to remove.
+      #
+      # @since 2.0.0.beta.1
+      def remove_child(child)
+        name = child.metadata.name
+        child.embedded_one? ? remove_ivar(name) : send(name).delete_one(child)
+      end
+
+      # After children are persisted we can call this to move all their changes
+      # and flag them as persisted in one call.
+      #
+      # @example Reset the children.
+      #   document.reset_persisted_children
+      #
+      # @return [ Array<Document> ] The children.
+      #
+      # @since 2.1.0
+      def reset_persisted_children
+        _children.each do |child|
+          child.move_changes
+          child.new_record = false
+        end
+      end
+
+      # Return the root document in the object graph. If the current document
+      # is the root object in the graph it will return self.
+      #
+      # @example Get the root document in the hierarchy.
+      #   document._root
+      #
+      # @return [ Document ] The root document in the hierarchy.
+      def _root
+        object = self
+        while (object._parent) do object = object._parent; end
+        object || self
+      end
+    end
+  end
+end