mongoid 3.1.5 → 8.0.2

data/lib/mongoid/validatable/macros.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Validatable
+    module Macros
+      extend ActiveSupport::Concern
+
+      # 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
+
+      # Validates the format of a field.
+      #
+      # @example
+      #   class Person
+      #     include Mongoid::Document
+      #     field :title
+      #
+      #     validates_format_of :title, with: /\A[a-z0-9 \-_]*\z/i
+      #   end
+      #
+      # @param [ Array ] args The names of the fields to validate.
+      def validates_format_of(*args)
+        validates_with(FormatValidator, _merge_attributes(args))
+      end
+
+      # Validates the length of a field.
+      #
+      # @example
+      #   class Person
+      #     include Mongoid::Document
+      #     field :title
+      #
+      #     validates_length_of :title, minimum: 100
+      #   end
+      #
+      # @param [ Array ] args The names of the fields to validate.
+      def validates_length_of(*args)
+        validates_with(LengthValidator, _merge_attributes(args))
+      end
+
+      # Validates whether or not a field is present - meaning nil or empty.
+      #
+      # @example
+      #   class Person
+      #     include Mongoid::Document
+      #     field :title
+      #
+      #     validates_presence_of :title
+      #   end
+      #
+      # @param [ Array ] args The names of the fields to validate.
+      def validates_presence_of(*args)
+        validates_with(PresenceValidator, _merge_attributes(args))
+      end
+    end
+  end
+end

data/lib/mongoid/validatable/presence.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Validatable
+
+    # Validates that the specified attributes are not blank (as defined by
+    # Object#blank?).
+    #
+    # @example Define the presence validator.
+    #
+    #   class Person
+    #     include Mongoid::Document
+    #     field :title
+    #
+    #     validates_presence_of :title
+    #   end
+    class PresenceValidator < ActiveModel::EachValidator
+
+      # Validate the document for the attribute and value.
+      #
+      # @example Validate the document.
+      #   validator.validate_each(doc, :title, "")
+      #
+      # @param [ Document ] document The document to validate.
+      # @param [ Symbol ] attribute The attribute name.
+      # @param [ Object ] value The current value of the field.
+      def validate_each(document, attribute, value)
+        field = document.fields[document.database_field_name(attribute)]
+        if field.try(:localized?) && !value.blank?
+          value.each_pair do |_locale, _value|
+            document.errors.add(
+              attribute,
+              :blank_in_locale,
+              **options.merge(location: _locale)
+            ) if not_present?(_value)
+          end
+        elsif document.relations.has_key?(attribute.to_s)
+          if relation_or_fk_missing?(document, attribute, value)
+            document.errors.add(attribute, :blank, **options)
+          end
+        else
+          document.errors.add(attribute, :blank, **options) if not_present?(value)
+        end
+      end
+
+      private
+
+      # Returns true if the association is blank or the foreign key is blank.
+      #
+      # @api private
+      #
+      # @example Check is the association or fk is blank.
+      #   validator.relation_or_fk_missing(doc, :name, "")
+      #
+      # @param [ Document ] doc The document.
+      # @param [ Symbol ] attr The attribute.
+      # @param [ Object ] value The value.
+      #
+      # @return [ true | false ] If the doc is missing.
+      def relation_or_fk_missing?(doc, attr, value)
+        return true if value.blank? && doc.send(attr).blank?
+        association = doc.relations[attr.to_s]
+        association.stores_foreign_key? && doc.send(association.foreign_key).blank?
+      end
+
+      # For guarding against false values.
+      #
+      # @api private
+      #
+      # @example Is the value not present?
+      #   validator.not_present?(value)
+      #
+      # @param [ Object ] value The value.
+      #
+      # @return [ true | false ] If the value is not present.
+      def not_present?(value)
+        value.blank? && value != false
+      end
+    end
+  end
+end

