mongo_doc_rails2 0.6.1

data/lib/mongo_doc/ext/object.rb

@@ -0,0 +1,19 @@
+class Object
+  define_method :singleton_class, instance_method(:metaclass) unless respond_to?(:singleton_class)
+
+  def to_bson(*args)
+    {MongoDoc::BSON::CLASS_KEY => self.class.name}.tap do |bson_hash|
+      instance_variables.each do |name|
+        bson_hash[name[1..-1]] = instance_variable_get(name).to_bson(args)
+      end
+    end
+  end
+
+  def self.bson_create(bson_hash, options = {})
+    allocate.tap do |obj|
+      bson_hash.each do |name, value|
+        obj.instance_variable_set("@#{name}", MongoDoc::BSON.decode(value, options))
+      end
+    end
+  end
+end

data/lib/mongo_doc/ext/object_id.rb

@@ -0,0 +1,7 @@
+module BSON
+  class ObjectID
+    def to_bson(*args)
+      self
+    end
+  end
+end

data/lib/mongo_doc/ext/regexp.rb

@@ -0,0 +1,5 @@
+class Regexp
+  def to_bson(*args)
+    self
+  end
+end

data/lib/mongo_doc/ext/string.rb

@@ -0,0 +1,5 @@
+class String
+  def to_bson(*args)
+    self
+  end
+end

data/lib/mongo_doc/ext/symbol.rb

@@ -0,0 +1,5 @@
+class Symbol
+  def to_bson(*args)
+    self
+  end
+end

data/lib/mongo_doc/ext/time.rb

@@ -0,0 +1,9 @@
+class Time
+  def to_bson(*args)
+    self
+  end
+
+  def self.cast_from_string(string)
+    Time.parse(string) unless string.blank?
+  end
+end

data/lib/mongo_doc/finders.rb

@@ -0,0 +1,38 @@
+require 'mongo_doc/criteria'
+
+module MongoDoc
+  module Finders
+    def self.extended(base)
+      base.extend(Criteria) unless base === Criteria
+    end
+
+    # Find a +Document+ based on id (+String+ or +BSON::ObjectID+)
+    #
+    # <tt>Person.find('1')</tt>
+    # <tt>Person.find(obj_id_1, obj_id_2)</tt>
+    def find(*args)
+      criteria.id(*args)
+    end
+    #
+    # Find all +Document+s in the collections
+    #
+    # <tt>Person.find_all</tt>
+    def find_all
+      criteria
+    end
+
+    # Find a +Document+ based on id (+String+ or +BSON::ObjectID+)
+    # or conditions
+    #
+    # <tt>Person.find_one('1')</tt>
+    # <tt>Person.find_one(:where => {:age.gt > 25})</tt>
+    def find_one(conditions_or_id)
+      if Hash === conditions_or_id
+        Mongoid::Criteria.translate(self, conditions_or_id).one
+      else
+        Mongoid::Criteria.translate(self, conditions_or_id)
+      end
+    end
+
+  end
+end

data/lib/mongo_doc/index.rb

@@ -0,0 +1,46 @@
+module MongoDoc
+  module Index
+
+    DIRECTION = { :asc => Mongo::ASCENDING,
+      :desc => Mongo::DESCENDING,
+      :geo2d => Mongo::GEO2D }
+    OPTIONS = [:min, :max, :background, :unique, :dropDups]
+
+    # Create an index on a collection.
+    #
+    # For compound indexes, pass pairs of fields and
+    # directions (+:asc+, +:desc+) as a hash.
+    #
+    # For a unique index, pass the option +:unique => true+.
+    # To create the index in the background, pass the options +:background => true+.
+    # If you want to remove duplicates from existing records when creating the
+    # unique index, pass the option +:dropDups => true+
+    #
+    # For GeoIndexing, specify the minimum and maximum longitude and latitude
+    # values with the +:min+ and +:max+ options.
+    #
+    # <tt>Person.index(:last_name)</tt>
+    # <tt>Person.index(:ssn, :unique => true)</tt>
+    # <tt>Person.index(:first_name => :asc, :last_name => :asc)</tt>
+    # <tt>Person.index(:first_name => :asc, :last_name => :asc, :unique => true)</tt>
+    def index(*args)
+      options_and_fields = args.extract_options!
+      if args.any?
+        collection.create_index(args.first, options_and_fields)
+      else
+        fields = options_and_fields.except(*OPTIONS)
+        options = options_and_fields.slice(*OPTIONS)
+        collection.create_index(to_mongo_direction(fields), options)
+      end
+    end
+
+    protected
+    def to_mongo_direction(fields_hash)
+      fields_hash.to_a.map {|field| [field.first, direction(field.last)]}
+    end
+
+    def direction(dir)
+      DIRECTION[dir] || Mongo::ASCENDING
+    end
+  end
+end

data/lib/mongo_doc/matchers.rb

@@ -0,0 +1,35 @@
+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 MongoDoc #: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(send(key))
+      end
+      Mongoid::Matchers::Default.new(send(key))
+    end
+  end
+end

data/lib/mongo_doc/root.rb

