mongodb 0.0.1 → 0.0.2

data/lib/mongodb/model/spec.rb

@@ -0,0 +1,12 @@
+require 'mongodb/driver/spec'
+
+rspec do
+  class << self
+    def with_mongo_model
+      with_mongo
+
+      before{Mongo::Model.db = mongo.db}
+      after{Mongo::Model.db = nil}
+    end
+  end
+end

data/lib/mongodb/model/support/types.rb

@@ -0,0 +1,110 @@
+#
+# Boolean
+#
+module Mongo::Model::BooleanType
+  Mapping = {
+    true    => true,
+    'true'  => true,
+    'TRUE'  => true,
+    'True'  => true,
+    't'     => true,
+    'T'     => true,
+    '1'     => true,
+    1       => true,
+    1.0     => true,
+    false   => false,
+    'false' => false,
+    'FALSE' => false,
+    'False' => false,
+    'f'     => false,
+    'F'     => false,
+    '0'     => false,
+    0       => false,
+    0.0     => false,
+    nil     => nil
+  }
+
+  def cast value
+    if value.is_a? Boolean
+      value
+    else
+      Mapping[value] || false
+    end
+  end
+end
+
+class Boolean; end unless defined?(Boolean)
+
+Boolean.extend Mongo::Model::BooleanType
+
+
+#
+# Date
+#
+require 'date'
+Date.class_eval do
+  def self.cast value
+    if value.nil? || value == ''
+      nil
+    else
+      date = value.is_a?(::Date) || value.is_a?(::Time) ? value : ::Date.parse(value.to_s)
+      date.to_date
+    end
+  rescue
+    nil
+  end
+end
+
+
+#
+# Float
+#
+Float.class_eval do
+  def self.cast value
+    value.nil? ? nil : value.to_f
+  end
+end
+
+
+#
+# Integer
+#
+Integer.class_eval do
+  def self.cast value
+    value_to_i = value.to_i
+    if value_to_i == 0 && value != value_to_i
+      value.to_s =~ /^(0x|0b)?0+/ ? 0 : nil
+    else
+      value_to_i
+    end
+  end
+end
+
+
+#
+# String
+#
+String.class_eval do
+  def self.cast value
+    value.nil? ? nil : value.to_s
+  end
+end
+
+
+#
+# Time
+#
+Time.class_eval do
+  def self.cast value
+    if value.nil? || value == ''
+      nil
+    else
+      # time_class = ::Time.try(:zone).present? ? ::Time.zone : ::Time
+      # time = value.is_a?(::Time) ? value : time_class.parse(value.to_s)
+      # strip milliseconds as Ruby does micro and bson does milli and rounding rounded wrong
+      # at(time.to_i).utc if time
+
+      value.is_a?(::Time) ? value : Date.parse(value.to_s).to_time
+    end
+  end
+end

data/lib/mongodb/model/validation.rb

@@ -0,0 +1,5 @@
+module Mongo::Model::Validation
+  def _valid?
+    !(respond_to?(:errors) and errors and !errors.empty?)
+  end
+end

data/lib/mongodb/object.rb

@@ -0,0 +1,18 @@
+require 'mongodb/driver'
+
+%w(
+  object_serializer
+  object_helper
+).each{|f| require "mongodb/object/#{f}"}
+
+Mongo.defaults[:callbacks] = true
+
+# collection
+Mongo::Collection.class_eval do
+  include Mongo::ObjectHelper
+
+  %w(insert update remove save).each do |method|
+    alias_method "#{method}_without_object", method
+    alias_method method, "#{method}_with_object"
+  end
+end

data/lib/mongodb/object/object_helper.rb