data/lib/mongoid/validatable/queryable.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Validatable
+    module Queryable
+
+      # Wrap the validation inside the an execution block that alert's the
+      # client not to clear its persistence options.
+      #
+      # @example Execute the validation with a query.
+      #   with_query(document) do
+      #     #...
+      #   end
+      #
+      # @param [ Document ] document The document being validated.
+      #
+      # @return [ Object ] The result of the yield.
+      def with_query(document)
+        klass = document.class
+        begin
+          Threaded.begin_execution("#{klass.name}-validate-with-query")
+          yield
+        ensure
+          Threaded.exit_execution("#{klass.name}-validate-with-query")
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/validatable/uniqueness.rb

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Validatable
+
+    # 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
+    #
+    # It is also possible to limit the uniqueness constraint to a set of
+    # documents matching certain conditions:
+    #   class Person
+    #     include Mongoid::Document
+    #     field :title
+    #     field :active, type: Boolean
+    #
+    #     validates_uniqueness_of :title, conditions: -> {where(active: true)}
+    #   end
+    class UniquenessValidator < ActiveModel::EachValidator
+      include Queryable
+
+      # 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.
+      def validate_each(document, attribute, value)
+        with_query(document) do
+          attrib, val = to_validate(document, attribute, value)
+          return unless validation_required?(document, attrib)
+          if document.embedded?
+            validate_embedded(document, attrib, val)
+          else
+            validate_root(document, attrib, val)
+          end
+        end
+      end
+
+      private
+
+      # Add the error to the document.
+      #
+      # @api private
+      #
+      # @example Add the error.
+      #   validator.add_error(doc, :name, "test")
+      #
+      # @param [ Document ] document The document to validate.
+      # @param [ Symbol ] attribute The name of the attribute.
+      # @param [ Object ] value The value of the object.
+      def add_error(document, attribute, value)
+        document.errors.add(
+          attribute, :taken, **options.except(:case_sensitive, :scope).merge(value: value)
+        )
+      end
+
+      # Should the uniqueness validation be case sensitive?
+      #
+      # @api private
+      #
+      # @example Is the validation case sensitive?
+      #   validator.case_sensitive?
+      #
+      # @return [ true | false ] If the validation is case sensitive.
+      def case_sensitive?
+        !(options[:case_sensitive] == false)
+      end
+
+      # Create the validation criteria.
+      #
+      # @api private
+      #
+      # @example Create the criteria.
+      #   validator.create_criteria(User, user, :name, "syd")
+      #
+      # @param [ Class | Proxy ] base The base to execute the criteria from.
+      # @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 criteria.
+      def create_criteria(base, document, attribute, value)
+        criteria = scope(base.unscoped, document, attribute)
+        field = document.fields[document.database_field_name(attribute)]
+
+        # In the past, we were calling value.mongoize in all cases, which
+        # would call Object's mongoize method. This is a problem for StringifiedSymbol,
+        # because a Symbol should mongoize to a String, but calling .mongoize
+        # on a Symbol mongoizes it to a Symbol.
+        # Therefore, we call the field's mongoize in all cases except when the
+        # field is localized, because by the time we arrive at this code, the
+        # value is already in the form of { lang => translation } and calling
+        # the field's mongoize will nest that further into { lang =>
+        # "\{ lang => translation \}"} (assuming the field type is a string).
+        # Therefore, we call Object's mongoize method so it returns the hash as
+        # it is.
+        mongoized = field.try(:localized?) ? value.mongoize : field.mongoize(value)
+        criteria.selector.update(criterion(document, attribute, mongoized))
+        criteria
+      end
+
+      # Get the default criteria for checking uniqueness.
+      #
+      # @api private
+      #
+      # @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.
+      def criterion(document, attribute, value)
+        field = document.database_field_name(attribute)
+
+        if value && localized?(document, field)
+          conditions = (value || {}).inject([]) { |acc, (k,v)| acc << { "#{field}.#{k}" => filter(v) }}
+          selector = { "$or" => conditions }
+        else
+          selector = { field => filter(value) }
+        end
+
+        if document.persisted? && !document.embedded?
+          selector.merge!(_id: { "$ne" => document._id })
+        end
+        selector
+      end
+
+      # Filter the value based on whether the check is case sensitive or not.
+      #
+      # @api private
+      #
+      # @example Filter the value.
+      #   validator.filter("testing")
+      #
+      # @param [ Object ] value The value to filter.
+      #
+      # @return [ Object | Regexp ] The value, filtered or not.
+      def filter(value)
+        !case_sensitive? && value ? /\A#{Regexp.escape(value.to_s)}\z/i : value
+      end
+
+      # Scope the criteria to the scope options provided.
+      #
+      # @api private
+      #
+      # @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.
+      def scope(criteria, document, _attribute)
+        Array.wrap(options[:scope]).each do |item|
+          name = document.database_field_name(item)
+          criteria = criteria.where(item => document.attributes[name])
+        end
+        criteria
+      end
+
+      # Should validation be skipped?
+      #
+      # @api private
+      #
+      # @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.
+      def skip_validation?(document)
+        !document._parent || document.embedded_one?
+      end
+
+      # Scope reference has changed?
+      #
+      # @api private
+      #
+      # @example Has scope reference changed?
+      #   validator.scope_value_changed?(doc)
+      #
+      # @param [ Document ] document The embedded document.
+      #
+      # @return [ true | false ] If the scope reference has changed.
+      def scope_value_changed?(document)
+        Array.wrap(options[:scope]).any? do |item|
+          document.send("attribute_changed?", item.to_s)
+        end
+      end
+
+      # Get the name of the field and the value to validate. This is for the
+      # case when we validate an association via the association name and not the key,
+      # we need to send the key name and value to the db, not the association
+      # object.
+      #
+      # @api private
+      #
+      # @example Get the name and key to validate.
+      #   validator.to_validate(doc, :parent, Parent.new)
+      #
+      # @param [ Document ] document The doc getting validated.
+      # @param [ Symbol ] attribute The attribute getting validated.
+      # @param [ Object ] value The value of the attribute.
+      #
+      # @return [ Array<Object, Object> ] The field and value.
+      def to_validate(document, attribute, value)
+        association = document.relations[attribute.to_s]
+        if association && association.stores_foreign_key?
+          [ association.foreign_key, value && value._id ]
+        else
+          [ attribute, value ]
+        end
+      end
+
+      # Validate an embedded document.
+      #
+      # @api private
+      #
+      # @example Validate the embedded document.
+      #   validator.validate_embedded(doc, :name, "test")
+      #
+      # @param [ Document ] document The document.
+      # @param [ Symbol ] attribute The attribute name.
+      # @param [ Object ] value The value.
+      def validate_embedded(document, attribute, value)
+        return if skip_validation?(document)
+        relation = document._parent.send(document.association_name)
+        criteria = create_criteria(relation, document, attribute, value)
+        criteria = criteria.merge(options[:conditions].call) if options[:conditions]
+        criteria = criteria.limit(2)
+        add_error(document, attribute, value) if criteria.count > 1
+      end
+
+      # Validate a root document.
+      #
+      # @api private
+      #
+      # @example Validate the root document.
+      #   validator.validate_root(doc, :name, "test")
+      #
+      # @param [ Document ] document The document.
+      # @param [ Symbol ] attribute The attribute name.
+      # @param [ Object ] value The value.
+      def validate_root(document, attribute, value)
+        klass = document.class
+
+        while klass.superclass.respond_to?(:validators) && klass.superclass.validators.include?(self)
+          klass = klass.superclass
+        end
+        criteria = create_criteria(klass, document, attribute, value)
+        criteria = criteria.merge(options[:conditions].call) if options[:conditions]
+
+        if criteria.read(mode: :primary).exists?
+          add_error(document, attribute, value)
+        end
+      end
+
+      # Are we required to validate the document?
+      #
+      # @example Is validation needed?
+      #   validator.validation_required?(doc, :field)
+      #
+      # @param [ Document ] document The document getting validated.
+      # @param [ Symbol ] attribute The attribute to validate.
+      #
+      # @return [ true | false ] If we need to validate.
+      def validation_required?(document, attribute)
+        document.new_record? ||
+          document.send("attribute_changed?", attribute.to_s) ||
+          scope_value_changed?(document)
+      end
+
+      # Is the attribute localized?
+      #
+      # @api private
+      #
+      # @example Is the attribute localized?
+      #   validator.localized?(doc, :field)
+      #
+      # @param [ Document ] document The document getting validated.
+      # @param [ Symbol ] attribute The attribute to validate.
+      #
+      # @return [ true | false ] If the attribute is localized.
+      def localized?(document, attribute)
+        document.fields[document.database_field_name(attribute)].try(:localized?)
+      end
+    end
+  end
+end

