mongodoc 0.1.2 → 0.2.0

data/lib/mongodoc/criteria.rb

@@ -12,7 +12,7 @@ module MongoDoc #:nodoc:
   #
   # <tt>criteria = Criteria.new</tt>
   #
-  # <tt>criteria.select(:field => "value").only(:field).skip(20).limit(20)</tt>
+  # <tt>criteria.only(:field => "value").only(:field).skip(20).limit(20)</tt>
   #
   # <tt>criteria.execute</tt>
   class Criteria
@@ -25,7 +25,17 @@ module MongoDoc #:nodoc:
 
     include Enumerable
 
-    attr_reader :klass, :options, :selector
+    attr_reader :collection, :klass, :options, :selector
+
+    # Create the new +Criteria+ object. This will initialize the selector
+    # and options hashes, as well as the type of criteria.
+    #
+    # Options:
+    #
+    # klass: The class to execute on.
+    def initialize(klass)
+      @selector, @options, @klass = {}, {}, klass
+    end
 
     # Returns true if the supplied +Enumerable+ or +Criteria+ is equal to the results
     # of this +Criteria+ or the criteria itself.
@@ -41,7 +51,7 @@ module MongoDoc #:nodoc:
         self.selector == other.selector && self.options == other.options
       when Enumerable
         @collection ||= execute
-        return (@collection == other)
+        return (collection == other)
       else
         return false
       end
@@ -55,31 +65,20 @@ module MongoDoc #:nodoc:
     #
     # Example:
     #
-    # <tt>criteria.select(:field1).where(:field1 => "Title").aggregate(Person)</tt>
-    def aggregate(use_klass = nil)
-      aggregating_klass = use_klass ? use_klass : klass
-      aggregating_klass.collection.group(options[:fields], selector, { :count => 0 }, AGGREGATE_REDUCE)
+    # <tt>criteria.only(:field1).where(:field1 => "Title").aggregate</tt>
+    def aggregate
+      klass.collection.group(options[:fields], selector, { :count => 0 }, AGGREGATE_REDUCE, true)
     end
 
-    # Adds a criterion to the +Criteria+ that specifies values that must all
-    # be matched in order to return results. Similar to an "in" clause but the
-    # underlying conditional logic is an "AND" and not an "OR". The MongoDB
-    # conditional operator that will be used is "$all".
-    #
-    # Options:
-    #
-    # selections: A +Hash+ where the key is the field name and the value is an
-    # +Array+ of values that must all match.
+    # Get all the matching documents in the database for the +Criteria+.
     #
     # Example:
     #
-    # <tt>criteria.every(:field => ["value1", "value2"])</tt>
+    # <tt>criteria.all</tt>
     #
-    # <tt>criteria.every(:field1 => ["value1", "value2"], :field2 => ["value1"])</tt>
-    #
-    # Returns: <tt>self</tt>
-    def every(selections = {})
-      selections.each { |key, value| selector[key] = { "$all" => value } }; self
+    # Returns: <tt>Array</tt>
+    def all
+      collect
     end
 
     # Get the count of matching documents in the database for the +Criteria+.
@@ -102,12 +101,97 @@ module MongoDoc #:nodoc:
     def each(&block)
       @collection ||= execute
       if block_given?
-        @collection.each(&block)
-      else
-        self
+        @collection = collection.inject([]) do |container, item|
+          container << item
+          yield item
+          container
+        end
+      end
+      self
+    end
+
+    GROUP_REDUCE = "function(obj, prev) { prev.group.push(obj); }"
+    # Groups the criteria. This will take the internally built selector and options
+    # and pass them on to the Ruby driver's +group()+ method on the collection. The
+    # collection itself will be retrieved from the class provided, and once the
+    # query has returned it will provided a grouping of keys with objects.
+    #
+    # Example:
+    #
+    # <tt>criteria.only(:field1).where(:field1 => "Title").group</tt>
+    def group
+      klass.collection.group(
+        options[:fields],
+        selector,
+        { :group => [] },
+        GROUP_REDUCE,
+        true
+      ).collect {|docs| docs["group"] = MongoDoc::BSON.decode(docs["group"]); docs }
+    end
+
+    # Return the last result for the +Criteria+. Essentially does a find_one on
+    # the collection with the sorting reversed. If no sorting parameters have
+    # been provided it will default to ids.
+    #
+    # Example:
+    #
+    # <tt>Criteria.only(:name).where(:name = "Chrissy").last</tt>
+    def last
+      opts = options.dup
+      sorting = opts[:sort]
+      sorting = [[:_id, :asc]] unless sorting
+      opts[:sort] = sorting.collect { |option| [ option.first, Criteria.invert(option.last) ] }
+      klass.collection.find_one(selector, opts)
+    end
+
+    # Return the first result for the +Criteria+.
+    #
+    # Example:
+    #
+    # <tt>Criteria.only(:name).where(:name = "Chrissy").one</tt>
+    def one
+      klass.collection.find_one(selector, options.dup)
+    end
+    alias :first :one
+
+    # Translate the supplied argument hash
+    #
+    # Options:
+    #
+    # criteria_conditions: Hash of criteria keys, and parameter values
+    #
+    # Example:
+    #
+    # <tt>criteria.criteria(:where => { :field => "value"}, :limit => 20)</tt>
+    #
+    # Returns <tt>self</tt>
+    def criteria(criteria_conditions = {})
+      criteria_conditions.inject(self) do |criteria, (key, value)|
+        criteria.send(key, value)
       end
     end
 
