mongoid-braxton 2.0.2

data/lib/mongoid/finders.rb

@@ -0,0 +1,127 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  # This module defines the finder methods that hang off the document at the
+  # class level.
+  module Finders
+
+    # Delegate to the criteria methods that are natural for creating a new
+    # criteria.
+    [ :all_in, :any_in, :any_of, :asc, :ascending, :avg, :desc, :descending,
+      :excludes, :limit, :max, :min, :not_in, :only, :order_by,
+      :skip, :sum, :without, :where, :update, :update_all, :near ].each do |name|
+      define_method(name) do |*args|
+        criteria.send(name, *args)
+      end
+    end
+
+    # Find +Documents+ given the conditions.
+    #
+    # Options:
+    #
+    # args: A +Hash+ with a conditions key and other options
+    #
+    # <tt>Person.all(:conditions => { :attribute => "value" })</tt>
+    def all(*args)
+      find(:all, *args)
+    end
+
+    # Returns a count of matching records in the database based on the
+    # provided arguments.
+    #
+    # <tt>Person.count(:conditions => { :attribute => "value" })</tt>
+    def count(*args)
+      find(:all, *args).count
+    end
+
+    # Returns true if count is zero
+    def empty?
+      count == 0
+    end
+
+    # Returns true if there are on document in database based on the
+    # provided arguments.
+    #
+    # <tt>Person.exists?(:conditions => { :attribute => "value" })</tt>
+    def exists?(*args)
+       find(:all, *args).limit(1).count == 1
+    end
+
+    # Find a +Document+ in several different ways.
+    #
+    # If a +String+ is provided, it will be assumed that it is a
+    # representation of a Mongo::ObjectID and will attempt to find a single
+    # +Document+ based on that id. If a +Symbol+ and +Hash+ is provided then
+    # it will attempt to find either a single +Document+ or multiples based
+    # on the conditions provided and the first parameter.
+    #
+    # Example:
+    #
+    # <tt>Person.find(:first, :conditions => { :attribute => "value" })</tt>
+    # <tt>Person.find(:all, :conditions => { :attribute => "value" })</tt>
+    # <tt>Person.find(BSON::ObjectId)</tt>
+    #
+    # Options:
+    #
+    # args: An assortment of finder options.
+    #
+    # Returns:
+    #
+    # A document or criteria.
+    def find(*args)
+      criteria.find(*args)
+    end
+
+    # Find the first +Document+ given the conditions, or creates a new document
+    # with the conditions that were supplied
+    #
+    # Options:
+    #
+    # args: A +Hash+ of attributes
+    #
+    # <tt>Person.find_or_create_by(:attribute => "value")</tt>
+    def find_or_create_by(attrs = {}, &block)
+      find_or(:create, attrs, &block)
+    end
+
+    # Find the first +Document+ given the conditions, or instantiates a new document
+    # with the conditions that were supplied
+    #
+    # Options:
+    #
+    # args: A +Hash+ of attributes
+    #
+    # <tt>Person.find_or_initialize_by(:attribute => "value")</tt>
+    def find_or_initialize_by(attrs = {}, &block)
+      find_or(:new, attrs, &block)
+    end
+
+    # Find the first +Document+ given the conditions.
+    #
+    # Options:
+    #
+    # args: A +Hash+ with a conditions key and other options
+    #
+    # <tt>Person.first(:conditions => { :attribute => "value" })</tt>
+    def first(*args)
+      find(:first, *args)
+    end
+
+    # Find the last +Document+ given the conditions.
+    #
+    # Options:
+    #
+    # args: A +Hash+ with a conditions key and other options
+    #
+    # <tt>Person.last(:conditions => { :attribute => "value" })</tt>
+    def last(*args)
+      find(:last, *args)
+    end
+
+    protected
+    # Find the first object or create/initialize it.
+    def find_or(method, attrs = {}, &block)
+      first(:conditions => attrs) || send(method, attrs, &block)
+    end
+  end
+end

data/lib/mongoid/hierarchy.rb