@@ -0,0 +1,26 @@
+module MongoDoc
+  module Root
+
+    attr_reader :_root
+
+    %w(_modifier_path _selector_path).each do |getter|
+      module_eval(<<-RUBY, __FILE__, __LINE__)
+        def #{getter}
+          @#{getter} ||= ''
+        end
+      RUBY
+    end
+
+    %w(_modifier_path _root _selector_path).each do |setter|
+      module_eval(<<-RUBY, __FILE__, __LINE__)
+        def #{setter}=(value)
+          @#{setter} = value
+          _associations.each do|a|
+            association = send(a)
+            association.#{setter} = value if association
+          end
+        end
+      RUBY
+    end
+  end
+end

data/lib/mongo_doc/scope.rb

@@ -0,0 +1,64 @@
+# Based on ActiveRecord::NamedScope
+module MongoDoc
+  module Scope
+    def scopes
+      read_inheritable_attribute(:scopes) || write_inheritable_attribute(:scopes, {})
+    end
+
+    def scope(name, *args, &block)
+      options = args.extract_options!
+      raise ArgumentError if args.size != 1
+      criteria = args.first
+      name = name.to_sym
+      scopes[name] = lambda do |parent_scope, *args|
+        CriteriaProxy.new(parent_scope, Mongoid::Criteria === criteria ? criteria : criteria.call(*args), options, &block)
+      end
+      (class << self; self; end).class_eval <<-EOT
+        def #{name}(*args)
+          scopes[:#{name}].call(self, *args)
+        end
+      EOT
+    end
+
+    class CriteriaProxy
+      attr_accessor :criteria, :klass, :parent_scope
+
+      delegate :scopes, :to => :parent_scope
+
+      def initialize(parent_scope, criteria, options, &block)
+        [options.delete(:extend)].flatten.each { |extension| extend extension } if options.include?(:extend)
+        extend Module.new(&block) if block_given?
+        if CriteriaProxy === parent_scope
+          chained = Mongoid::Criteria.new(klass)
+          chained.merge(parent_scope)
+          chained.merge(criteria)
+          self.criteria = chained
+          self.klass = criteria.klass
+        else
+          self.criteria = criteria
+          self.klass = parent_scope
+        end
+
+        self.parent_scope = parent_scope
+      end
+
+      def respond_to?(method, include_private = false)
+        return true if scopes.include?(method)
+        criteria.respond_to?(method, include_private)
+      end
+
+      private
+
+      def method_missing(method, *args, &block)
+        if scopes.include?(method)
+          scopes[method].call(self, *args)
+        else
+          chained = Mongoid::Criteria.new(klass)
+          chained.merge(criteria)
+          chained.send(method, *args, &block)
+        end
+      end
+    end
+  end
+end
+

data/lib/mongo_doc/validations.rb

@@ -0,0 +1,12 @@
+require 'mongo_doc/validations/macros'
+
+module MongoDoc
+  module Validations
+    def self.included(klass)
+      klass.class_eval do
+        include ::Validatable
+        extend Macros
+      end
+    end
+  end
+end

data/lib/mongo_doc/validations/macros.rb

@@ -0,0 +1,11 @@
+require 'mongo_doc/validations/validates_embedded'
+
+module MongoDoc
+  module Validations
+    module Macros
+      def validates_embedded(*args)
+        add_validations(args, MongoDoc::Validations::ValidatesEmbedded)
+      end
+    end
+  end
+end

data/lib/mongo_doc/validations/validates_embedded.rb

@@ -0,0 +1,13 @@
+module MongoDoc
+  module Validations
+    class ValidatesEmbedded < ::Validatable::ValidationBase
+      def valid?(instance)
+        instance.send(attribute).valid?
+      end
+
+      def message(instance)
+        super || "is invalid"
+      end
+    end
+  end
+end

data/lib/mongoid/contexts/enumerable.rb

@@ -0,0 +1,151 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Contexts #:nodoc:
+    class Enumerable
+      include Ids, Paging
+      attr_reader :criteria
+
+      delegate :blank?, :empty?, :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
+
+      # Get the average value for the supplied field.
+      #
+      # Example:
+      #
+      # <tt>context.avg(:age)</tt>
+      #
+      # Returns:
+      #
+      # A numeric value that is the average.
+      def avg(field)
+        total = sum(field)
+        total ? (total.to_f / count) : nil
+      end
+
+      # Gets the number of documents in the array. Delegates to size.
+      def count
+        @count ||= documents.size
+      end
+
+      # Gets an array of distinct values for the supplied field across the
+      # entire array or the susbset given the criteria.
+      #
+      # Example:
+      #
+      # <tt>context.distinct(:title)</tt>
+      def distinct(field)
+        execute.collect { |doc| doc.send(field) }.uniq
+      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
+
+      # 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
+
+      # 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>Mongoid::Contexts::Enumerable.new(criteria)</tt>
+      def initialize(criteria)
+        @criteria = criteria
+      end
+
+      # Iterate over each +Document+ in the results. This can take an optional
+      # block to pass to each argument in the results.
+      #
+      # Example:
+      #
+      # <tt>context.iterate { |doc| p doc }</tt>
+      def iterate(&block)
+        execute.each(&block)
+      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