mongoid-braxton 2.0.2

data/lib/mongoid/state.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  # This module contains the behaviour for getting the various states a
+  # document can transition through.
+  module State
+
+    # Returns true if the +Document+ has not been persisted to the database,
+    # false if it has. This is determined by the variable @new_record
+    # and NOT if the object has an id.
+    #
+    # @example Is the document new?
+    #   person.new_record?
+    #
+    # @return [ true, false ] True if new, false if not.
+    def new_record?
+      @new_record == true
+    end
+    alias :new? :new_record?
+
+    # Sets the new_record boolean - used after document is saved.
+    #
+    # @example Set whether the document is new.
+    #   person.new_record = true
+    #
+    # @param [ true, false ] saved The value to set for new_record.
+    #
+    # @return [ true, false ] The new_record value.
+    def new_record=(saved)
+      @new_record = saved
+    end
+
+    # Checks if the document has been saved to the database. Returns false
+    # if the document has been destroyed.
+    #
+    # @example Is the document persisted?
+    #   person.persisted?
+    #
+    # @return [ true, false ] True if persisted, false if not.
+    def persisted?
+      !new_record? && !destroyed?
+    end
+
+    # Returns true if the +Document+ has been succesfully destroyed, and false
+    # if it hasn't. This is determined by the variable @destroyed and NOT
+    # by checking the database.
+    #
+    # @example Is the document destroyed?
+    #   person.destroyed?
+    #
+    # @return [ true, false ] True if destroyed, false if not.
+    def destroyed?
+      @destroyed == true
+    end
+    alias :deleted? :destroyed?
+
+    # Sets the destroyed boolean - used after document is destroyed.
+    #
+    # @example Set the destroyed flag.
+    #   person.destroyed = true
+    #
+    # @return [ true, false ] The value set for destroyed.
+    def destroyed=(destroyed)
+      @destroyed = destroyed && true
+    end
+  end
+end

data/lib/mongoid/timestamps.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+require "mongoid/timestamps/created"
+require "mongoid/timestamps/updated"
+
+module Mongoid #:nodoc:
+
+  # This module handles the behaviour for setting up document created at and
+  # updated at timestamps.
+  module Timestamps
+    extend ActiveSupport::Concern
+    include Created
+    include Updated
+  end
+end

data/lib/mongoid/timestamps/created.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  module Timestamps
+    # This module handles the behaviour for setting up document created at
+    # timestamp.
+    module Created
+      extend ActiveSupport::Concern
+
+      included do
+        field :created_at, :type => Time
+
+        set_callback :create, :before, :set_created_at
+
+        unless methods.include? 'record_timestamps'
+          class_attribute :record_timestamps
+          self.record_timestamps = true
+        end
+      end
+
+      # Update the created_at field on the Document to the current time. This is
+      # only called on create.
+      #
+      # @example Set the created at time.
+      #   person.set_created_at
+      def set_created_at
+        self.created_at = Time.now.utc if !created_at
+      end
+    end
+  end
+end

data/lib/mongoid/timestamps/updated.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  module Timestamps
+    # This module handles the behaviour for setting up document updated at
+    # timestamp.
+    module Updated
+      extend ActiveSupport::Concern
+
+      included do
+        field :updated_at, :type => Time
+
+        set_callback :save, :before, :set_updated_at, :if => Proc.new { |doc|
+          doc.new_record? || doc.changed?
+        }
+
+        unless methods.include? 'record_timestamps'
+          class_attribute :record_timestamps
+          self.record_timestamps = true
+        end
+      end
+
+      # Update the updated_at field on the Document to the current time.
+      # This is only called on create and on save.
+      #
+      # @example Set the updated at time.
+      #   person.set_updated_at
+      def set_updated_at
+        self.updated_at = Time.now.utc
+      end
+    end
+  end
+end

data/lib/mongoid/validations.rb

