humanoid 1.2.7

data/lib/humanoid/commands/create.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Commands
+    class Create
+      # Performs a create of the supplied Document, with the necessary
+      # callbacks. It then delegates to the Save command.
+      #
+      # Options:
+      #
+      # doc: A new +Document+ that is going to be persisted.
+      #
+      # Returns: +Document+.
+      def self.execute(doc, validate = true)
+        doc.run_callbacks :before_create
+        Save.execute(doc, validate)
+        doc.run_callbacks :after_create
+        return doc
+      end
+    end
+  end
+end

data/lib/humanoid/commands/delete.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Commands
+    class Delete
+      extend Deletion
+      # Performs a delete of the supplied +Document+ without any callbacks.
+      #
+      # Options:
+      #
+      # doc: A new +Document+ that is going to be deleted.
+      def self.execute(doc)
+        delete(doc)
+      end
+    end
+  end
+end

data/lib/humanoid/commands/delete_all.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Commands
+    class DeleteAll
+      # Performs a delete of the all the +Documents+ that match the criteria
+      # supplied.
+      #
+      # Options:
+      #
+      # params: A set of conditions to find the +Documents+ by.
+      # klass: The class of the +Document+ to execute the find on.
+      #
+      # Example:
+      #
+      # <tt>DeleteAll.execute(Person, :conditions => { :field => "value" })</tt>
+      def self.execute(klass, params = {})
+        safe = Humanoid.persist_in_safe_mode
+        collection = klass.collection
+        collection.remove((params[:conditions] || {}).merge(:_type => klass.name), :safe => safe)
+      end
+    end
+  end
+end

data/lib/humanoid/commands/deletion.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+module Humanoid #:nodoc
+  module Commands #:nodoc
+    module Deletion #:nodoc
+      # If the +Document+ has a parent, delete it from the parent's attributes,
+      # otherwise delete it from it's collection.
+      def delete(doc)
+        parent = doc._parent
+        if parent
+          parent.remove(doc)
+          parent.save
+        else
+          doc.collection.remove(:_id => doc.id)
+        end
+      end
+    end
+  end
+end

data/lib/humanoid/commands/destroy.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Commands
+    class Destroy
+      extend Deletion
+      # Performs a destroy of the supplied +Document+, with the necessary
+      # callbacks. It then deletes the record from the collection.
+      #
+      # Options:
+      #
+      # doc: A new +Document+ that is going to be destroyed.
+      def self.execute(doc)
+        doc.run_callbacks :before_destroy
+        delete(doc)
+        doc.run_callbacks :after_destroy
+      end
+    end
+  end
+end

data/lib/humanoid/commands/destroy_all.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Commands
+    class DestroyAll
+      # Performs a destroy of the all the +Documents+ that match the criteria
+      # supplied. Will execute all the destroy callbacks for each +Document+.
+      #
+      # Options:
+      #
+      # params: A set of conditions to find the +Documents+ by.
+      # klass: The class of the +Document+ to execute the find on.
+      #
+      # Example:
+      #
+      # <tt>DestroyAll.execute(Person, :conditions => { :field => "value" })</tt>
+      def self.execute(klass, params)
+        conditions = params[:conditions] || {}
+        params[:conditions] = conditions.merge(:_type => klass.name)
+        klass.find(:all, params).each { |doc| Destroy.execute(doc) }; true
+      end
+    end
+  end
+end

data/lib/humanoid/commands/save.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Commands
+    class Save
+      # Performs a save of the supplied +Document+, handling all associated
+      # callbacks and validation.
+      #
+      # Options:
+      #
+      # doc: A +Document+ that is going to be persisted.
+      #
+      # Returns: +true+ if validation passes, +false+ if not.
+      def self.execute(doc, validate = true)
+        return false if validate && !doc.valid?
+        doc.run_callbacks :before_save
+        parent = doc._parent
+        if parent ? Save.execute(parent, validate) : doc.collection.save(doc.raw_attributes, :safe => Humanoid.persist_in_safe_mode)
+          doc.new_record = false
+          doc.run_callbacks :after_save
+          return true
+        else
+          return false
+        end
+      end
+    end
+  end
+end