+    # Adds a criterion to the +Criteria+ that specifies values that must all
+    # be matched in order to return results. Similar to an "in" clause but the
+    # underlying conditional logic is an "AND" and not an "OR". The MongoDB
+    # conditional operator that will be used is "$all".
+    #
+    # Options:
+    #
+    # selections: A +Hash+ where the key is the field name and the value is an
+    # +Array+ of values that must all match.
+    #
+    # Example:
+    #
+    # <tt>criteria.every(:field => ["value1", "value2"])</tt>
+    #
+    # <tt>criteria.every(:field1 => ["value1", "value2"], :field2 => ["value1"])</tt>
+    #
+    # Returns: <tt>self</tt>
+    def every(selections = {})
+      selections.each { |key, value| selector[key] = { "$all" => value } }; self
+    end
+
     # Adds a criterion to the +Criteria+ that specifies values that are not allowed
     # to match any document in the database. The MongoDB conditional operator that
     # will be used is "$ne".
@@ -146,32 +230,19 @@ module MongoDoc #:nodoc:
       self
     end
 
-    # Return the first result for the +Criteria+.
+    # Adds a criterion to the +Criteria+ that specifies an id that must be matched.
     #
-    # Example:
+    # Options:
     #
-    # <tt>Criteria.select(:name).where(:name = "Chrissy").one</tt>
-    def one
-      klass.collection.find_one(selector, options.dup)
-    end
-    alias :first :one
-
-    GROUP_REDUCE = "function(obj, prev) { prev.group.push(obj); }"
-    # Groups the criteria. This will take the internally built selector and options
-    # and pass them on to the Ruby driver's +group()+ method on the collection. The
-    # collection itself will be retrieved from the class provided, and once the
-    # query has returned it will provided a grouping of keys with objects.
+    # id_or_object_id: A +String+ representation of a <tt>Mongo::ObjectID</tt>
     #
     # Example:
     #
-    # <tt>criteria.select(:field1).where(:field1 => "Title").group(Person)</tt>
-    def group(use_klass = nil)
-      (use_klass || klass).collection.group(
-        options[:fields],
-        selector,
-        { :group => [] },
-        GROUP_REDUCE
-      ).collect {|docs| docs["group"] = MongoDoc::BSON.decode(docs["group"]); docs }
+    # <tt>criteria.id("4ab2bc4b8ad548971900005c")</tt>
+    #
+    # Returns: <tt>self</tt>
+    def id(id_or_object_id)
+      selector[:_id] = id_or_object_id; self
     end
 
     # Adds a criterion to the +Criteria+ that specifies values where any can
@@ -194,47 +265,6 @@ module MongoDoc #:nodoc:
       inclusions.each { |key, value| selector[key] = { "$in" => value } }; self
     end
 