@@ -0,0 +1,124 @@
+# encoding: utf-8
+require "mongoid/validations/associated"
+require "mongoid/validations/referenced"
+require "mongoid/validations/uniqueness"
+
+module Mongoid #:nodoc:
+
+  # This module provides additional validations that ActiveModel does not
+  # provide: validates_associated and validates_uniqueness_of.
+  module Validations
+    extend ActiveSupport::Concern
+    include ActiveModel::Validations
+
+    attr_accessor :validated
+
+    # Overrides the default ActiveModel behaviour since we need to handle
+    # validations of relations slightly different than just calling the
+    # getter.
+    #
+    # @example Read the value.
+    #   person.read_attribute_for_validation(:addresses)
+    #
+    # @param [ Symbol ] attr The name of the field or relation.
+    #
+    # @return [ Object ] The value of the field or the relation.
+    #
+    # @since 2.0.0.rc.1
+    def read_attribute_for_validation(attr)
+      if relations[attr.to_s]
+        send(attr, false, :eager => true)
+      else
+        send(attr)
+      end
+    end
+
+    # Determine if the document is valid.
+    #
+    # @example Is the document valid?
+    #   person.valid?
+    #
+    # @example Is the document valid in a context?
+    #   person.valid?(:create)
+    #
+    # @param [ Symbol ] context The optional validation context.
+    #
+    # @return [ true, false ] True if valid, false if not.
+    #
+    # @since 2.0.0.rc.6
+    def valid?(context = nil)
+      super context ? context : (new? ? :create : :update)
+    end
+
+    # Used to prevent infinite loops in associated validations.
+    #
+    # @example Is the document validated?
+    #   document.validated?
+    #
+    # @return [ true, false ] Has the document already been validated?
+    #
+    # @since 2.0.0.rc.2
+    def validated?
+      !!@validated
+    end
+
+    module ClassMethods #:nodoc:
+
+      # Validates whether or not an association is valid or not. Will correctly
+      # handle has one and has many associations.
+      #
+      # @example
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     embeds_one :name
+      #     embeds_many :addresses
+      #
+      #     validates_associated :name, :addresses
+      #   end
+      #
+      # @param [ Array ] *args The arguments to pass to the validator.
+      def validates_associated(*args)
+        validates_with(AssociatedValidator, _merge_attributes(args))
+      end
+
+      # Validates whether or not a field is unique against the documents in the
+      # database.
+      #
+      # @example
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     field :title
+      #
+      #     validates_uniqueness_of :title
+      #   end
+      #
+      # @param [ Array ] *args The arguments to pass to the validator.
+      def validates_uniqueness_of(*args)
+        validates_with(UniquenessValidator, _merge_attributes(args))
+      end
+
+      protected
+
+      # Adds an associated validator for the relation if the validate option
+      # was not provided or set to true.
+      #
+      # @example Set up validation.
+      #   Person.validates_relation(metadata)
+      #
+      # @param [ Metadata ] metadata The relation metadata.
+      #
+      # @since 2.0.0.rc.1
+      def validates_relation(metadata)
+        if metadata.validate?
+          if metadata.embedded?
+            validates_associated(metadata.name)
+          else
+            validates_with(ReferencedValidator, _merge_attributes([metadata.name]))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/validations/associated.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Validations #:nodoc:
+
+    # Validates whether or not an association is valid or not. Will correctly
+    # handle has one and has many associations.
+    #
+    # @example Set up the association validations.
+    #
+    #   class Person
+    #     include Mongoid::Document
+    #     embeds_one :name
+    #     embeds_many :addresses
+    #
+    #     validates_associated :name, :addresses
+    #   end
+    class AssociatedValidator < ActiveModel::EachValidator
+
+      # Validates that the associations provided are either all nil or all
+      # valid. If neither is true then the appropriate errors will be added to
+      # the parent document.
+      #
+      # @example Validate the association.
+      #   validator.validate_each(document, :name, name)
+      #
+      # @param [ Document ] document The document to validate.
+      # @param [ Symbol ] attribute The relation to validate.
+      # @param [ Object ] value The value of the relation.
+      def validate_each(document, attribute, value)
+        document.validated = true
+        valid = Array.wrap(value).collect do |doc|
+          if doc.nil?
+            true
+          else
+            doc.validated? ? true : doc.valid?
+          end
+        end.all?
+        document.validated = false
+        return if valid
+        document.errors.add(attribute, :invalid, options.merge(:value => value))
+      end
+    end
+  end
+end