@@ -0,0 +1,85 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Hierarchy #:nodoc
+    extend ActiveSupport::Concern
+    included do
+      attr_accessor :_parent
+    end
+
+    module ClassMethods #:nodoc:
+
+      # Determines if the document is a subclass of another document.
+      #
+      # @example Check if the document is a subclass.
+      #   Square.hereditary?
+      #
+      # @return [ true, false ] True if hereditary, false if not.
+      def hereditary?
+        Mongoid::Document > superclass
+      end
+    end
+
+    module InstanceMethods #:nodoc:
+
+      # Get all child +Documents+ to this +Document+, going n levels deep if
+      # necessary. This is used when calling update persistence operations from
+      # the root document, where changes in the entire tree need to be
+      # determined. Note that persistence from the embedded documents will
+      # always be preferred, since they are optimized calls... This operation
+      # can get expensive in domains with large hierarchies.
+      #
+      # @example Get all the document's children.
+      #   person._children
+      #
+      # @return [ Array<Document> ] All child documents in the hierarchy.
+      def _children
+        relations.inject([]) do |children, (name, metadata)|
+          children.tap do |kids|
+            if metadata.embedded? && name != "versions"
+              child = send(name)
+              child.to_a.each do |doc|
+                kids.push(doc).concat(doc._children)
+              end unless child.blank?
+            end
+          end
+        end
+      end
+
+      # Determines if the document is a subclass of another document.
+      #
+      # @example Check if the document is a subclass
+      #   Square.new.hereditary?
+      #
+      # @return [ true, false ] True if hereditary, false if not.
+      def hereditary?
+        self.class.hereditary?
+      end
+
+      # Sets up a child/parent association. This is used for newly created
+      # objects so they can be properly added to the graph.
+      #
+      # @example Set the parent document.
+      #   document.parentize(parent)
+      #
+      # @param [ Document ] document The parent document.
+      #
+      # @return [ Document ] The parent document.
+      def parentize(document)
+        self._parent = document
+      end
+
+      # Return the root document in the object graph. If the current document
+      # is the root object in the graph it will return self.
+      #
+      # @example Get the root document in the hierarchy.
+      #   document._root
+      #
+      # @return [ Document ] The root document in the hierarchy.
+      def _root
+        object = self
+        while (object._parent) do object = object._parent; end
+        object || self
+      end
+    end
+  end
+end

data/lib/mongoid/identity.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  class Identity #:nodoc:
+
+    attr_reader :document
+
+    # Create the identity for the document. The id will be set in either in
+    # the form of a Mongo object id or a composite key set up by defining
+    # a key on the document. The _type will be set to the document's class
+    # name.
+    #
+    # @example Create the id and set the type.
+    #   identity.create
+    def create
+      identify.tap { type }
+    end
+
+    # Create the new identity generator - this will be expanded in the future
+    # to support pk generators.
+    #
+    # @example
+    #   Identity.new(document)
+    #
+    # @param [ Document ] document The document to generate an id for.
+    #
+    # @return [ Identity ] The new identity object.
+    def initialize(document)
+      @document = document
+    end
+
+    private
+
+    # Return the proper id for the document. Will be an object id or its string
+    # representation depending on the configuration.
+    #
+    # @example Generate the id.
+    #   identity.generate_id
+    #
+    # @return [ Object ] The bson object id or its string equivalent.
+    def generate_id
+      id = BSON::ObjectId.new
+      document.using_object_ids? ? id : id.to_s
+    end
+
+    # Sets the id on the document. Will either set a newly generated id or
+    # build the composite key.
+    #
+    # @example Set the id.
+    #   identity.identify
+    def identify
+      if !document.embedded? || Mongoid.embedded_object_id
+        document.id = compose.join(" ").identify if document.primary_key
+        document.id = generate_id if document.id.blank?
+      end
+      document.id
+    end
+
+    # Set the _type field on the document if the document is hereditary or in a
+    # polymorphic relation.
+    #
+    # @example Set the type.
+    #   identity.type
+    def type
+      document._type = document.class.name if typed?
+    end
+
+    # Generates the array of keys to build the id.
+    #
+    # @example Build the array for the keys.
+    #   identity.compose.
+    #
+    # @return [ Array<Object> ] The array of keys.
+    def compose
+      document.primary_key.collect do |key|
+        document.attributes[key.to_s]
+      end.reject { |val| val.nil? }
+    end
+
+    # Determines if the document stores the type information. This is if it is
+    # in a hierarchy, has subclasses, or is in a polymorphic relation.
+    #
+    # @example Check if the document is typed.
+    #   identity.typed?
+    #
+    # @return [ true, false ] True if typed, false if not.
+    def typed?
+      document.hereditary? ||
+        document.class.descendants.any? ||
+        document.polymorphic?
+    end
+  end
+end