-    # Adds a criterion to the +Criteria+ that specifies an id that must be matched.
-    #
-    # Options:
-    #
-    # object_id: A +String+ representation of a <tt>Mongo::ObjectID</tt>
-    #
-    # Example:
-    #
-    # <tt>criteria.id("4ab2bc4b8ad548971900005c")</tt>
-    #
-    # Returns: <tt>self</tt>
-    def id(object_id)
-      selector[:_id] = object_id; self
-    end
-
-    # Create the new +Criteria+ object. This will initialize the selector
-    # and options hashes, as well as the type of criteria.
-    #
-    # Options:
-    #
-    # type: One of :all, :first:, or :last
-    # klass: The class to execute on.
-    def initialize(klass)
-      @selector, @options, @klass = {}, {}, klass
-    end
-
-    # Return the last result for the +Criteria+. Essentially does a find_one on
-    # the collection with the sorting reversed. If no sorting parameters have
-    # been provided it will default to ids.
-    #
-    # Example:
-    #
-    # <tt>Criteria.select(:name).where(:name = "Chrissy").last</tt>
-    def last
-      opts = options.dup
-      sorting = opts[:sort]
-      sorting = [[:_id, :asc]] unless sorting
-      opts[:sort] = sorting.collect { |option| [ option.first, Criteria.invert(option.last) ] }
-      klass.collection.find_one(selector, opts)
-    end
-
     # Adds a criterion to the +Criteria+ that specifies the maximum number of
     # results to return. This is mostly used in conjunction with <tt>skip()</tt>
     # to handle paginated results.
@@ -252,56 +282,6 @@ module MongoDoc #:nodoc:
       options[:limit] = value; self
     end
 
-    # Merges another object into this +Criteria+. The other object may be a
-    # +Criteria+ or a +Hash+. This is used to combine multiple scopes together,
-    # where a chained scope situation may be desired.
-    #
-    # Options:
-    #
-    # other: The +Criteria+ or +Hash+ to merge with.
-    #
-    # Example:
-    #
-    # <tt>criteria.merge({ :conditions => { :title => "Sir" } })</tt>
-    def merge(other)
-      selector.update(other.selector)
-      options.update(other.options)
-    end
-
-    # Used for chaining +Criteria+ scopes together in the for of class methods
-    # on the +Document+ the criteria is for.
-    #
-    # Options:
-    #
-    # name: The name of the class method on the +Document+ to chain.
-    # args: The arguments passed to the method.
-    #
-    # Example:
-    #
-    #   class Person < Mongoid::Document
-    #     field :title
-    #     field :terms, :type => Boolean, :default => false
-    #
-    #     class << self
-    #       def knights
-    #         all(:conditions => { :title => "Sir" })
-    #       end
-    #
-    #       def accepted
-    #         all(:conditions => { :terms => true })
-    #       end
-    #     end
-    #   end
-    #
-    #   Person.accepted.knights #returns a merged criteria of the 2 scopes.
-    #
-    # Returns: <tt>Criteria</tt>
-    def method_missing(name, *args)
-      new_scope = klass.send(name)
-      new_scope.merge(self)
-      new_scope
-    end
-
     # Adds a criterion to the +Criteria+ that specifies values where none
     # should match in order to return results. This is similar to an SQL "NOT IN"
     # clause. The MongoDB conditional operator that will be used is "$nin".
@@ -363,7 +343,7 @@ module MongoDoc #:nodoc:
     def paginate
       @collection ||= execute
       WillPaginate::Collection.create(page, per_page, count) do |pager|
-        pager.replace(@collection.to_a)
+        pager.replace(collection.to_a)
       end
     end
 
@@ -382,10 +362,10 @@ module MongoDoc #:nodoc:
     #
     # Example:
     #
-    # <tt>criteria.select(:field1, :field2, :field3)</tt>
+    # <tt>criteria.only(:field1, :field2, :field3)</tt>
     #
     # Returns: <tt>self</tt>
-    def select(*args)
+    def only(*args)
       options[:fields] = args.flatten if args.any?; self
     end
 
@@ -407,6 +387,36 @@ module MongoDoc #:nodoc:
       options[:skip] = value; self
     end
 
+    # Adds a criterion to the +Criteria+ that specifies values that must
+    # be matched in order to return results. This is similar to a SQL "WHERE"
+    # clause. This is the actual selector that will be provided to MongoDB,
+    # similar to the Javascript object that is used when performing a find()
+    # in the MongoDB console.
+    #
+    # Options:
+    #
+    # selector_or_js: A +Hash+ that must match the attributes of the +Document+
+    # or a +String+ of js code.
+    #
+    # Example:
+    #
+    # <tt>criteria.where(:field1 => "value1", :field2 => 15)</tt>
+    #
+    # <tt>criteria.where('this.a > 3')</tt>
+    #
+    # Returns: <tt>self</tt>
+    def where(selector_or_js = {})
+      case selector_or_js
+      when String
+        selector['$where'] = selector_or_js
+      else
+        selector.merge!(selector_or_js)
+      end
+      self
+    end
+    alias :and :where
+    alias :conditions :where
+
     # Translate the supplied arguments into a +Criteria+ object.
     #
     # If the passed in args is a single +String+, then it will