@@ -0,0 +1,62 @@
+module Mongo::ObjectHelper
+  #
+  # CRUD
+  #
+  def save_with_object doc, opts = {}
+    if doc.is_a? Hash
+      save_without_object doc, opts
+    else
+      ::Mongo::ObjectSerializer.new(doc).save opts, self
+    end
+  end
+
+  def insert_with_object args, opts = {}
+    if args.is_a?(Hash) or args.is_a?(Array)
+      insert_without_object args, opts
+    else
+      ::Mongo::ObjectSerializer.new(args).insert opts, self
+    end
+  end
+
+  def update_with_object selector, doc, opts = {}
+    if doc.is_a?(Hash)
+      update_without_object selector, doc, opts
+    else
+      raise "can't use update selector with object (#{selector}, {#{doc}})!" unless selector == nil
+      ::Mongo::ObjectSerializer.new(doc).update opts, self
+    end
+  end
+
+  def remove_with_object arg = {}, opts = {}
+    if arg.is_a? Hash
+      remove_without_object arg, opts
+    else
+      ::Mongo::ObjectSerializer.new(arg).remove opts, self
+    end
+  end
+  
+  def save! doc, opts = {}
+    save(doc, opts) || raise(Mongo::Error, "can't save #{doc.inspect}!")
+  end
+
+
+  #
+  # Querying
+  #
+  def first selector = {}, opts = {}, &block
+    opts = opts.clone
+    object = (opts.delete(:object) == false) ? false : true
+    doc = super selector, opts, &block
+    object ? ::Mongo::ObjectSerializer.build(doc) : doc
+  end
+  
+  def each selector = {}, opts = {}, &block
+    opts = opts.clone
+    object = (opts.delete(:object) == false) ? false : true
+    super selector, opts do |doc|
+      doc = ::Mongo::ObjectSerializer.build(doc) if object
+      block.call doc
+    end
+    nil
+  end
+end

data/lib/mongodb/object/object_serializer.rb