data/lib/mongoid/indexes.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Indexes #:nodoc
+    extend ActiveSupport::Concern
+    included do
+      cattr_accessor :index_options
+      self.index_options = {}
+    end
+
+    module ClassMethods #:nodoc
+
+      # Send the actual index creation comments to the MongoDB driver
+      def create_indexes
+        return unless index_options
+        current_collection = self._collection || set_collection
+        index_options.each do |name, options|
+          current_collection.create_index(name, options)
+        end
+      end
+
+      # Add the default indexes to the root document if they do not already
+      # exist. Currently this is only _type.
+      def add_indexes
+        if hereditary? && !index_options[:_type]
+          self.index_options[:_type] = {:unique => false, :background => true}
+        end
+        create_indexes if Mongoid.autocreate_indexes
+      end
+
+      # Adds an index on the field specified. Options can be :unique => true or
+      # :unique => false. It will default to the latter.
+      def index(name, options = { :unique => false })
+        self.index_options[name] = options
+        create_indexes if Mongoid.autocreate_indexes
+      end
+    end
+  end
+end

data/lib/mongoid/inspection.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+
+  # Contains the bahviour around inspecting documents via
+  # <tt>Object#inspect</tt>.
+  module Inspection
+
+    # Returns the class name plus its attributes. If using dynamic fields will
+    # include those as well.
+    #
+    # @example Inspect the document.
+    #   person.inspect
+    #
+    # @return [ String ] A nice pretty string to look at.
+    def inspect
+      inspection = []
+      inspection.concat(inspect_fields).concat(inspect_dynamic_fields)
+      "#<#{self.class.name} _id: #{id}, #{inspection * ', '}>"
+    end
+
+    private
+
+    # Get an array of inspected fields for the document.
+    #
+    # @example Inspect the defined fields.
+    #   document.inspect_fields
+    #
+    # @return [ String ] An array of pretty printed field values.
+    def inspect_fields
+      fields.map do |name, field|
+        unless name == "_id"
+          "#{name}: #{@attributes[name].inspect}"
+        end
+      end.compact
+    end
+
+    # Get an array of inspected dynamic fields for the document.
+    #
+    # @example Inspect the dynamic fields.
+    #   document.inspect_dynamic_fields
+    #
+    # @return [ String ] An array of pretty printed dynamic field values.
+    def inspect_dynamic_fields
+      if Mongoid.allow_dynamic_fields
+        keys = @attributes.keys - fields.keys - relations.keys - ["_id", "_type"]
+        return keys.map do |name|
+          "#{name}: #{@attributes[name].inspect}"
+        end
+      else
+        []
+      end
+    end
+  end
+end

data/lib/mongoid/javascript.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  class Javascript
+    # Constant for the file that defines all the js functions.
+    FUNCTIONS = File.join(File.dirname(__FILE__), "javascript", "functions.yml")
+
+    # Load the javascript functions and define a class method for each one,
+    # that memoizes the value.
+    #
+    # Example:
+    #
+    # <tt>Mongoid::Javascript.aggregate</tt>
+    YAML.load(File.read(FUNCTIONS)).each_pair do |key, function|
+      (class << self; self; end).class_eval <<-EOT
+        def #{key}
+          @#{key} ||= "#{function}"
+        end
+      EOT
+    end
+  end
+end

data/lib/mongoid/javascript/functions.yml

@@ -0,0 +1,37 @@
+aggregate:
+  "function(obj, prev) {
+     prev.count++;
+   }"
+
+group:
+  "function(obj, prev) {
+     prev.group.push(obj);
+   }"
+
+max:
+  "function(obj, prev) {
+     if (prev.max == 'start') {
+       prev.max = obj.[field];
+     }
+     if (prev.max < obj.[field]) {
+       prev.max = obj.[field];
+     }
+   }"
+
+min:
+  "function(obj, prev) {
+     if (prev.min == 'start') {
+       prev.min = obj.[field];
+     }
+     if (prev.min > obj.[field]) {
+       prev.min = obj.[field];
+     }
+   }"
+
+sum:
+  "function(obj, prev) {
+     if (prev.sum == 'start') {
+       prev.sum = 0;
+     }
+     prev.sum += obj.[field];
+  }"