data/lib/humanoid/components.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+module Humanoid #:nodoc
+  module Components #:nodoc
+    def self.included(base)
+      base.class_eval do
+        # All modules that a +Document+ is composed of are defined in this
+        # module, to keep the document class from getting too cluttered.
+        include Associations
+        include Attributes
+        include Callbacks
+        include Commands
+        include Enslavement
+        include Fields
+        include Indexes
+        include Matchers
+        include Memoization
+        include Observable
+        include Validatable
+        extend Finders
+        extend NamedScope
+      end
+    end
+  end
+end

data/lib/humanoid/config.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+module Humanoid #:nodoc
+  class Config #:nodoc
+    include Singleton
+
+    attr_accessor \
+      :allow_dynamic_fields,
+      :reconnect_time,
+      :parameterize_keys,
+      :persist_in_safe_mode,
+      :raise_not_found_error,
+      :use_object_ids
+
+    # Defaults the configuration options to true.
+    def initialize
+      @allow_dynamic_fields = true
+      @parameterize_keys = true
+      @persist_in_safe_mode = true
+      @raise_not_found_error = true
+      @reconnect_time = 3
+      @use_object_ids = false
+    end
+
+    # Sets the Mongo::DB master database to be used. If the object trying to me
+    # set is not a valid +Mongo::DB+, then an error will be raise.
+    #
+    # Example:
+    #
+    # <tt>Config.master = Mongo::Connection.db("test")</tt>
+    #
+    # Returns:
+    #
+    # The Master DB instance.
+    def master=(db)
+      raise Errors::InvalidDatabase.new(db) unless db.kind_of?(Mongo::DB)
+      @master = db
+    end
+
+    # Returns the master database, or if none has been set it will raise an
+    # error.
+    #
+    # Example:
+    #
+    # <tt>Config.master</tt>
+    #
+    # Returns:
+    #
+    # The master +Mongo::DB+
+    def master
+      @master || (raise Errors::InvalidDatabase.new(nil))
+    end
+
+    alias :database :master
+    alias :database= :master=
+
+    # Sets the Mongo::DB slave databases to be used. If the objects trying to me
+    # set are not valid +Mongo::DBs+, then an error will be raise.
+    #
+    # Example:
+    #
+    # <tt>Config.slaves = [ Mongo::Connection.db("test") ]</tt>
+    #
+    # Returns:
+    #
+    # The slaves DB instances.
+    def slaves=(dbs)
+      dbs.each { |db| raise Errors::InvalidDatabase.new(db) unless db.kind_of?(Mongo::DB) }
+      @slaves = dbs
+    end
+
+    # Returns the slave databases, or if none has been set nil
+    #
+    # Example:
+    #
+    # <tt>Config.slaves</tt>
+    #
+    # Returns:
+    #
+    # The slave +Mongo::DBs+
+    def slaves
+      @slaves
+    end
+  end
+end

data/lib/humanoid/contexts.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+require "humanoid/contexts/ids"
+require "humanoid/contexts/paging"
+require "humanoid/contexts/enumerable"
+require "humanoid/contexts/mongo"
+
+module Humanoid
+  module Contexts
+    # Determines the context to be used for this criteria. If the class is an
+    # embedded document, then the context will be the array in the has_many
+    # association it is in. If the class is a root, then the database itself
+    # will be the context.
+    #
+    # Example:
+    #
+    # <tt>Contexts.context_for(criteria)</tt>
+    def self.context_for(criteria)
+      if criteria.klass.embedded
+        return Contexts::Enumerable.new(criteria)
+      end
+      Contexts::Mongo.new(criteria)
+    end
+
+  end
+end

data/lib/humanoid/contexts/enumerable.rb