@@ -0,0 +1,273 @@
+class Mongo::ObjectSerializer
+  SIMPLE_TYPES = [
+    Fixnum, Float,
+    TrueClass, FalseClass,
+    String, Symbol,
+    Array, Hash, Set,
+    Data, DateTime,
+    NilClass, Time,
+    BSON::ObjectId
+  ].to_set
+
+  attr_reader :object
+
+  def initialize object
+    @object = object
+  end
+
+  def save opts, collection
+    if _id
+      self.update opts.merge(upsert: true), collection
+    else
+      self.insert opts, collection
+    end
+  end
+
+  def insert opts, collection
+    opts, validate, callbacks = parse_object_options opts
+
+    # before callbacks
+    return false if callbacks and !run_callbacks(objects, [:before, :validate], [:before, :save], [:before, :create])
+
+    # validation
+    return false if validate  and !valid?
+
+    # saving document
+    doc = to_document
+    collection.insert_without_object doc, opts
+    id = doc[:_id] || doc['_id'] || raise("internal error: no id after document insertion (#{doc})!")
+    object.instance_variable_set :@_id, id
+    update_internal_state!
+
+    # after callbacks
+    run_callbacks(objects, [:after, :create], [:after, :save], [:after, :validate]) if callbacks
+
+    true
+  end
+
+  def update opts, collection
+    opts, validate, callbacks = parse_object_options opts
+
+    # before callbacks.
+    # we need to sort out embedded objects into created, updated and destroyed
+    created_objects, updated_objects, destroyed_objects = [], [], []
+    if callbacks
+      original_ids = original_objects.collect{|obj| obj.object_id}.to_set
+      objects.each do |obj|
+        (original_ids.include?(obj.object_id) ? updated_objects : created_objects) << obj
+      end
+
+      objects_ids = objects.collect{|obj| obj.object_id}.to_set
+      destroyed_objects = original_objects.select{|obj| !objects_ids.include?(obj.object_id)}
+
+      all_successfull = [
+        run_callbacks(created_objects,   [:before, :validate], [:before, :save],   [:before, :create]),
+        run_callbacks(updated_objects,   [:before, :validate], [:before, :save],   [:before, :update]),
+        run_callbacks(destroyed_objects, [:before, :validate], [:before, :destroy])
+      ].reduce(:&)
+
+      return false unless all_successfull
+    end
+
+    # validation
+    return false if validate  and !valid?
+
+    # saving document
+    doc = to_document
+    id = _id || raise("can't update document without id (#{doc})!")
+    collection.update_without_object({_id: id}, doc, opts)
+    update_internal_state!
+
+    # after callbacks
+    if callbacks
+      run_callbacks(created_objects,   [:after, :create],  [:after, :save],    [:after, :validate])
+      run_callbacks(updated_objects,   [:after, :update],  [:after, :save],    [:after, :validate])
+      run_callbacks(destroyed_objects, [:after, :destroy], [:after, :validate])
+    end
+
+    true
+  end
+
+  def remove opts, collection
+    opts, validate, callbacks = parse_object_options opts
+
+    # before callbacks
+    if callbacks
+      # we need to run :destroy callbacks also on detached embedded objects.
+      all_objects = (objects + original_objects).uniq{|o| o.object_id}
+      return false unless run_callbacks(all_objects, [:before, :validate], [:before, :destroy])
+    end
+
+    # validation
+    return false if validate  and !valid?
+
+    # saving document
+    id = _id || "can't destroy object without _id (#{arg})!"
+    collection.remove_without_object({_id: id}, opts)
+    update_internal_state!
+
+    # after callbacks
+    run_callbacks(objects, [:after, :destroy], [:after, :validate]) if callbacks
+
+    true
+  end
+
+  def to_document
+    _to_document object
+  end
+
+  def _id
+    object.instance_variable_get(:@_id)
+  end
+
+  def valid?
+    objects.each do |obj|
+      return false if obj.respond_to?(:_valid?) and !obj._valid?
+    end
+    true
+  end
+
+  def run_callbacks objects, *callbacks
+    callbacks.each do |type, method_name|
+      objects.each do |obj|
+        if obj.respond_to? :_run_callbacks
+          return false if obj._run_callbacks(type, method_name) == false
+        end
+      end
+    end
+    true
+  end
+
+  def objects
+    @objects_cache ||= begin
+      objects = []
+      _each_object(object){|obj| objects << obj}
+      objects
+    end
+  end
+
+  def update_internal_state!
+    self.original_objects = objects if Mongo.defaults[:callbacks]
+  end
+
+  protected
+    def original_objects; object.instance_variable_get(:@_original_objects) end
+    def original_objects= objects; object.instance_variable_set(:@_original_objects, objects) end
+
+    def parse_object_options opts
+      opts = opts.clone
+      validate  = opts.delete(:validate)  == false ? false : true
+      callbacks = opts.delete(:callbacks) == false ? false : Mongo.defaults[:callbacks]
+      return opts, validate, callbacks
+    end
+
+    # need this to allow change it in specs
+    # RSpec adds @mock_proxy, and we need to skip it
+    SKIP_IV_REGEXP = /^@_/
+
+    def _each_instance_variable obj, &block
+      obj.instance_variables.each do |iv_name|
+        # skipping variables starting with _xx, usually they
+        # have specific meaning and used for example for cache
+        next if iv_name =~ SKIP_IV_REGEXP
+
+        block.call iv_name, obj.instance_variable_get(iv_name)
+      end
+    end
+
+    # converts object to document (also works with nested & arrays)
+    def _to_document obj
+      return obj.to_mongo if obj.respond_to? :to_mongo
+
+      if obj.is_a? Hash
+        doc = {}
+        obj.each do |k, v|
+          doc[k] = _to_document v
+        end
+        doc
+      elsif obj.is_a? Array
+        obj.collect{|v| _to_document v}
+      elsif SIMPLE_TYPES.include? obj.class
+        obj
+      else
+        doc = {}
+
+        # copying instance variables
+        _each_instance_variable obj do |iv_name, v|
+          k = iv_name.to_s[1..-1]
+          k = k.to_sym if Mongo.defaults[:symbolize]
+          doc[k] = _to_document v
+        end
+
+        # adding _id & _class
+        id_key, class_key = Mongo.defaults[:symbolize] ? [:_id, :_class] : ['_id', '_class']
+        id = instance_variable_get('@_id')
+        doc[id_key]    = id if id
+        doc[class_key] = obj.class.name
+
+        doc
+      end
+    end
+
+    def _each_object obj, &block
+      if obj.is_a? Hash
+        obj.each{|k, v| _each_object v, &block}
+      elsif obj.is_a? Array
+        obj.each{|v| _each_object v, &block}
+      elsif SIMPLE_TYPES.include? obj.class
+      else
+        block.call obj
+        _each_instance_variable obj do |iv_name, v|
+          _each_object v, &block
+        end
+      end
+      nil
+    end
+
+
+  class << self
+    def build doc
+      obj = _build doc
+      serializer = Mongo::ObjectSerializer.new obj
+      serializer.update_internal_state!
+      obj
+    end
+
+    protected
+      def _build doc
+        if doc.is_a? Hash
+          if class_name = doc[:_class] || doc['_class']
+            klass = constantize class_name
+
+            if klass.respond_to? :to_object
+              klass.to_object doc
+            else
+              obj = klass.new
+              doc.each do |k, v|
+                next if k.to_sym == :_class
+
+                v = _build v
+                obj.instance_variable_set "@#{k}", v
+              end
+              obj
+            end
+          else
+            doc
+          end
+        elsif doc.is_a? Array
+          doc.collect{|v| _build v}
+        else
+          doc
+        end
+      end
+
+      def constantize class_name
+        @constantize_cache ||= {}
+        unless klass = @constantize_cache[class_name]
+          klass = eval class_name, TOPLEVEL_BINDING, __FILE__, __LINE__
+          @constantize_cache[class_name] = klass
+        end
+        klass
+      end
+  end
+end