mongoid-multi-db 3.0.0

data/lib/mongoid/validations/associated.rb

@@ -0,0 +1,46 @@
+# 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)
+        begin
+          document.begin_validate
+          valid = Array.wrap(value).collect do |doc|
+            if doc.nil?
+              true
+            else
+              doc.validated? ? true : doc.valid?
+            end
+          end.all?
+        ensure
+          document.exit_validate
+        end
+        document.errors.add(attribute, :invalid) unless valid
+      end
+    end
+  end
+end

data/lib/mongoid/validations/uniqueness.rb

@@ -0,0 +1,145 @@
+# 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
+      attr_reader :klass
+
+      # Unfortunately, we have to tie Uniqueness validators to a class.
+      #
+      # @example Setup the validator.
+      #   UniquenessValidator.new.setup(Person)
+      #
+      # @param [ Class ] klass The class getting validated.
+      #
+      # @since 1.0.0
+      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.
+      #
+      # @return [ Errors ] The errors.
+      #
+      # @since 1.0.0
+      def validate_each(document, attribute, value)
+        if document.embedded?
+          return if skip_validation?(document)
+          relation = document._parent.send(document.metadata.name)
+          criteria = relation.where(criterion(document, attribute, value))
+          criteria = scope(criteria, document, attribute)
+          if document.primary_key == Array.wrap(attribute)
+            document.errors.add(attribute, :taken) if criteria.count > 1
+          else
+            document.errors.add(attribute, :taken) if criteria.exists?
+          end
+        else
+          criteria = klass.where(criterion(document, attribute, value))
+          criteria = scope(criteria, document, attribute)
+          document.errors.add(attribute, :taken) if criteria.exists?
+        end
+      end
+
+      protected
+
+      # Should the uniqueness validation be case sensitive?
+      #
+      # @example Is the validation case sensitive?
+      #   validator.case_sensitive?
+      #
+      # @return [ true, false ] If the validation is case sensitive.
+      #
+      # @since 2.3.0
+      def case_sensitive?
+        !(options[:case_sensitive] == false)
+      end
+
+      # Get the default criteria for checking uniqueness.
+      #
+      # @example Get the criteria.
+      #   validator.criterion(person, :title, "Sir")
+      #
+      # @param [ Document ] document The document to validate.
+      # @param [ Symbol ] attribute The name of the attribute.
+      # @param [ Object ] value The value of the object.
+      #
+      # @return [ Criteria ] The uniqueness criteria.
+      #
+      # @since 2.3.0
+      def criterion(document, attribute, value)
+        { attribute => filter(value) }.tap do |selector|
+          if document.persisted? ||
+            (document.embedded? && (document.primary_key != Array.wrap(attribute)))
+            selector.merge!(:_id => { "$ne" => document.id })
+          end
+        end
+      end
+
+      # Filter the value based on whether the check is case sensitive or not.
+      #
+      # @example Filter the value.
+      #   validator.filter("testing")
+      #
+      # @param [ Object ] value The value to filter.
+      #
+      # @return [ Object, Regexp ] The value, filtered or not.
+      #
+      # @since 2.3.0
+      def filter(value)
+        !case_sensitive? && value ? /^#{Regexp.escape(value.to_s)}$/i : value
+      end
+
+      # Scope the criteria to the scope options provided.
+      #
+      # @example Scope the criteria.
+      #   validator.scope(criteria, document)
+      #
+      # @param [ Criteria ] criteria The criteria to scope.
+      # @param [ Document ] document The document being validated.
+      #
+      # @return [ Criteria ] The scoped criteria.
+      #
+      # @since 2.3.0
+      def scope(criteria, document, attribute)
+        unless document.primary_key == Array.wrap(attribute)
+          Array.wrap(options[:scope]).each do |item|
+            criteria = criteria.where(item => document.attributes[item.to_s])
+          end
+        end
+        criteria
+      end
+
+      # Should validation be skipped?
+      #
+      # @example Should the validation be skipped?
+      #   validator.skip_validation?(doc)
+      #
+      # @param [ Document ] document The embedded document.
+      #
+      # @return [ true, false ] If the validation should be skipped.
+      #
+      # @since 2.3.0
+      def skip_validation?(document)
+        !document._parent || document.embedded_one?
+      end
+    end
+  end
+end

data/lib/mongoid/version.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  VERSION = "3.0.0"
+end

data/lib/mongoid/versioning.rb