@@ -0,0 +1,117 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Contexts #:nodoc:
+    class Enumerable
+      include Ids, Paging
+      attr_reader :criteria
+
+      delegate :first, :last, :to => :execute
+      delegate :documents, :options, :selector, :to => :criteria
+
+      # Return aggregation counts of the grouped documents. This will count by
+      # the first field provided in the fields array.
+      #
+      # Returns:
+      #
+      # A +Hash+ with field values as keys, count as values
+      def aggregate
+        counts = {}
+        group.each_pair { |key, value| counts[key] = value.size }
+        counts
+      end
+
+      # Gets the number of documents in the array. Delegates to size.
+      def count
+        @count ||= documents.size
+      end
+
+      # Groups the documents by the first field supplied in the field options.
+      #
+      # Returns:
+      #
+      # A +Hash+ with field values as keys, arrays of documents as values.
+      def group
+        field = options[:fields].first
+        documents.group_by { |doc| doc.send(field) }
+      end
+
+      # Enumerable implementation of execute. Returns matching documents for
+      # the selector, and adds options if supplied.
+      #
+      # Returns:
+      #
+      # An +Array+ of documents that matched the selector.
+      def execute(paginating = false)
+        limit(documents.select { |document| document.matches?(selector) })
+      end
+
+      # Create the new enumerable context. This will need the selector and
+      # options from a +Criteria+ and a documents array that is the underlying
+      # array of embedded documents from a has many association.
+      #
+      # Example:
+      #
+      # <tt>Humanoid::Contexts::Enumerable.new(criteria)</tt>
+      def initialize(criteria)
+        @criteria = criteria
+      end
+
+      # Get the largest value for the field in all the documents.
+      #
+      # Returns:
+      #
+      # The numerical largest value.
+      def max(field)
+        determine(field, :>=)
+      end
+
+      # Get the smallest value for the field in all the documents.
+      #
+      # Returns:
+      #
+      # The numerical smallest value.
+      def min(field)
+        determine(field, :<=)
+      end
+
+      # Get one document.
+      #
+      # Returns:
+      #
+      # The first document in the +Array+
+      alias :one :first
+
+      # Get the sum of the field values for all the documents.
+      #
+      # Returns:
+      #
+      # The numerical sum of all the document field values.
+      def sum(field)
+        sum = documents.inject(nil) do |memo, doc|
+          value = doc.send(field)
+          memo ? memo += value : value
+        end
+      end
+
+      protected
+      # If the field exists, perform the comparison and set if true.
+      def determine(field, operator)
+        matching = documents.inject(nil) do |memo, doc|
+          value = doc.send(field)
+          (memo && memo.send(operator, value)) ? memo : value
+        end
+      end
+
+      # Limits the result set if skip and limit options.
+      def limit(documents)
+        skip, limit = options[:skip], options[:limit]
+        if skip && limit
+          return documents.slice(skip, limit)
+        elsif limit
+          return documents.first(limit)
+        end
+        documents
+      end
+    end
+  end
+end

data/lib/humanoid/contexts/ids.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Contexts #:nodoc:
+    module Ids
+      # Return documents based on an id search. Will handle if a single id has
+      # been passed or mulitple ids.
+      #
+      # Example:
+      #
+      #   context.id_criteria([1, 2, 3])
+      #
+      # Returns:
+      #
+      # The single or multiple documents.
+      def id_criteria(params)
+        criteria.id(params)
+        result = params.is_a?(Array) ? criteria.entries : one
+        if Humanoid.raise_not_found_error
+          raise Errors::DocumentNotFound.new(klass, params) if result.blank?
+        end
+        return result
+      end
+    end
+  end
+end

data/lib/humanoid/contexts/mongo.rb