data/lib/mongoid/validations/referenced.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Validations #:nodoc:
+
+    # Validates whether or not an association is valid or not. Will correctly
+    # handle has one and has many associations. Will *not* load associations if
+    # they aren't already in memory.
+    #
+    # @example Set up the association validations.
+    #
+    #   class Person
+    #     include Mongoid::Document
+    #     references_many :posts, :validate => true
+    #   end
+    class ReferencedValidator < ActiveModel::EachValidator
+
+      # Validate the document for the initialized attributes. Will not load
+      # any association that's not currently loaded.
+      #
+      # @param [ Document ] document The document to validate.
+      def validate(document)
+        attributes.each do |attribute|
+          value = document.instance_variable_get("@#{attribute}".to_sym)
+          validate_each(document, attribute, value)
+        end
+      end
+
+      # Validates that the already loaded associations provided are either all
+      # nil or unchanged or all valid. If neither is true then the appropriate
+      # errors will be added to the parent document.
+      #
+      # @example Validate the loaded association.
+      #   validator.validate_each(document, :name, name)
+      #
+      # @param [ Document ] document The document to validate.
+      # @param [ Symbol ] attribute The relation to validate.
+      # @param [ Object ] value The value of the relation.
+      def validate_each(document, attribute, value)
+        document.validated = true
+        valid =
+          if !value || !value.target
+            true
+          else
+            Array.wrap(value).collect do |doc|
+              if doc.nil? || (!doc.changed? && !doc.new_record?)
+                true
+              else
+                doc.validated? ? true : doc.valid?
+              end
+            end.all?
+          end
+        document.validated = false
+        return if valid
+        document.errors.add(attribute, :invalid, options.merge(:value => value))
+      end
+    end
+  end
+end

data/lib/mongoid/validations/uniqueness.rb

@@ -0,0 +1,85 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Validations #:nodoc:
+
+    # Validates whether or not a field is unique against the documents in the
+    # database.
+    #
+    # @example Define the uniqueness validator.
+    #
+    #   class Person
+    #     include Mongoid::Document
+    #     field :title
+    #
+    #     validates_uniqueness_of :title
+    #   end
+    class UniquenessValidator < ActiveModel::EachValidator
+
+      # Unfortunately, we have to tie Uniqueness validators to a class.
+      def setup(klass)
+        @klass = klass
+      end
+
+      # Validate the document for uniqueness violations.
+      #
+      # @example Validate the document.
+      #   validate_each(person, :title, "Sir")
+      #
+      # @param [ Document ] document The document to validate.
+      # @param [ Symbol ] attribute The field to validate on.
+      # @param [ Object ] value The value of the field.
+      #
+      # @todo Durran: This method needs refactoring.
+      def validate_each(document, attribute, value)
+        if document.embedded?
+          return if document._parent.nil?
+          criteria = document._parent.send(document.metadata.name)
+          # If the parent document embeds_one, no need to validate uniqueness
+          return if criteria.is_a?(Mongoid::Document)
+          criteria = criteria.where(attribute => unique_search_value(value), :_id => {'$ne' => document._id})
+        else
+          criteria = @klass.where(attribute => unique_search_value(value))
+          unless document.new_record?
+            criteria = criteria.where(:_id => {'$ne' => document._id})
+          end
+        end
+
+        Array.wrap(options[:scope]).each do |item|
+          criteria = criteria.where(item => document.attributes[item.to_s])
+        end
+        if criteria.exists?
+          document.errors.add(
+            attribute,
+            :taken,
+            options.except(:case_sensitive, :scope).merge(:value => value)
+          )
+        end
+      end
+
+      protected
+
+      # Determine if the primary key has changed on the document.
+      #
+      # @example Has the key changed?
+      #   key_changed?(document)
+      #
+      # @param [ Document ] document The document to check.
+      #
+      # @return [ true, false ] True if changed, false if not.
+      def key_changed?(document)
+        (document.primary_key || {}).each do |key|
+          return true if document.send("#{key}_changed?")
+        end; false
+      end
+
+      # ensure :case_sensitive is true by default
+      def unique_search_value(value)
+        if options[:case_sensitive] == false
+          value ? Regexp.new("^#{Regexp.escape(value.to_s)}$", Regexp::IGNORECASE) : nil
+        else
+          value
+        end
+      end
+    end
+  end
+end