mongo_doc 0.3.0

data/lib/mongo_doc/document.rb

@@ -0,0 +1,216 @@
+require 'mongo_doc/bson'
+require 'mongo_doc/query'
+require 'mongo_doc/attributes'
+require 'mongo_doc/criteria'
+require 'mongo_doc/finders'
+require 'mongo_doc/scope'
+require 'mongo_doc/validations/macros'
+
+module MongoDoc
+  class UnsupportedOperation < RuntimeError; end
+  class DocumentInvalidError < RuntimeError; end
+  class NotADocumentError < RuntimeError; end
+
+  module Document
+
+    def self.included(klass)
+      klass.class_eval do
+        include Attributes
+        extend ClassMethods
+        extend Criteria
+        extend Finders
+        extend Scope
+        include ::Validatable
+        extend Validations::Macros
+
+        alias :id :_id
+      end
+    end
+
+    def initialize(attrs = {})
+      self.attributes = attrs
+    end
+
+    def ==(other)
+      return false unless self.class === other
+      self.class._attributes.all? {|var| self.send(var) == other.send(var)}
+    end
+
+    def attributes
+      hash = {}
+      self.class._attributes.each do |attr|
+        hash[attr] = send(attr)
+      end
+      hash
+    end
+
+    def attributes=(attrs)
+      attrs.each do |key, value|
+        send("#{key}=", value)
+      end
+    end
+
+    def new_record?
+      _id.nil?
+    end
+
+    def remove
+      raise UnsupportedOperation.new('Document#remove is not supported for embedded documents') if _root
+      remove_document
+    end
+
+    def remove_document
+      return _root.remove_document if _root
+      _remove
+    end
+
+    def save(validate = true)
+      return _root.save(validate) if _root
+      return _save(false) unless validate and not valid?
+      false
+    end
+
+    def save!
+      return _root.save! if _root
+      raise DocumentInvalidError unless valid?
+      _save(true)
+    end
+
+    def to_bson(*args)
+      {MongoDoc::BSON::CLASS_KEY => self.class.name}.tap do |bson_hash|
+        bson_hash['_id'] = _id unless new_record?
+        self.class._attributes.each do |name|
+          bson_hash[name.to_s] = send(name).to_bson(args)
+        end
+      end
+    end
+
+    def to_param
+      _id.to_s
+    end
+
+    def update_attributes(attrs)
+      strict = attrs.delete(:__strict__)
+      self.attributes = attrs
+      return save if new_record?
+      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
+      return save! if new_record?
+      raise DocumentInvalidError unless valid?
+      if strict
+        _strict_update_attributes(_path_to_root(self, attrs), true)
+      else
+        _naive_update_attributes(_path_to_root(self, attrs), true)
+      end
+    end
+
+    module ClassMethods
+      def bson_create(bson_hash, options = {})
+        new.tap do |obj|
+          bson_hash.each do |name, value|
+            obj.send("#{name}=", MongoDoc::BSON.decode(value, options))
+          end
+        end
+      end
+
+      def collection
+        @collection ||= MongoDoc::Collection.new(collection_name)
+      end
+
+      def collection_name
+        self.to_s.tableize.gsub('/', '.')
+      end
+
+      def create(attrs = {})
+        instance = new(attrs)
+        instance.save(false)
+        instance
+      end
+
+      def create!(attrs = {})
+        instance = new(attrs)
+        instance.save!(true)
+        instance
+      end
+    end
+
+    protected
+
+    def _collection
+      self.class.collection
+    end
+
+    def _naive_update_attributes(attrs, safe)
+      return _root.send(:_naive_update_attributes, attrs, safe) if _root
+      _update({}, attrs, safe)
+    end
+
+    def _remove
+      _collection.remove({'_id' => _id})
+    end
+
+    def _strict_update_attributes(attrs, safe, selector = {})
+      return _root.send(:_strict_update_attributes, attrs, safe, _path_to_root(self, '_id' => _id)) if _root
+      _update(selector, attrs, safe)
+    end
+
+    def _update(selector, data, safe)
+      _collection.update({'_id' => _id}.merge(selector), MongoDoc::Query.set_modifier(data), :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 before_save_callback(root)
+      self._id = Mongo::ObjectID.new if new_record?
+    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/mongo_doc/ext/array.rb

@@ -0,0 +1,5 @@
+class Array
+  def to_bson(*args)
+    map {|item| item.to_bson(args)}
+  end
+end

data/lib/mongo_doc/ext/binary.rb

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

data/lib/mongo_doc/ext/boolean_class.rb

@@ -0,0 +1,11 @@
+class FalseClass
+  def to_bson(*args)
+    self
+  end
+end
+
+class TrueClass
+  def to_bson(*args)
+    self
+  end
+end

data/lib/mongo_doc/ext/date.rb

@@ -0,0 +1,16 @@
+class Date
+  def to_bson(*args)
+    {
+      MongoDoc::BSON::CLASS_KEY => self.class.name,
+      'dt' => strftime,
+      'sg' => start
+    }
+  end
+
+  alias start sg unless method_defined?(:start)
+
+  def self.bson_create(bson_hash, options = nil)
+    Date.parse(*bson_hash.values_at('dt', 'sg'))
+  end
+
+end

data/lib/mongo_doc/ext/date_time.rb

@@ -0,0 +1,13 @@
+class DateTime
+  def to_bson(*args)
+    {
+      MongoDoc::BSON::CLASS_KEY => self.class.name,
+      'dt' => strftime,
+      'sg' => start
+    }
+  end
+
+  def self.bson_create(bson_hash, options = nil)
+    DateTime.parse(*bson_hash.values_at('dt', 'sg'))
+  end
+end

data/lib/mongo_doc/ext/dbref.rb

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

data/lib/mongo_doc/ext/hash.rb

@@ -0,0 +1,7 @@
+class Hash
+  def to_bson(*args)
+    {}.tap do |hash|
+      each {|key, value| hash[key.to_s] = value.to_bson}
+    end
+  end  
+end

data/lib/mongo_doc/ext/nil_class.rb

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

data/lib/mongo_doc/ext/numeric.rb

@@ -0,0 +1,17 @@
+class Numeric
+  def to_bson(*args)
+    self
+  end
+end
+
+class Float
+  def to_bson(*args)
+    self
+  end
+end
+
+class Integer
+  def to_bson(*args)
+    self
+  end
+end

data/lib/mongo_doc/ext/object.rb

@@ -0,0 +1,17 @@
+class Object
+  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 = {})
+    new.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 Mongo
+  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,5 @@
+class Time
+  def to_bson(*args)
+    self
+  end
+end

