mongoid-locomotive 2.0.0.beta9

data/lib/mongoid/matchers/exists.rb

@@ -0,0 +1,13 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Exists < Default
+      # Return true if the attribute exists and checking for existence or
+      # return true if the attribute does not exist and checking for
+      # non-existence.
+      def matches?(value)
+        @attribute.nil? != value.values.first
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/gt.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Gt < Default
+      # Return true if the attribute is greater than the value.
+      def matches?(value)
+        determine(value, :>)
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/gte.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Gte < Default
+      # Return true if the attribute is greater than or equal to the value.
+      def matches?(value)
+        determine(value, :>=)
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/in.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class In < Default
+      # Return true if the attribute is in the values.
+      def matches?(value)
+        value.values.first.include?(@attribute)
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/lt.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Lt < Default
+      # Return true if the attribute is less than the value.
+      def matches?(value)
+        determine(value, :<)
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/lte.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Lte < Default
+      # Return true if the attribute is less than or equal to the value.
+      def matches?(value)
+        determine(value, :<=)
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/ne.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Ne < Default
+      # Return true if the attribute and first value are not equal.
+      def matches?(value)
+        @attribute != value.values.first
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/nin.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Nin < Default
+      # Return true if the attribute is not in the value list.
+      def matches?(value)
+        !value.values.first.include?(@attribute)
+      end
+    end
+  end
+end

data/lib/mongoid/matchers/size.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Size < Default
+      # Return true if the attribute size is equal to the first value.
+      def matches?(value)
+        @attribute.size == value.values.first
+      end
+    end
+  end
+end

data/lib/mongoid/memoization.rb

@@ -0,0 +1,33 @@
+module Mongoid #:nodoc
+  module Memoization
+
+    # Handles cases when accessing an association that should be memoized in
+    # the Mongoid specific manner. Does not memoize nil values though
+    def memoized(name, &block)
+      var = "@#{name}"
+      if instance_variable_defined?(var)
+        return instance_variable_get(var)
+      end
+      value = yield
+      instance_variable_set(var, value) if value
+    end
+
+    # Removes an memozied association if it exists
+    def unmemoize(name)
+      var = "@#{name}"
+      remove_instance_variable(var) if instance_variable_defined?(var)
+    end
+
+    # Mongoid specific behavior is to remove the memoized object when setting
+    # the association, or if it wasn't previously memoized it will get set.
+    def reset(name, &block)
+      var = "@#{name}"      
+      value = yield      
+      if instance_variable_defined?(var)
+        remove_instance_variable(var)
+      else
+        instance_variable_set(var, value)
+      end
+    end
+  end
+end

