mongoid-locomotive 2.0.0.beta9

data/lib/mongoid/finders.rb

@@ -0,0 +1,145 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Finders #:nodoc:
+
+    # Delegate to the criteria methods that are natural for creating a new
+    # criteria.
+    [ :all_in, :any_in, :asc, :ascending, :avg, :desc, :descending,
+      :excludes, :limit, :max, :min, :not_in, :only, :order_by,
+      :skip, :sum, :where ].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)
+      Criteria.translate(self, *args).count
+    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)
+      Criteria.translate(self, *args).limit(1).count == 1
+    end
+
+    # Helper to initialize a new +Criteria+ object for this class.
+    #
+    # Example:
+    #
+    # <tt>Person.criteria</tt>
+    def criteria
+      Criteria.new(self)
+    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.
+    #
+    # <tt>Person.find(:first, :conditions => { :attribute => "value" })</tt>
+    #
+    # <tt>Person.find(:all, :conditions => { :attribute => "value" })</tt>
+    #
+    # <tt>Person.find(Mongo::ObjectID.new.to_s)</tt>
+    def find(*args)
+      raise Errors::InvalidOptions.new("Calling Document#find with nil is invalid") if args[0].nil?
+      type = args.delete_at(0) if args[0].is_a?(Symbol)
+      criteria = Criteria.translate(self, *args)
+      case type
+      when :first then return criteria.one
+      when :last then return criteria.last
+      else
+        return criteria
+      end
+    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 = {})
+      find_or(:create, attrs)
+    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 = {})
+      find_or(:new, attrs)
+    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
+
+    # Find all documents in paginated fashion given the supplied arguments.
+    # If no parameters are passed just default to offset 0 and limit 20.
+    #
+    # Options:
+    #
+    # params: A +Hash+ of params to pass to the Criteria API.
+    #
+    # Example:
+    #
+    # <tt>Person.paginate(:conditions => { :field => "Test" }, :page => 1,
+    # :per_page => 20)</tt>
+    #
+    # Returns paginated array of docs.
+    def paginate(params = {})
+      Criteria.translate(self, params).paginate
+    end
+
+    protected
+    # Find the first object or create/initialize it.
+    def find_or(method, attrs = {})
+      first(:conditions => attrs) || send(method, attrs)
+    end
+  end
+end

data/lib/mongoid/hierarchy.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Hierarchy #:nodoc
+    extend ActiveSupport::Concern
+    included do
+      cattr_accessor :hereditary
+      self.hereditary = false
+
+      attr_accessor :_parent
+    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:
+      #
+      # <tt>person._children</tt>
+      #
+      # Returns:
+      #
+      # All child +Documents+ to this +Document+ in the entire hierarchy.
+      def _children
+        associations.inject([]) do |children, (name, metadata)|
+          if metadata.embedded? && name != "versions"
+            child = send(name)
+            child.to_a.each do |doc|
+              children.push(doc).concat(doc._children)
+            end unless child.blank?
+          end
+          children
+        end
+      end
+
+      # Is inheritance in play here?
+      #
+      # Returns:
+      #
+      # <tt>true</tt> if inheritance used, <tt>false</tt> if not.
+      def hereditary?
+        !!self.hereditary
+      end
+
+      # Sets up a child/parent association. This is used for newly created
+      # objects so they can be properly added to the graph.
+      #
+      # Options:
+      #
+      # abject: The parent object that needs to be set for the child.
+      # association_name: The name of the association for the child.
+      #
+      # Example:
+      #
+      # <tt>address.parentize(person, :addresses)</tt>
+      def parentize(object, association_name)
+        self._parent = object
+        self.association_name = association_name.to_s
+      end
+
+      # Return the root +Document+ in the object graph. If the current +Document+
+      # is the root object in the graph it will return self.
+      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,47 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  class Identity #:nodoc:
+    # Create the identity for the +Document+.
+    #
+    # The id will be set in either in the form of a Mongo
+    # +ObjectID+ or a composite key set up by defining a key on the document.
+    #
+    # The _type will be set to the document's class name.
+    def create
+      identify!; type!
+    end
+
+    # Create the new identity generator - this will be expanded in the future
+    # to support pk generators.
+    #
+    # Options:
+    #
+    # document: The document to generate an id for.
+    def initialize(document)
+      @document = document
+    end
+
+    protected
+    # Return the proper id for the document.
+    def generate_id
+      id = BSON::ObjectID.new
+      Mongoid.use_object_ids ? id : id.to_s
+    end
+
+    # Set the id for the document.
+    def identify!
+      @document.id = compose.join(" ").identify if @document.primary_key
+      @document.id = generate_id if @document.id.blank?
+    end
+
+    # Set the _type field on the @document.ment.
+    def type!
+      @document._type = @document.class.name if @document.hereditary?
+    end
+
+    # Generates the composite key for a @document.ment.
+    def compose
+      @document.primary_key.collect { |key| @document.attributes[key] }.reject { |val| val.nil? }
+    end
+  end
+end

