mongoid_heroku_stable 4.0.0

data/lib/mongoid/relations/touchable.rb

@@ -0,0 +1,94 @@
+# encoding: utf-8
+module Mongoid
+  module Relations
+    module Touchable
+      extend ActiveSupport::Concern
+
+      # Touch the document, in effect updating its updated_at timestamp and
+      # optionally the provided field to the current time. If any belongs_to
+      # relations exist with a touch option, they will be updated as well.
+      #
+      # @example Update the updated_at timestamp.
+      #   document.touch
+      #
+      # @example Update the updated_at and provided timestamps.
+      #   document.touch(:audited)
+      #
+      # @note This will not autobuild relations if those options are set.
+      #
+      # @param [ Symbol ] field The name of an additional field to update.
+      #
+      # @return [ true/false ] false if record is new_record otherwise true.
+      #
+      # @since 3.0.0
+      def touch(field = nil)
+        return false if _root.new_record?
+        current = Time.now
+        field = database_field_name(field)
+        write_attribute(:updated_at, current) if respond_to?("updated_at=")
+        write_attribute(field, current) if field
+
+        touches = touch_atomic_updates(field)
+        unless touches.empty?
+          selector = atomic_selector
+          _root.collection.find(selector).update(positionally(selector, touches))
+        end
+        run_callbacks(:touch)
+        true
+      end
+
+      module ClassMethods
+
+        # Add the metadata to the touchable relations if the touch option was
+        # provided.
+        #
+        # @example Add the touchable.
+        #   Model.touchable(meta)
+        #
+        # @param [ Metadata ] metadata The relation metadata.
+        #
+        # @return [ Class ] The model class.
+        #
+        # @since 3.0.0
+        def touchable(metadata)
+          if metadata.touchable?
+            name = metadata.name
+            method_name = define_relation_touch_method(name)
+            after_create method_name
+            after_destroy method_name
+            after_touch method_name
+          end
+          self
+        end
+
+        private
+
+        # Define the method that will get called for touching belongs_to
+        # relations.
+        #
+        # @api private
+        #
+        # @example Define the touch relation.
+        #   Model.define_relation_touch_method(:band)
+        #
+        # @param [ Symbol ] name The name of the relation.
+        #
+        # @since 3.1.0
+        #
+        # @return [ Symbol ] The method name.
+        def define_relation_touch_method(name)
+          method_name = "touch_#{name}_after_create_or_destroy"
+          class_eval <<-TOUCH
+            def #{method_name}
+              without_autobuild do
+                relation = __send__(:#{name})
+                relation.touch if relation
+              end
+            end
+          TOUCH
+          method_name.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/reloadable.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+module Mongoid
+
+  # This module handles reloading behaviour of documents.
+  #
+  # @since 4.0.0
+  module Reloadable
+
+    # Reloads the +Document+ attributes from the database. If the document has
+    # not been saved then an error will get raised if the configuration option
+    # was set. This can reload root documents or embedded documents.
+    #
+    # @example Reload the document.
+    #   person.reload
+    #
+    # @raise [ Errors::DocumentNotFound ] If the document was deleted.
+    #
+    # @return [ Document ] The document, reloaded.
+    #
+    # @since 1.0.0
+    def reload
+      reloaded = _reload
+      if Mongoid.raise_not_found_error && reloaded.empty?
+        raise Errors::DocumentNotFound.new(self.class, id, id)
+      end
+      @attributes = reloaded
+      @attributes_before_type_cast = {}
+      changed_attributes.clear
+      apply_defaults
+      reload_relations
+      IdentityMap.set(self)
+      run_callbacks(:find) unless _find_callbacks.empty?
+      run_callbacks(:initialize) unless _initialize_callbacks.empty?
+      self
+    end
+
+    private
+
+    # Reload the document, determining if it's embedded or not and what
+    # behaviour to use.
+    #
+    # @example Reload the document.
+    #   document._reload
+    #
+    # @return [ Hash ] The reloaded attributes.
+    #
+    # @since 2.3.2
+    def _reload
+      embedded? ? reload_embedded_document : reload_root_document
+    end
+
+    # Reload the root document.
+    #
+    # @example Reload the document.
+    #   document.reload_root_document
+    #
+    # @return [ Hash ] The reloaded attributes.
+    #
+    # @since 2.3.2
+    def reload_root_document
+      {}.merge(with(consistency: :strong).collection.find(_id: id).one || {})
+    end
+
+    # Reload the embedded document.
+    #
+    # @example Reload the document.
+    #   document.reload_embedded_document
+    #
+    # @return [ Hash ] The reloaded attributes.
+    #
+    # @since 2.3.2
+    def reload_embedded_document
+      extract_embedded_attributes({}.merge(
+        _root.with(consistency: :strong).collection.find(_id: _root.id).one
+      ))
+    end
+
+    # Extract only the desired embedded document from the attributes.
+    #
+    # @example Extract the embedded document.
+    #   document.extract_embedded_attributes(attributes)
+    #
+    # @param [ Hash ] attributes The document in the db.
+    #
+    # @return [ Hash ] The document's extracted attributes.
+    #
+    # @since 2.3.2
+    def extract_embedded_attributes(attributes)
+      atomic_position.split(".").inject(attributes) do |attrs, part|
+        attrs = attrs[part =~ /\d/ ? part.to_i : part]
+        attrs
+      end
+    end
+  end
+end

data/lib/mongoid/scopable.rb

@@ -0,0 +1,379 @@
+# encoding: utf-8
+module Mongoid
+
+  # This module contains behaviour for all Mongoid scoping - named scopes,
+  # default scopes, and criteria accessors via scoped and unscoped.
+  #
+  # @since 4.0.0
+  module Scopable
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :default_scoping
+      class_attribute :_declared_scopes
+      self._declared_scopes = {}
+    end
+
+    private
+
+    # Apply the default scoping to the attributes of the document, as long as
+    # they are not complex queries.
+    #
+    # @api private
+    #
+    # @example Apply the default scoping.
+    #   document.apply_default_scoping
+    #
+    # @return [ true, false ] If default scoping was applied.
+    #
+    # @since 4.0.0
+    def apply_default_scoping
+      if default_scoping
+        default_scoping.call.selector.each do |field, value|
+          attributes[field] = value unless value.respond_to?(:each_pair)
+        end
+      end
+    end
+
+    module ClassMethods
+
+      # Returns a hash of all the scopes defined for this class, including
+      # scopes defined on ancestor classes.
+      #
+      # @example Get the defined scopes for a class
+      #   class Band
+      #     include Mongoid::Document
+      #     field :active, type: Boolean
+      #
+      #     scope :active, where(active: true)
+      #   end
+      #   Band.scopes
+      #
+      # @return [ Hash ] The scopes defined for this class
+      #
+      # @since 3.1.4
+      def scopes
+        defined_scopes = {}
+        ancestors.reverse.each do |klass|
+          if klass.respond_to?(:_declared_scopes)
+            defined_scopes.merge!(klass._declared_scopes)
+          end
+        end
+        defined_scopes.freeze
+      end
+
+      # Add a default scope to the model. This scope will be applied to all
+      # criteria unless #unscoped is specified.
+      #
+      # @example Define a default scope with a criteria.
+      #   class Band
+      #     include Mongoid::Document
+      #     field :active, type: Boolean
+      #     default_scope where(active: true)
+      #   end
+      #
+      # @example Define a default scope with a proc.
+      #   class Band
+      #     include Mongoid::Document
+      #     field :active, type: Boolean
+      #     default_scope ->{ where(active: true) }
+      #   end
+      #
+      # @param [ Proc, Criteria ] scope The default scope.
+      #
+      # @raise [ Errors::InvalidScope ] If the scope is not a proc or criteria.
+      #
+      # @return [ Proc ] The default scope.
+      #
+      # @since 1.0.0
+      def default_scope(value)
+        check_scope_validity(value)
+        self.default_scoping = process_default_scope(value)
+      end
+
+      # Is the class able to have the default scope applied?
+      #
+      # @example Can the default scope be applied?
+      #   Band.default_scopable?
+      #
+      # @return [ true, false ] If the default scope can be applied.
+      #
+      # @since 3.0.0
+      def default_scopable?
+        default_scoping? && !Threaded.executing?(:without_default_scope)
+      end
+
+      # Get a queryable, either the last one on the scope stack or a fresh one.
+      #
+      # @api private
+      #
+      # @example Get a queryable.
+      #   Model.queryable
+      #
+      # @return [ Criteria ] The queryable.
+      #
+      # @since 3.0.0
+      def queryable
+        scope_stack.last || Criteria.new(self)
+      end
+
+      # Create a scope that can be accessed from the class level or chained to
+      # criteria by the provided name.
+      #
+      # @example Create named scopes.
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     field :active, type: Boolean
+      #     field :count, type: Integer
+      #
+      #     scope :active, where(active: true)
+      #     scope :at_least, ->(count){ where(:count.gt => count) }
+      #   end
+      #
+      # @param [ Symbol ] name The name of the scope.
+      # @param [ Proc, Criteria ] conditions The conditions of the scope.
+      #
+      # @raise [ Errors::InvalidScope ] If the scope is not a proc or criteria.
+      # @raise [ Errors::ScopeOverwrite ] If the scope name already exists.
+      #
+      # @since 1.0.0
+      def scope(name, value, &block)
+        normalized = name.to_sym
+        check_scope_validity(value)
+        check_scope_name(normalized)
+        _declared_scopes[normalized] = {
+          scope: strip_default_scope(value),
+          extension: Module.new(&block)
+        }
+        define_scope_method(normalized)
+      end
+
+      # Initializes and returns the current scope stack.
+      #
+      # @example Get the scope stack.
+      #   Person.scope_stack
+      #
+      # @return [ Array<Criteria> ] The scope stack.
+      #
+      # @since 1.0.0
+      def scope_stack
+        Threaded.scope_stack[object_id] ||= []
+      end
+
+      # Get a criteria for the document with normal scoping.
+      #
+      # @example Get the criteria.
+      #   Band.scoped(skip: 10)
+      #
+      # @note This will force the default scope to be applied.
+      #
+      # @param [ Hash ] options Query options for the criteria.
+      #
+      # @option options [ Integer ] :skip Optional number of documents to skip.
+      # @option options [ Integer ] :limit Optional number of documents to
+      #   limit.
+      # @option options [ Array ] :sort Optional sorting options.
+      #
+      # @return [ Criteria ] A scoped criteria.
+      #
+      # @since 3.0.0
+      def scoped(options = nil)
+        queryable.scoped(options)
+      end
+
+      # Get the criteria without the default scoping applied.
+      #
+      # @example Get the unscoped criteria.
+      #   Band.unscoped
+      #
+      # @example Yield to block with no default scoping.
+      #   Band.unscoped do
+      #     Band.where(name: "Depeche Mode")
+      #   end
+      #
+      # @note This will force the default scope to be removed.
+      #
+      # @return [ Criteria, Object ] The unscoped criteria or result of the
+      #   block.
+      #
+      # @since 3.0.0
+      def unscoped
+        if block_given?
+          without_default_scope do
+            yield(self)
+          end
+        else
+          queryable.unscoped
+        end
+      end
+
+      # Get a criteria with the default scope applied, if possible.
+      #
+      # @example Get a criteria with the default scope.
+      #   Model.with_default_scope
+      #
+      # @return [ Criteria ] The criteria.
+      #
+      # @since 3.0.0
+      def with_default_scope
+        queryable.with_default_scope
+      end
+      alias :criteria :with_default_scope
+
+      # Pushes the provided criteria onto the scope stack, and removes it after the
+      # provided block is yielded.
+      #
+      # @example Yield to the criteria.
+      #   Person.with_scope(criteria)
+      #
+      # @param [ Criteria ] criteria The criteria to apply.
+      #
+      # @return [ Criteria ] The yielded criteria.
+      #
+      # @since 1.0.0
+      def with_scope(criteria)
+        scope_stack.push(criteria)
+        begin
+          yield criteria
+        ensure
+          scope_stack.pop
+        end
+      end
+
+      # Execute the block without applying the default scope.
+      #
+      # @example Execute without the default scope.
+      #   Band.without_default_scope do
+      #     Band.where(name: "Depeche Mode")
+      #   end
+      #
+      # @return [ Object ] The result of the block.
+      #
+      # @since 3.0.0
+      def without_default_scope
+        Threaded.begin_execution("without_default_scope")
+        yield
+      ensure
+        Threaded.exit_execution("without_default_scope")
+      end
+
+      private
+
+      # Warns or raises exception if overriding another scope or method.
+      #
+      # @api private
+      #
+      # @example Warn or raise error if name exists.
+      #   Model.valid_scope_name?("test")
+      #
+      # @param [ String, Symbol ] name The name of the scope.
+      #
+      # @raise [ Errors::ScopeOverwrite ] If the name exists and configured to
+      #   raise the error.
+      #
+      # @since 2.1.0
+      def check_scope_name(name)
+        if _declared_scopes[name] || respond_to?(name, true)
+          if Mongoid.scope_overwrite_exception
+            raise Errors::ScopeOverwrite.new(self.name, name)
+          else
+            if Mongoid.logger
+              Mongoid.logger.warn(
+                "Creating scope :#{name}. " +
+                "Overwriting existing method #{self.name}.#{name}."
+              )
+            end
+          end
+        end
+      end
+
+      # Checks if the intended scope is a valid object, either a criteria or
+      # proc with a criteria.
+      #
+      # @api private
+      #
+      # @example Check if the scope is valid.
+      #   Model.check_scope_validity({})
+      #
+      # @param [ Object ] value The intended scope.
+      #
+      # @raise [ Errors::InvalidScope ] If the scope is not a valid object.
+      #
+      # @since 3.0.0
+      def check_scope_validity(value)
+        unless value.respond_to?(:to_proc)
+          raise Errors::InvalidScope.new(self, value)
+        end
+      end
+
+      # Defines the actual class method that will execute the scope when
+      # called.
+      #
+      # @api private
+      #
+      # @example Define the scope class method.
+      #   Model.define_scope_method(:active)
+      #
+      # @param [ Symbol ] name The method/scope name.
+      #
+      # @return [ Method ] The defined method.
+      #
+      # @since 3.0.0
+      def define_scope_method(name)
+        singleton_class.class_eval <<-SCOPE, __FILE__, __LINE__ + 1
+          def #{name}(*args)
+            scoping = _declared_scopes[:#{name}]
+            scope, extension = scoping[:scope][*args], scoping[:extension]
+            criteria = with_default_scope.merge(scope || queryable)
+            criteria.extend(extension)
+            criteria
+          end
+        SCOPE
+      end
+
+      # Process the default scope value. If one already exists, we merge the
+      # new one into the old one.
+      #
+      # @api private
+      #
+      # @example Process the default scope.
+      #   Model.process_default_scope(value)
+      #
+      # @param [ Criteria, Proc ] value The default scope value.
+      #
+      # @since 3.0.5
+      def process_default_scope(value)
+        if existing = default_scoping
+          ->{ existing.call.merge(value.to_proc.call) }
+        else
+          value.to_proc
+        end
+      end
+
+      # Strip the default scope from the provided value, if it is a criteria.
+      # This is used by named scopes - they should not have the default scoping
+      # applied to them.
+      #
+      # @api private
+      #
+      # @example Strip the default scope.
+      #   Model.strip_default_scope
+      #
+      # @param [ Proc, Criteria ] value The value to strip from.
+      #
+      # @return [ Proc ] The stripped criteria, as a proc.
+      #
+      # @since 3.0.0
+      def strip_default_scope(value)
+        if value.is_a?(Criteria)
+          default = default_scoping.try(:call)
+          value.remove_scoping(default)
+          value.to_proc
+        else
+          value
+        end
+      end
+    end
+  end
+end