data/lib/mongoid/named_scope.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module NamedScope
+    # Creates a named_scope for the +Document+, similar to ActiveRecord's
+    # named_scopes. +NamedScopes+ are proxied +Criteria+ objects that can be
+    # chained.
+    #
+    # Example:
+    #
+    #   class Person
+    #     include Mongoid::Document
+    #     field :active, :type => Boolean
+    #     field :count, :type => Integer
+    #
+    #     named_scope :active, :where => { :active => true }
+    #     named_scope :count_gt_one, :where => { :count.gt => 1 }
+    #     named_scope :at_least_count, lambda { |count| { :where => { :count.gt => count } } }
+    #   end
+    def named_scope(name, options = {}, &block)
+      name = name.to_sym
+      scopes[name] = lambda do |parent, *args|
+        Scope.new(parent, options.scoped(*args), &block)
+      end
+      (class << self; self; end).class_eval <<-EOT
+        def #{name}(*args)
+          scopes[:#{name}].call(self, *args)
+        end
+      EOT
+    end
+    alias :scope :named_scope
+
+    # Return the scopes or default to an empty +Hash+.
+    def scopes
+      read_inheritable_attribute(:scopes) || write_inheritable_attribute(:scopes, {})
+    end
+  end
+end

data/lib/mongoid/paranoia.rb

@@ -0,0 +1,106 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Paranoid #:nodoc:
+    # Find deleted documents
+    #
+    # Examples:
+    #
+    #   <tt>Person.deleted</tt>  # all deleted employees
+    #   <tt>Company.first.employees.deleted</tt>  # works with a join
+    #   <tt>Person.deleted.find("4c188dea7b17235a2a000001").first</tt>  # retrieve by id a deleted person
+    def deleted
+      where(:deleted_at.exists => false)
+    end
+  end
+
+  # Include this module to get soft deletion of root level documents.
+  # This will add a deleted_at field to the +Document+, managed automatically.
+  # Potentially incompatible with unique indices. (if collisions with deleted items)
+  #
+  # To use:
+  #
+  #   class Person
+  #     include Mongoid::Document
+  #     include Mongoid::Paranoia
+  #   end
+  module Paranoia
+    extend ActiveSupport::Concern
+
+    included do
+      Mongoid::Criteria.send(:include, Mongoid::Paranoid)
+      field :deleted_at, :type => Time
+    end
+
+    # Delete the paranoid +Document+ from the database completely. This will
+    # run the destroy callbacks.
+    #
+    # Example:
+    #
+    # <tt>document.destroy!</tt>
+    def destroy!
+      run_callbacks(:destroy) { delete! }
+    end
+
+    # Delete the paranoid +Document+ from the database completely.
+    #
+    # Example:
+    #
+    # <tt>document.delete!</tt>
+    def delete!
+      @destroyed = true
+      Mongoid::Persistence::Remove.new(self).persist
+    end
+
+    # Delete the +Document+, will set the deleted_at timestamp and not actually
+    # delete it.
+    #
+    # Example:
+    #
+    # <tt>document._remove</tt>
+    #
+    # Returns:
+    #
+    # true
+    def _remove
+      now = Time.now
+      collection.update({ :_id => self.id }, { '$set' => { :deleted_at => Time.now } })
+      @attributes["deleted_at"] = now
+      true
+    end
+
+    alias :delete :_remove
+
+    # Determines if this document is destroyed.
+    #
+    # Returns:
+    #
+    # true if the +Document+ was destroyed.
+    def destroyed?
+      @destroyed || !!deleted_at
+    end
+
+    # Restores a previously soft-deleted document. Handles this by removing the
+    # deleted_at flag.
+    #
+    # Example:
+    #
+    # <tt>document.restore</tt>
+    def restore
+      collection.update({ :_id => self.id }, { '$unset' => { :deleted_at => true } })
+      @attributes.delete("deleted_at")
+    end
+
+    module ClassMethods #:nodoc:
+
+      # Override the default +Criteria+ accessor to only get existing
+      # documents.
+      #
+      # Returns:
+      #
+      # A +Criteria+ for deleted_at not existing.
+      def criteria
+        super.where(:deleted_at.exists => false)
+      end
+    end
+  end
+end

data/lib/mongoid/paths.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Paths #:nodoc:
+    extend ActiveSupport::Concern
+    included do
+      cattr_accessor :__path
+      attr_accessor :_index
+    end
+
+    # Get the insertion modifier for the document. Will be nil on root
+    # documents, $set on embeds_one, $push on embeds_many.
+    #
+    # Example:
+    #
+    # <tt>name.inserter</tt>
+    def _inserter
+      embedded? ? (embedded_many? ? "$push" : "$set") : nil
+    end
+
+    # Return the path to this +Document+ in JSON notation, used for atomic
+    # updates via $set in MongoDB.
+    #
+    # Example:
+    #
+    # <tt>address.path # returns "addresses"</tt>
+    def _path
+      _position.sub!(/\.\d+$/, '') || _position
+    end
+    alias :_pull :_path
+
+    # Returns the positional operator of this document for modification.
+    #
+    # Example:
+    #
+    # <tt>address.position</tt>
+    def _position
+      locator = _index ? (new_record? ? "" : ".#{_index}") : ""
+      embedded? ? "#{_parent._position}#{"." unless _parent._position.blank?}#{@association_name}#{locator}" : ""
+    end
+
+    # Get the removal modifier for the document. Will be nil on root
+    # documents, $unset on embeds_one, $set on embeds_many.
+    #
+    # Example:
+    #
+    # <tt>name.remover</tt>
+    def _remover
+      embedded? ? (_index ? "$pull" : "$unset") : nil
+    end
+
+    # Return the selector for this document to be matched exactly for use
+    # with MongoDB's $ operator.
+    #
+    # Example:
+    #
+    # <tt>address.selector</tt>
+    def _selector
+      embedded? ? _parent._selector.merge("#{_path}._id" => id) : { "_id" => id }
+    end
+  end
+end

data/lib/mongoid/persistence.rb

@@ -0,0 +1,216 @@
+# encoding: utf-8
+require "mongoid/persistence/command"
+require "mongoid/persistence/insert"
+require "mongoid/persistence/insert_embedded"
+require "mongoid/persistence/remove"
+require "mongoid/persistence/remove_all"
+require "mongoid/persistence/remove_embedded"
+require "mongoid/persistence/update"
+
+module Mongoid #:nodoc:
+  # The persistence module is a mixin to provide database accessor methods for
+  # the document. These correspond to the appropriate accessors on a
+  # +Mongo::Collection+ and retain the same DSL.
+  #
+  # Examples:
+  #
+  # <tt>document.insert</tt>
+  # <tt>document.update</tt>
+  # <tt>document.upsert</tt>
+  module Persistence
+    extend ActiveSupport::Concern
+    # Remove the +Document+ from the datbase with callbacks.
+    #
+    # Example:
+    #
+    # <tt>document.destroy</tt>
+    #
+    # TODO: Will get rid of other #destroy once new persistence complete.
+    def destroy
+      run_callbacks(:destroy) { self.destroyed = true if _remove }
+    end
+
+    # Insert a new +Document+ into the database. Will return the document
+    # itself whether or not the save was successful.
+    #
+    # Example:
+    #
+    # <tt>document.insert</tt>
+    def insert(validate = true)
+      Insert.new(self, validate).persist
+    end
+
+    # Remove the +Document+ from the datbase.
+    #
+    # Example:
+    #
+    # <tt>document._remove</tt>
+    #
+    # TODO: Will get rid of other #remove once observable pattern killed.
+    def _remove
+      Remove.new(self).persist
+    end
+
+    alias :delete :_remove
+
+    # Save the document - will perform an insert if the document is new, and
+    # update if not. If a validation error occurs a
+    # Mongoid::Errors::Validations error will get raised.
+    #
+    # Example:
+    #
+    # <tt>document.save!</tt>
+    #
+    # Returns:
+    #
+    # +true+ if validation passed, will raise error otherwise.
+    def save!
+      self.class.fail_validate!(self) unless upsert; true
+    end
+
+    # Update the +Document+ in the datbase.
+    #
+    # Example:
+    #
+    # <tt>document.update</tt>
+    def update(validate = true)
+      Update.new(self, validate).persist
+    end
+
+    # Update the +Document+ attributes in the datbase.
+    #
+    # Example:
+    #
+    # <tt>document.update_attributes(:title => "Sir")</tt>
+    #
+    # Returns:
+    #
+    # +true+ if validation passed, +false+ if not.
+    def update_attributes(attributes = {})
+      write_attributes(attributes); update
+    end
+
+    # Update the +Document+ attributes in the datbase.
+    #
+    # Example:
+    #
+    # <tt>document.update_attributes(:title => "Sir")</tt>
+    #
+    # Returns:
+    #
+    # +true+ if validation passed, raises an error if not
+    def update_attributes!(attributes = {})
+      write_attributes(attributes)
+      result = update
+      self.class.fail_validate!(self) unless result
+      result
+    end
+
+    # Upsert the document - will perform an insert if the document is new, and
+    # update if not.
+    #
+    # Example:
+    #
+    # <tt>document.upsert</tt>
+    #
+    # Returns:
+    #
+    # A +Boolean+ for updates.
+    def upsert(validate = true)
+      validate = parse_validate(validate)
+      if new_record?
+        insert(validate).persisted?
+      else
+        update(validate)
+      end
+    end
+
+    # Save is aliased so that users familiar with active record can have some
+    # semblance of a familiar API.
+    #
+    # Example:
+    #
+    # <tt>document.save</tt>
+    alias :save :upsert
+
+    protected
+    # Alternative validation params.
+    def parse_validate(validate)
+      if validate.is_a?(Hash) && validate.has_key?(:validate)
+        validate = validate[:validate]
+      end
+      validate
+    end
+
+    module ClassMethods #:nodoc:
+
+      # Create a new +Document+. This will instantiate a new document and
+      # insert it in a single call. Will always return the document
+      # whether save passed or not.
+      #
+      # Example:
+      #
+      # <tt>Person.create(:title => "Mr")</tt>
+      #
+      # Returns: the +Document+.
+      def create(attributes = {})
+        new(attributes).tap(&:insert)
+      end
+
+      # Create a new +Document+. This will instantiate a new document and
+      # insert it in a single call. Will always return the document
+      # whether save passed or not, and if validation fails an error will be
+      # raise.
+      #
+      # Example:
+      #
+      # <tt>Person.create!(:title => "Mr")</tt>
+      #
+      # Returns: the +Document+.
+      def create!(attributes = {})
+        document = new(attributes)
+        fail_validate!(document) if document.insert.errors.any?
+        document
+      end
+
+      # Delete all documents given the supplied conditions. If no conditions
+      # are passed, the entire collection will be dropped for performance
+      # benefits. Does not fire any callbacks.
+      #
+      # Example:
+      #
+      # <tt>Person.delete_all(:conditions => { :title => "Sir" })</tt>
+      # <tt>Person.delete_all</tt>
+      #
+      # Returns: true or raises an error.
+      def delete_all(conditions = {})
+        RemoveAll.new(
+          self,
+          false,
+          conditions[:conditions] || {}
+        ).persist
+      end
+
+      # Delete all documents given the supplied conditions. If no conditions
+      # are passed, the entire collection will be dropped for performance
+      # benefits. Fires the destroy callbacks if conditions were passed.
+      #
+      # Example:
+      #
+      # <tt>Person.destroy_all(:conditions => { :title => "Sir" })</tt>
+      # <tt>Person.destroy_all</tt>
+      #
+      # Returns: true or raises an error.
+      def destroy_all(conditions = {})
+        documents = all(conditions)
+        count = documents.count
+        documents.each { |doc| doc.destroy }; count
+      end
+
+      # Raise an error if validation failed.
+      def fail_validate!(document)
+        raise Errors::Validations.new(document)
+      end
+    end
+  end
+end