data/lib/mongo_doc/finders.rb

@@ -0,0 +1,49 @@
+require 'mongo_doc/criteria'
+
+module MongoDoc
+  module Finders
+    def self.extended(base)
+      base.extend(Criteria) unless base === Criteria
+    end
+
+    %w(count first last).each do |name|
+      module_eval <<-RUBY
+        # #{name.humanize} for this +Document+ class
+        #
+        # <tt>Person.#{name}</tt>
+        def #{name}
+          criteria.#{name}
+        end
+      RUBY
+    end
+
+    # Find a +Document+ based on id (+String+ or +Mongo::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 +Mongo::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/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/query.rb

@@ -0,0 +1,7 @@
+module MongoDoc
+  module Query
+    def self.set_modifier(bson_hash)
+      {'$set' => bson_hash}
+    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/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/mongo_doc.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+
+gem 'mongo', '0.19'
+gem 'mongo_ext', '0.19'
+gem 'durran-validatable', '2.0.1'
+gem 'leshill-will_paginate', '2.3.11'
+
+require 'mongo'
+require 'active_support'
+require 'validatable'
+require 'will_paginate/collection'
+
+module MongoDoc
+  VERSION = '0.3.0'
+end
+
+require 'mongo_doc/connection'
+require 'mongo_doc/collection'
+require 'mongo_doc/document'

data/lib/mongoid/contexts/paging.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Contexts #:nodoc:
+    module Paging
+      # Paginates the documents.
+      #
+      # Example:
+      #
+      # <tt>context.paginate</tt>
+      #
+      # Returns:
+      #
+      # A collection of documents paginated.
+      def paginate
+        @collection ||= execute(true)
+        WillPaginate::Collection.create(page, per_page, count) do |pager|
+          pager.replace(@collection.to_a)
+        end
+      end
+
+      # Either returns the page option and removes it from the options, or
+      # returns a default value of 1.
+      #
+      # Returns:
+      #
+      # An +Integer+ page number.
+      def page
+        skips, limits = options[:skip], options[:limit]
+        (skips && limits) ? (skips + limits) / limits : 1
+      end
+
+      # Get the number of results per page or the default of 20.
+      #
+      # Returns:
+      #
+      # The +Integer+ number of documents in each page.
+      def per_page
+        (options[:limit] || 20).to_i
+      end
+    end
+  end
+end