@@ -0,0 +1,224 @@
+# encoding: utf-8
+module Humanoid #:nodoc:
+  module Contexts #:nodoc:
+    class Mongo
+      include Ids, Paging
+      attr_reader :criteria
+
+      delegate :klass, :options, :selector, :to => :criteria
+
+      AGGREGATE_REDUCE = "function(obj, prev) { prev.count++; }"
+      # Aggregate the context. 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 counts.
+      #
+      # Example:
+      #
+      # <tt>context.aggregate</tt>
+      #
+      # Returns:
+      #
+      # A +Hash+ with field values as keys, counts as values
+      def aggregate
+        klass.collection.group(options[:fields], selector, { :count => 0 }, AGGREGATE_REDUCE, true)
+      end
+
+      # Get the count of matching documents in the database for the context.
+      #
+      # Example:
+      #
+      # <tt>context.count</tt>
+      #
+      # Returns:
+      #
+      # An +Integer+ count of documents.
+      def count
+        @count ||= klass.collection.find(selector, process_options).count
+      end
+
+      # Execute the context. This will take the selector and options
+      # and pass them on to the Ruby driver's +find()+ method on the collection. The
+      # collection itself will be retrieved from the class provided, and once the
+      # query has returned new documents of the type of class provided will be instantiated.
+      #
+      # Example:
+      #
+      # <tt>mongo.execute</tt>
+      #
+      # Returns:
+      #
+      # An enumerable +Cursor+.
+      def execute(paginating = false)
+        cursor = klass.collection.find(selector, process_options)
+        if cursor
+          @count = cursor.count if paginating
+          cursor
+        else
+          []
+        end
+      end
+
+      GROUP_REDUCE = "function(obj, prev) { prev.group.push(obj); }"
+      # Groups the context. 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>context.group</tt>
+      #
+      # Returns:
+      #
+      # A +Hash+ with field values as keys, arrays of documents as values.
+      def group
+        klass.collection.group(
+          options[:fields],
+          selector,
+          { :group => [] },
+          GROUP_REDUCE,
+          true
+        ).collect do |docs|
+          docs["group"] = docs["group"].collect do |attrs|
+            Humanoid::Factory.build(klass, attrs)
+          end
+          docs
+        end
+      end
+
+      # Create the new mongo context. This will execute the queries given the
+      # selector and options against the database.
+      #
+      # Example:
+      #
+      # <tt>Humanoid::Contexts::Mongo.new(criteria)</tt>
+      def initialize(criteria)
+        @criteria = criteria
+        if criteria.klass.hereditary
+          criteria.in(:_type => criteria.klass._types)
+        end
+      end
+
+      # Return the last result for the +Context+. 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>context.last</tt>
+      #
+      # Returns:
+      #
+      # The last document in the collection.
+      def last
+        opts = process_options
+        sorting = opts[:sort]
+        sorting = [[:_id, :asc]] unless sorting
+        opts[:sort] = sorting.collect { |option| [ option[0], option[1].invert ] }
+        attributes = klass.collection.find_one(selector, opts)
+        attributes ? Humanoid::Factory.build(klass, attributes) : nil
+      end
+
+      MAX_REDUCE = "function(obj, prev) { if (prev.max == 'start') { prev.max = obj.[field]; } " +
+        "if (prev.max < obj.[field]) { prev.max = obj.[field]; } }"
+      # Return the max value for a field.
+      #
+      # 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 sums.
+      #
+      # Example:
+      #
+      # <tt>context.max(:age)</tt>
+      #
+      # Returns:
+      #
+      # A numeric max value.
+      def max(field)
+        grouped(:max, field.to_s, MAX_REDUCE)
+      end
+
+      MIN_REDUCE = "function(obj, prev) { if (prev.min == 'start') { prev.min = obj.[field]; } " +
+        "if (prev.min > obj.[field]) { prev.min = obj.[field]; } }"
+      # Return the min value for a field.
+      #
+      # 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 sums.
+      #
+      # Example:
+      #
+      # <tt>context.min(:age)</tt>
+      #
+      # Returns:
+      #
+      # A numeric minimum value.
+      def min(field)
+        grouped(:min, field.to_s, MIN_REDUCE)
+      end
+
+      # Return the first result for the +Context+.
+      #
+      # Example:
+      #
+      # <tt>context.one</tt>
+      #
+      # Return:
+      #
+      # The first document in the collection.
+      def one
+        attributes = klass.collection.find_one(selector, process_options)
+        attributes ? Humanoid::Factory.build(klass, attributes) : nil
+      end
+
+      alias :first :one
+
+      SUM_REDUCE = "function(obj, prev) { if (prev.sum == 'start') { prev.sum = 0; } prev.sum += obj.[field]; }"
+      # Sum the context.
+      #
+      # 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 sums.
+      #
+      # Example:
+      #
+      # <tt>context.sum(:age)</tt>
+      #
+      # Returns:
+      #
+      # A numeric value that is the sum.
+      def sum(field)
+        grouped(:sum, field.to_s, SUM_REDUCE)
+      end
+
+      # Common functionality for grouping operations. Currently used by min, max
+      # and sum. Will gsub the field name in the supplied reduce function.
+      def grouped(start, field, reduce)
+        collection = klass.collection.group(
+          nil,
+          selector,
+          { start => "start" },
+          reduce.gsub("[field]", field),
+          true
+        )
+        collection.empty? ? nil : collection.first[start.to_s]
+      end
+
+      # Filters the field list. If no fields have been supplied, then it will be
+      # empty. If fields have been defined then _type will be included as well.
+      def process_options
+        fields = options[:fields]
+        if fields && fields.size > 0 && !fields.include?(:_type)
+          fields << :_type
+          options[:fields] = fields
+        end
+        options.dup
+      end
+
+    end
+  end
+end