data/lib/mongoid/indexes.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Indexes #:nodoc
+    extend ActiveSupport::Concern
+    included do
+      cattr_accessor :indexed
+      self.indexed = false
+    end
+
+    module ClassMethods #:nodoc
+      # Add the default indexes to the root document if they do not already
+      # exist. Currently this is only _type.
+      def add_indexes
+        if hereditary && !indexed
+          self._collection.create_index(:_type, :unique => false, :background => true)
+          self.indexed = true
+        end
+      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 })
+        collection.create_index(name, options)
+      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];
+  }"

data/lib/mongoid/logger.rb

@@ -0,0 +1,19 @@
+module Mongoid
+  class Logger
+
+    delegate :info, :debug, :error, :fatal, :unknown, :to => :logger, :allow_nil => true
+
+    def warn(message)
+      logger.warn(message) if logger && logger.respond_to?(:warn)
+    end
+
+    def logger
+      Mongoid.logger
+    end
+
+    def inspect
+      "#<Mongoid::Logger:0x#{object_id.to_s(16)} @logger=#{logger.inspect}>"
+    end
+
+  end
+end

data/lib/mongoid/matchers.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+require "mongoid/matchers/default"
+require "mongoid/matchers/all"
+require "mongoid/matchers/exists"
+require "mongoid/matchers/gt"
+require "mongoid/matchers/gte"
+require "mongoid/matchers/in"
+require "mongoid/matchers/lt"
+require "mongoid/matchers/lte"
+require "mongoid/matchers/ne"
+require "mongoid/matchers/nin"
+require "mongoid/matchers/size"
+
+module Mongoid #:nodoc:
+  module Matchers
+    # Determines if this document has the attributes to match the supplied
+    # MongoDB selector. Used for matching on embedded associations.
+    def matches?(selector)
+      selector.each_pair do |key, value|
+        return false unless matcher(key, value).matches?(value)
+      end; true
+    end
+
+    protected
+    # Get the matcher for the supplied key and value. Will determine the class
+    # name from the key.
+    def matcher(key, value)
+      if value.is_a?(Hash)
+        name = "Mongoid::Matchers::#{value.keys.first.gsub("$", "").camelize}"
+        return name.constantize.new(attributes[key])
+      end
+      Default.new(attributes[key])
+    end
+  end
+end

data/lib/mongoid/matchers/all.rb

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

data/lib/mongoid/matchers/default.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Matchers #:nodoc:
+    class Default
+      # Creating a new matcher only requires the value.
+      def initialize(attribute)
+        @attribute = attribute
+      end
+      # Return true if the attribute and value are equal.
+      def matches?(value)
+        @attribute == value
+      end
+
+      protected
+      # Return the first value in the hash.
+      def first(value)
+        value.values.first
+      end
+
+      # If object exists then compare, else return false
+      def determine(value, operator)
+        @attribute ? @attribute.send(operator, first(value)) : false
+      end
+    end
+  end
+end