data/lib/mongoid/validatable.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "mongoid/validatable/macros"
+require "mongoid/validatable/localizable"
+require "mongoid/validatable/associated"
+require "mongoid/validatable/format"
+require "mongoid/validatable/length"
+require "mongoid/validatable/queryable"
+require "mongoid/validatable/presence"
+require "mongoid/validatable/uniqueness"
+
+module Mongoid
+
+  # This module provides additional validations that ActiveModel does not
+  # provide: validates_associated and validates_uniqueness_of.
+  module Validatable
+    extend ActiveSupport::Concern
+
+    included do
+      extend Macros
+      include Macros
+    end
+
+    # Begin the associated validation.
+    #
+    # @example Begin validation.
+    #   document.begin_validate
+    def begin_validate
+      Threaded.begin_validate(self)
+    end
+
+    # Exit the associated validation.
+    #
+    # @example Exit validation.
+    #   document.exit_validate
+    def exit_validate
+      Threaded.exit_validate(self)
+    end
+
+    # Given the provided options, are we performing validations?
+    #
+    # @example Are we performing validations?
+    #   document.performing_validations?(validate: true)
+    #
+    # @param [ Hash ] options The options to check.
+    #
+    # @return [ true | false ] If we are validating.
+    def performing_validations?(options = {})
+      options[:validate].nil? ? true : options[:validate]
+    end
+
+    # Overrides the default ActiveModel behavior since we need to handle
+    # validations of associations 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 association.
+    #
+    # @return [ Object ] The value of the field or the association.
+    def read_attribute_for_validation(attr)
+      attribute = database_field_name(attr)
+      if relations.key?(attribute)
+        begin_validate
+        relation = without_autobuild { send(attr) }
+        exit_validate
+        relation.do_or_do_not(:in_memory) || relation
+      elsif fields[attribute].try(:localized?)
+        attributes[attribute]
+      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.
+    def valid?(context = nil)
+      super context ? context : (new_record? ? :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?
+    def validated?
+      Threaded.validated?(self)
+    end
+
+    # Are we currently performing a validation that has a query?
+    #
+    # @example Are we validating with a query?
+    #   document.validating_with_query?
+    #
+    # @return [ true | false ] If we are validating with a query.
+    def validating_with_query?
+      self.class.validating_with_query?
+    end
+
+    module ClassMethods
+
+      # Adds an associated validator for the association if the validate option
+      # was not provided or set to true.
+      #
+      # @example Set up validation.
+      #   Person.validates_relation(association)
+      #
+      # @param [ Association ] association The association metadata.
+      def validates_relation(association)
+        if association.validate?
+          validates_associated(association.name)
+        end
+      end
+
+      # Add validation with the supplied validators for the provided fields
+      # with options.
+      #
+      # @example Validate with a specific validator.
+      #   validates_with MyValidator, on: :create
+      #
+      # @param [ Class<Array> | Hash ] args The validator classes and options.
+      #
+      # @note See ActiveModel::Validations::With for full options. This is
+      #   overridden to add autosave functionality when presence validation is
+      #   added.
+      def validates_with(*args, &block)
+        if args.first == PresenceValidator
+          args.last[:attributes].each do |name|
+            association = relations[name.to_s]
+            if association && association.autosave?
+              Association::Referenced::AutoSave.define_autosave!(association)
+            end
+          end
+        end
+        super
+      end
+
+      # Are we currently performing a validation that has a query?
+      #
+      # @example Are we validating with a query?
+      #   Model.validating_with_query?
+      #
+      # @return [ true | false ] If we are validating with a query.
+      def validating_with_query?
+        Threaded.executing?("#{name}-validate-with-query")
+      end
+    end
+  end
+end

data/lib/mongoid/version.rb

@@ -1,4 +1,5 @@
-# encoding: utf-8
+# frozen_string_literal: true
+
 module Mongoid
-  VERSION = "3.1.5"
+  VERSION = "8.0.2"
 end

data/lib/mongoid/warnings.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Mongoid
+
+  # Encapsulates behavior around logging and caching warnings so they are only
+  # logged once.
+  #
+  # @api private
+  module Warnings
+
+    class << self
+      def warning(id, message)
+        singleton_class.class_eval do
+          define_method("warn_#{id}") do
+            unless instance_variable_get("@#{id}")
+              Mongoid.logger.warn(message)
+              instance_variable_set("@#{id}", true)
+            end
+          end
+        end
+      end
+    end
+
+    warning :geo_haystack_deprecated, 'The geoHaystack type is deprecated.'
+    warning :as_json_compact_deprecated, '#as_json :compact option is deprecated. Please call #compact on the returned Hash object instead.'
+    warning :symbol_type_deprecated, 'The BSON Symbol type is deprecated by MongoDB. Please use String or StringifiedSymbol field types instead of the Symbol field type'
+  end
+end