@@ -427,27 +437,8 @@ module MongoDoc #:nodoc:
     #
     # Returns a new +Criteria+ object.
     def self.translate(klass, params = {})
-      return new(klass).id(params).one if params.is_a?(String)
-      return new(klass).where(params.delete(:conditions)).extras(params)
-    end
-
-    # Adds a criterion to the +Criteria+ that specifies values that must
-    # be matched in order to return results. This is similar to a SQL "WHERE"
-    # clause. This is the actual selector that will be provided to MongoDB,
-    # similar to the Javascript object that is used when performing a find()
-    # in the MongoDB console.
-    #
-    # Options:
-    #
-    # selectior: A +Hash+ that must match the attributes of the +Document+.
-    #
-    # Example:
-    #
-    # <tt>criteria.where(:field1 => "value1", :field2 => 15)</tt>
-    #
-    # Returns: <tt>self</tt>
-    def where(add_selector = {})
-      selector.merge!(add_selector); self
+      return new(klass).id(params).one unless params.is_a?(Hash)
+      return new(klass).criteria(params)
     end
 
     protected

data/lib/mongodoc/cursor.rb

@@ -1,5 +1,7 @@
 module MongoDoc
   class Cursor
+    include Enumerable
+
     attr_accessor :_cursor
     delegate :close, :closed?, :count, :explain, :limit, :query_options_hash, :query_opts, :skip, :sort, :to => :_cursor
 
@@ -8,17 +10,17 @@ module MongoDoc
     end
 
     def each
-      _cursor.each do |next_object|
-        yield MongoDoc::BSON.decode(next_object)
+      _cursor.each do |next_document|
+        yield MongoDoc::BSON.decode(next_document)
       end
     end
 
-    def next_object
-      MongoDoc::BSON.decode(_cursor.next_object)
+    def next_document
+      MongoDoc::BSON.decode(_cursor.next_document)
     end
 
     def to_a
       MongoDoc::BSON.decode(_cursor.to_a)
     end
   end
-end
+end

data/lib/mongodoc/document.rb

@@ -2,18 +2,27 @@ require 'mongodoc/bson'
 require 'mongodoc/query'
 require 'mongodoc/attributes'
 require 'mongodoc/criteria'
+require 'mongodoc/finders'
+require 'mongodoc/named_scope'
 
 module MongoDoc
   class DocumentInvalidError < RuntimeError; end
   class NotADocumentError < RuntimeError; end
 
-  class Document
-    extend MongoDoc::Attributes
-    include Validatable
+  module Document
 
-    attr_accessor :_id
-    alias :id :_id
-    alias :to_param :_id
+    def self.included(klass)
+      klass.class_eval do
+        include Attributes
+        extend ClassMethods
+        extend Finders
+        extend NamedScope
+        include Validatable
+
+        alias :id :_id
+        alias :to_param :_id
+      end
+    end
 
     def initialize(attrs = {})
       self.attributes = attrs
@@ -24,6 +33,13 @@ module MongoDoc
       self.class._attributes.all? {|var| self.send(var) == other.send(var)}
     end
 
+    def attributes
+      self.class._attributes.inject({}) do |hash, attr|
+        hash[attr] = send(attr)
+        hash
+      end
+    end
+
     def attributes=(attrs)
       attrs.each do |key, value|
         send("#{key}=", value)
@@ -39,7 +55,7 @@ module MongoDoc
       return _save(false) unless validate and not valid?
       false
     end
-    
+
     def save!
       return _root.save! if _root
       raise DocumentInvalidError unless valid?
@@ -56,18 +72,28 @@ module MongoDoc
     end
 
     def update_attributes(attrs)
+      strict = attrs.delete(:__strict__)
       self.attributes = attrs
-      return _propose_update_attributes(self, path_to_root(attrs), false) if valid?
-      false
+      return false unless valid?
+      if strict
+        _strict_update_attributes(_path_to_root(self, attrs), false)
+      else
+        _naive_update_attributes(_path_to_root(self, attrs), false)
+      end
     end
 
     def update_attributes!(attrs)
+      strict = attrs.delete(:__strict__)
       self.attributes = attrs
       raise DocumentInvalidError unless valid?