@@ -0,0 +1,185 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  # Include this module to get automatic versioning of root level documents.
+  # This will add a version field to the +Document+ and a has_many association
+  # with all the versions contained in it.
+  module Versioning
+    extend ActiveSupport::Concern
+
+    included do
+      field :version, :type => Integer, :default => 1
+
+      embeds_many \
+        :versions,
+        :class_name => self.name,
+        :validate => false,
+        :cyclic => true,
+        :inverse_of => nil,
+        :versioned => true
+
+      set_callback :save, :before, :revise, :if => :revisable?
+
+      class_attribute :version_max
+      self.cyclic = true
+    end
+
+    # Create a new version of the +Document+. This will load the previous
+    # document from the database and set it as the next version before saving
+    # the current document. It then increments the version number. If a #max_versions
+    # limit is set in the model and it's exceeded, the oldest version gets discarded.
+    #
+    # @example Revise the document.
+    #   person.revise
+    #
+    # @since 1.0.0
+    def revise
+      previous = previous_revision
+      if previous && versioned_attributes_changed?
+        versions.build(previous.versioned_attributes).attributes.delete("_id")
+        if version_max.present? && versions.length > version_max
+          versions.delete(versions.first)
+        end
+        self.version = (version || 1 ) + 1
+      end
+    end
+
+    # Forces the creation of a new version of the +Document+, regardless of
+    # whether a change was actually made.
+    #
+    # @example Revise the document.
+    #   person.revise!
+    #
+    # @since 2.2.1
+    def revise!
+      new_version = versions.build((previous_revision || self).versioned_attributes)
+      versions.shift if version_max.present? && versions.length > version_max
+      self.version = (version || 1 ) + 1
+      save
+    end
+
+    # Filters the results of +changes+ by removing any fields that should
+    # not be versioned.
+    #
+    # @return [ Hash ] A hash of versioned changed attributes.
+    #
+    # @since 2.1.0
+    def versioned_changes
+      only_versioned_attributes(changes)
+    end
+
+    # Filters the results of +attributes+ by removing any fields that should
+    # not be versioned.
+    #
+    # @return [ Hash ] A hash of versioned attributes.
+    #
+    # @since 2.1.0
+    def versioned_attributes
+      only_versioned_attributes(attributes)
+    end
+
+    # Check if any versioned fields have been modified. This is similar
+    # to +changed?+, except this method also ignores fields set to be
+    # ignored by versioning.
+    #
+    # @return [ Boolean ] Whether fields that will be versioned have changed.
+    #
+    # @since 2.1.0
+    def versioned_attributes_changed?
+      !versioned_changes.empty?
+    end
+
+    # Executes a block that temporarily disables versioning. This is for cases
+    # where you do not want to version on every save.
+    #
+    # @example Execute a save without versioning.
+    #   person.versionless(&:save)
+    #
+    # @return [ Object ] The document or result of the block execution.
+    #
+    # @since 2.0.0
+    def versionless
+      @versionless = true
+      result = yield(self) if block_given?
+      @versionless = false
+      result || self
+    end
+
+    private
+
+    # Find the previous version of this document in the database, or if the
+    # document had been saved without versioning return the persisted one.
+    #
+    # @example Find the last version.
+    #   document.find_last_version
+    #
+    # @return [ Document, nil ] The previously saved document.
+    #
+    # @since 2.0.0
+    def previous_revision
+      _loading_revision do
+        self.class.
+          where(:_id => id).
+          any_of({ :version => version }, { :version => nil }).first
+      end
+    end
+
+    # Is the document able to be revised? This is true if the document has
+    # changed and we have not explicitly told it not to version.
+    #
+    # @example Is the document revisable?
+    #   document.revisable?
+    #
+    # @return [ true, false ] If the document is revisable.
+    #
+    # @since 2.0.0
+    def revisable?
+      versioned_attributes_changed? && !versionless?
+    end
+
+    # Are we in versionless mode? This is true if in a versionless block on the
+    # document.
+    #
+    # @example Is the document in versionless mode?
+    #   document.versionless?
+    #
+    # @return [ true, false ] Is the document not currently versioning.
+    #
+    # @since 2.0.0
+    def versionless?
+      !!@versionless
+    end
+
+    # Filters fields that should not be versioned out of an attributes hash.
+    # Dynamic attributes are always versioned.
+    #
+    # @param [ Hash ] A hash with field names as keys.
+    #
+    # @return [ Hash ] The hash without non-versioned columns.
+    #
+    # @since 2.1.0
+    def only_versioned_attributes(hash)
+      {}.tap do |versioned|
+        hash.except("versions").each_pair do |name, value|
+          field = fields[name]
+          versioned[name] = value if !field || field.versioned?
+        end
+      end
+    end
+
+    module ClassMethods #:nodoc:
+
+      # Sets the maximum number of versions to store.
+      #
+      # @example Set the maximum.
+      #   Person.max_versions(5)
+      #
+      # @param [ Integer ] number The maximum number to store.
+      #
+      # @return [ Integer ] The max number of versions.
+      def max_versions(number)
+        self.version_max = number.to_i
+      end
+    end
+  end
+end

data/lib/rack/mongoid.rb

@@ -0,0 +1,2 @@
+# encoding: utf-8
+require "rack/mongoid/middleware/identity_map"

data/lib/rack/mongoid/middleware/identity_map.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+module Rack #:nodoc:
+  module Mongoid #:nodoc:
+    module Middleware #:nodoc:
+
+      # This middleware contains the behaviour needed to properly use the
+      # identity map in Rack based applications.
+      class IdentityMap
+
+        # Initialize the new middleware.
+        #
+        # @example Init the middleware.
+        # IdentityMap.new(app)
+        #
+        # @param [ Object ] app The application.
+        #
+        # @since 2.1.0
+        def initialize(app)
+          @app = app
+        end
+
+        # Make the request with the provided environment.
+        #
+        # @example Make the request.
+        # identity_map.call(env)
+        #
+        # @param [ Object ] env The environment.
+        #
+        # @return [ Array ] The status, headers, and response.
+        #
+        # @since 2.1.0
+        def call(env)
+          ::Mongoid.unit_of_work { @app.call(env) }
+        end
+      end
+    end
+  end
+end

data/lib/rails/generators/mongoid/config/config_generator.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+require 'rails/generators/mongoid_generator'
+
+module Mongoid
+  module Generators
+    class ConfigGenerator < Rails::Generators::Base
+      desc "Creates a Mongoid configuration file at config/mongoid.yml"
+
+      argument :database_name, :type => :string, :optional => true
+
+      def self.source_root
+        @_mongoid_source_root ||= File.expand_path("../templates", __FILE__)
+      end
+
+      def app_name
+        Rails::Application.subclasses.first.parent.to_s.underscore
+      end
+
+      def create_config_file
+        template 'mongoid.yml', File.join('config', "mongoid.yml")
+      end
+
+    end
+  end
+end