-      _propose_update_attributes(self, path_to_root(attrs), true)
+      if strict
+        _strict_update_attributes(_path_to_root(self, attrs), true)
+      else
+        _naive_update_attributes(_path_to_root(self, attrs), true)
+      end
     end
 
-    class << self
+    module ClassMethods
       def bson_create(bson_hash, options = {})
         new.tap do |obj|
           bson_hash.each do |name, value|
@@ -84,16 +110,12 @@ module MongoDoc
         self.to_s.tableize.gsub('/', '.')
       end
 
-      def count
-        collection.count
-      end
-
       def create(attrs = {})
         instance = new(attrs)
         _create(instance, false) if instance.valid?
         instance
       end
-    
+
       def create!(attrs = {})
         instance = new(attrs)
         raise MongoDoc::DocumentInvalidError unless instance.valid?
@@ -101,12 +123,16 @@ module MongoDoc
         instance
       end
 
-      def criteria
-        Criteria.new(self)
-      end
+      protected
 
-      def find_one(id)
-        MongoDoc::BSON.decode(collection.find_one(id))
+      def _create(instance, safe)
+        instance.send(:notify_before_save_observers)
+        instance._id = collection.insert(instance, :safe => safe)
+        instance.send(:notify_save_success_observers)
+        instance._id
+      rescue Mongo::MongoDBError => e
+        instance.send(:notify_save_failed_observers)
+        raise e
       end
     end
 
@@ -115,24 +141,62 @@ module MongoDoc
     def _collection
       self.class.collection
     end
-    
-    def _propose_update_attributes(src, attrs, safe)
-      return _parent.send(:_propose_update_attributes, src, attrs, safe) if _parent
-      _update_attributes(attrs, safe)
+
+    def _naive_update_attributes(attrs, safe)
+      return _root.send(:_naive_update_attributes, attrs, safe) if _root
+      _collection.update({'_id' => self._id}, MongoDoc::Query.set_modifier(attrs), :safe => safe)
+    end
+
+    def _strict_update_attributes(attrs, safe, selector = {})
+      return _root.send(:_strict_update_attributes, attrs, safe, _selector_path_to_root('_id' => _id)) if _root
+      _collection.update({'_id' => _id}.merge(selector), MongoDoc::Query.set_modifier(attrs), :safe => safe)
     end
 
     def _save(safe)
+      notify_before_save_observers
       self._id = _collection.save(self, :safe => safe)
+      notify_save_success_observers
+      self._id
+    rescue Mongo::MongoDBError => e
+      notify_save_failed_observers
+      raise e
     end
 
-    def _update_attributes(attrs,  safe)
-      _collection.update({'_id' => self._id}, MongoDoc::Query.set_modifier(attrs), :safe => safe)
+    def before_save_callback(root)
+      self._id = Mongo::ObjectID.new if new_record?
     end
 
-    class << self
-      def _create(instance, safe)
-        instance._id = collection.insert(instance, :safe => safe)
-      end
+    def save_failed_callback(root)
+      self._id = nil
+    end
+
+    def save_success_callback(root)
+      root.unregister_save_observer(self)
+    end
+
+    def save_observers
+      @save_observers ||= []
+    end
+
+    def register_save_observer(child)
+      save_observers << child
     end
+
+    def unregister_save_observer(child)
+      save_observers.delete(child)
+    end
+
+    def notify_before_save_observers
+      save_observers.each {|obs| obs.before_save_callback(self) }
+    end
+
+    def notify_save_success_observers
+      save_observers.each {|obs| obs.save_success_callback(self) }
+    end
+
+    def notify_save_failed_observers
+      save_observers.each {|obs| obs.save_failed_callback(self) }
+    end
+
   end
 end

data/lib/mongodoc/finders.rb

@@ -0,0 +1,29 @@
+module MongoDoc
+  module Finders
+    [:all, :count, :first, :last].each do |name|
+      module_eval <<-RUBY
+        def #{name}
+          Criteria.new(self).#{name}
+        end
+      RUBY
+    end
+
+    def criteria
+      Criteria.new(self)
+    end
+
+    def find(*args)
+      query = args.extract_options!
+      which = args.first
+      Criteria.translate(self, query).send(which)
+    end
+
+    def find_one(conditions_or_id)
+      if Hash === conditions_or_id
+        Criteria.translate(self, conditions_or_id).one
+      else
+        Criteria.translate(self, conditions_or_id)
+      end
+    end
+  end
+end