mongoo 0.1.2

data/lib/mongoo/changelog.rb

@@ -0,0 +1,36 @@
+module Mongoo
+  module Changelog
+    
+    def changelog
+      persisted_mongohash_kv = (self.persisted_mongohash || Mongoo::Mongohash.new).to_key_value
+      curr_mongohash_kv      = self.mongohash.to_key_value
+      
+      log = []
+      
+      persisted_mongohash_kv.each do |k,v|
+        unless curr_mongohash_kv.has_key?(k)
+          found = nil
+          parts = k.split(".")
+          while parts.pop
+            if !self.mongohash.dot_get(parts.join("."))
+              found = [:unset, parts.join("."), 1]
+            end
+          end
+          found ||= [:unset, k, 1]
+          log << found
+        end
+      end
+      
+      curr_mongohash_kv.each do |k,v|
+        if v != persisted_mongohash_kv[k]
+          unless log.include?([:set, k, v])
+            log << [:set, k, v]
+          end
+        end
+      end
+      
+      log.uniq
+    end
+    
+  end
+end

data/lib/mongoo/cursor.rb

@@ -0,0 +1,55 @@
+module Mongoo
+  class Cursor
+    include Enumerable
+  
+    attr_accessor :mongo_cursor
+
+    def initialize(obj_class, mongo_cursor)
+      @obj_class    = obj_class
+      @mongo_cursor = mongo_cursor
+    end
+  
+    def next_document
+      if doc = @mongo_cursor.next_document
+        @obj_class.new(doc, true)
+      end
+    end
+  
+    alias :next :next_document
+  
+    def each
+      @mongo_cursor.each do |doc|
+        yield(@obj_class.new(doc, true))
+      end
+    end
+  
+    def sort(key_or_list, direction=nil)
+      @mongo_cursor.sort(key_or_list, direction)
+      self
+    end
+    
+    def limit(number_to_return=nil)
+      @mongo_cursor.limit(number_to_return)
+      self
+    end
+    
+    def skip(number_to_return=nil)
+      @mongo_cursor.skip(number_to_return)
+      self
+    end
+    
+    def batch_size(size=0)
+      @mongo_cursor.batch_size(size)
+      self
+    end
+  
+    def method_missing(name, *args)
+      if @mongo_cursor.respond_to?(name)
+        @mongo_cursor.send name, *args
+      else
+        super
+      end
+    end
+  
+  end
+end

data/lib/mongoo/hash_ext.rb

@@ -0,0 +1,21 @@
+module Mongoo
+  module HashExt
+    def deep_stringify_keys
+      Marshal.load(Marshal.dump(self)).deep_stringify_keys!
+    end
+    
+    def deep_stringify_keys!
+      keys.each do |key|
+        self[key.to_s] = delete(key)
+        if self[key.to_s].is_a?(Hash)
+          self[key.to_s].stringify_keys!
+        end
+      end
+      self
+    end
+  end
+end
+
+class Hash
+  include Mongoo::HashExt
+end

data/lib/mongoo/modifiers.rb

@@ -0,0 +1,150 @@
+module Mongoo
+  class ModifierUpdateError < Exception; end
+  class UnknownAttributeError < Exception; end
+  
+  class ModifierBuilder
+    def initialize(opts, doc)
+      @opts  = opts
+      @doc   = doc
+      @queue = {}
+      @key_prefix = opts[:key_prefix] || ""
+    end
+    
+    def ensure_valid_field!(k)
+      unless @doc.known_attribute?("#{@key_prefix}#{k}")
+        raise UnknownAttributeError, "#{@key_prefix}#{k}"
+      end
+    end
+    
+    def sanitize_value(k,v)
+      k = "#{@key_prefix}#{k}"
+      field_type = @doc.class.attributes[k][:type]
+      Mongoo::AttributeSanitizer.sanitize(field_type, v)
+    end
+    
+    def inc(k, v=1)
+      ensure_valid_field!(k)
+      v = sanitize_value(k,v)
+      @queue["$inc"] ||= {}
+      @queue["$inc"]["#{@key_prefix}#{k}"] = v
+    end
+    
+    def set(k,v)
+      ensure_valid_field!(k)
+      v = sanitize_value(k,v)
+      @queue["$set"] ||= {}
+      @queue["$set"]["#{@key_prefix}#{k}"] = v
+    end
+    
+    def unset(k)
+      ensure_valid_field!(k)
+      @queue["$unset"] ||= {}
+      @queue["$unset"]["#{@key_prefix}#{k}"] = 1
+    end
+
+    def push(k, v)
+      ensure_valid_field!(k)
+      @queue["$push"] ||= {}
+      @queue["$push"]["#{@key_prefix}#{k}"] = v
+    end
+    
+    def push_all(k, v)
+      ensure_valid_field!(k)
+      @queue["$pushAll"] ||= {}
+      @queue["$pushAll"]["#{@key_prefix}#{k}"] = v
+    end
+    
+    def add_to_set(k,v)
+      ensure_valid_field!(k)
+      @queue["$addToSet"] ||= {}
+      @queue["$addToSet"]["#{@key_prefix}#{k}"] = v
+    end
+    
+    def pop(k)
+      ensure_valid_field!(k)
+      @queue["$pop"] ||= {}
+      @queue["$pop"]["#{@key_prefix}#{k}"] = 1
+    end
+    
+    def pull(k, v)
+      ensure_valid_field!(k)
+      @queue["$pull"] ||= {}
+      @queue["$pull"]["#{@key_prefix}#{k}"] = v
+    end
+    
+    def pull_all(k, v)
+      ensure_valid_field!(k)
+      @queue["$pullAll"] ||= {}
+      @queue["$pullAll"]["#{@key_prefix}#{k}"] = v
+    end
+    
+    def run!
+      ret = @doc.collection.update({"_id" => @doc.id}, @queue, @opts)
+      if !ret.is_a?(Hash) || (ret["err"] == nil && ret["n"] == 1)
+        @queue.each do |op, op_queue|
+          op_queue.each do |k, v|
+            case op
+            when "$inc" then
+              new_val = @doc.persisted_mongohash.dot_get(k).to_i + v
+              @doc.mongohash.dot_set( k, new_val )
+              @doc.persisted_mongohash.dot_set( k, new_val )
+            when "$set" then
+              @doc.mongohash.dot_set( k, v )
+              @doc.persisted_mongohash.dot_set( k, v )
+            when "$unset" then
+              @doc.mongohash.dot_delete( k )
+              @doc.persisted_mongohash.dot_delete( k )
+            when "$push" then
+              new_val = (@doc.persisted_mongohash.dot_get(k) || []) + [v]
+              @doc.mongohash.dot_set( k, new_val )
+              @doc.persisted_mongohash.dot_set( k, new_val )
+            when "$pushAll" then
+              new_val = (@doc.persisted_mongohash.dot_get(k) || []) + v
+              @doc.mongohash.dot_set( k, new_val )
+              @doc.persisted_mongohash.dot_set( k, new_val )
+            when "$addToSet" then
+              new_val = (@doc.persisted_mongohash.dot_get(k) || [])
+              new_val << v unless new_val.include?(v)
+              @doc.mongohash.dot_set(k, new_val)
+              @doc.persisted_mongohash.dot_set(k, new_val)
+            when "$pop" then
+              new_val = (@doc.persisted_mongohash.dot_get(k) || [])
+              new_val.pop
+              @doc.mongohash.dot_set(k, new_val)
+              @doc.persisted_mongohash.dot_set(k, new_val)
+            when "$pull" then
+              new_val = (@doc.persisted_mongohash.dot_get(k) || [])
+              new_val.delete(v)
+              @doc.mongohash.dot_set(k, new_val)
+              @doc.persisted_mongohash.dot_set(k, new_val)
+            when "$pullAll" then
+              new_val = (@doc.persisted_mongohash.dot_get(k) || [])
+              v.each do |val|
+                new_val.delete(val)
+              end
+              @doc.mongohash.dot_set(k, new_val)
+              @doc.persisted_mongohash.dot_set(k, new_val)
+            end
+          end
+        end
+        true
+      else
+        raise ModifierUpdateError, ret.inspect
+      end
+    end
+  end
+  
+  module Modifiers
+    
+    def mod(opts={}, &block)
+      builder = ModifierBuilder.new(opts, self)
+      block.call(builder)
+      builder.run!
+    end
+    
+    def mod!(opts={}, &block)
+      mod(opts.merge(:safe => true), &block)
+    end
+    
+  end
+end

data/lib/mongoo/mongohash.rb

@@ -0,0 +1,79 @@
+module Mongoo
+  class Mongohash
+    extend Forwardable
+      
+    def_delegators :@raw_hash, :==, :[], :[], :[]=, :clear, :default, :default=, :default_proc, :delete, :delete_if,
+                   :each, :each_key, :each_pair, :each_value, :empty?, :fetch, :has_key?, :has_value?, :include?,
+                   :index, :indexes, :indices, :initialize_copy, :inspect, :invert, :key?, :keys, :length, :member?,
+                   :merge, :merge!, :pretty_print, :pretty_print_cycle, :rehash, :reject, :reject!, :replace, :select,
+                   :shift, :size, :sort, :store, :to_a, :to_hash, :to_s, :update, :value?, :values, :values_at
+    
+    attr_reader :raw_hash
+    
+    def initialize(hash={})
+      hash = hash.to_hash unless hash.class.to_s == "Hash"
+      @raw_hash = hash.deep_stringify_keys
+    end
+
+    def deep_clone
+      Mongoo::Mongohash.new(Marshal.load(Marshal.dump self.raw_hash))
+    end
+    
+    def dot_set(k,v)
+      parts    = k.to_s.split(".")
+      curr_val = to_hash
+      while !parts.empty?
+        part = parts.shift
+        if parts.empty?
+          curr_val[part] = v
+        else
+          curr_val[part] ||= {}
+          curr_val = curr_val[part]
+        end
+      end
+      true
+    end
+    
+    def dot_get(k)
+      parts    = k.to_s.split(".")
+      curr_val = to_hash
+      while !parts.empty?
+        part = parts.shift
+        curr_val = curr_val[part]
+        return curr_val unless curr_val.is_a?(Hash)
+      end
+      curr_val
+    end
+    
+    def dot_delete(k)
+      parts    = k.to_s.split(".")
+      curr_val = to_hash
+      while !parts.empty?
+        part = parts.shift
+        if parts.empty?
+          curr_val.delete(part)
+          return true
+        else
+          curr_val = curr_val[part]
+        end
+      end
+      false
+    end
+    
+    def dot_list(curr_hash=self.to_hash, path=[])
+      list = []
+      curr_hash.each do |k,v|
+        if v.is_a?(Hash)
+          list.concat dot_list(v, (path + [k]))
+        else
+          list << (path + [k]).join(".")
+        end
+      end
+      list
+    end
+    
+    def to_key_value
+      kv = {}; dot_list.collect { |k| kv[k] = dot_get(k) }; kv
+    end
+  end
+end

data/lib/mongoo/persistence.rb

@@ -0,0 +1,256 @@
+module Mongoo
+  class AlreadyInsertedError < Exception; end
+  class NotInsertedError < Exception; end
+  class InsertError < Exception; end
+  class StaleUpdateError < Exception; end
+  class UpdateError < Exception; end
+  class RemoveError < Exception; end
+  class NotValidError < Exception; end
+  
+  module Persistence
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    module ClassMethods      
+      def collection_name
+        @collection_name ||= self.model_name.tableize
+      end
+      
+      def collection
+        @collection ||= db.collection(collection_name)
+      end
+      
+      def conn
+        @conn ||= begin
+          if Mongoo.config == config
+            Mongoo.conn
+          else
+            Mongo::Connection.new(config[:host], config[:port], config[:opts])
+          end
+        end
+      end
+      
+      def db
+        @db ||= begin
+          if Mongoo.config == config
+            Mongoo.db
+          else
+            conn.db(config[:db])
+          end
+        end
+      end
+      
+      def config=(cfg)
+        @config = cfg
+      end
+      
+      def config
+        @config || Mongoo.config
+      end
+      
+      def db=(db)
+        @db = db
+      end
+      
+      def find(query={}, opts={})
+        Mongoo::Cursor.new(self, collection.find(query, opts))
+      end
+      
+      def find_one(query={}, opts={})
+        return nil unless doc = collection.find_one(query, opts)
+        new(doc, true)
+      end
+      
+      def all
+        find
+      end
+      
+      def each
+        find.each { |found| yield(found) }
+      end
+      
+      def first
+        find.limit(1).next_document
+      end
+      
+      def empty?
+        count == 0
+      end
+      
+      def count
+        collection.count
+      end
+      
+      def drop
+        collection.drop
+      end
+      
+      def index_meta
+        Mongoo::INDEX_META[self.collection_name] ||= {}
+      end
+      
+      def index(spec, opts={})
+        self.index_meta[spec] = opts
+      end
+      
+      def create_indexes
+        self.index_meta.each do |spec, opts|
+          opts[:background] = true if !opts.has_key?(:background)
+          collection.create_index(spec, opts)
+        end; true
+      end
+    end # ClassMethods
+        
+    def to_param
+      persisted? ? get("_id").to_s : nil
+    end
+    
+    def to_key
+      get("_id")
+    end
+    
+    def to_model
+      self
+    end
+    
+    def persisted?
+      @persisted == true
+      #!get("_id").nil?
+    end
+    
+    def collection
+      self.class.collection
+    end
+    
+    def insert(opts={})
+      _run_insert_callbacks do
+        if persisted?
+          raise AlreadyInsertedError, "document has already been inserted"
+        end
+        unless valid?
+          if opts[:safe] == true
+            raise Mongoo::NotValidError, "document contains errors"
+          else
+            return false
+          end
+        end
+        ret = self.collection.insert(mongohash.deep_clone, opts)
+        unless ret.is_a?(BSON::ObjectId)
+          raise InsertError, "not an object: #{ret.inspect}"
+        end
+        set("_id", ret)
+        @persisted = true
+        set_persisted_mongohash(mongohash.deep_clone)
+        ret
+      end
+    end
+    
+    def insert!(opts={})
+      insert(opts.merge(:safe => true))
+    end
+    
+    def update(opts={})
+      _run_update_callbacks do
+        unless persisted?
+          raise NotInsertedError, "document must be inserted before being updated"
+        end
+        unless valid?
+          if opts[:safe] == true
+            raise Mongoo::NotValidError, "document contains errors"
+          else
+            return false
+          end
+        end
+        opts[:only_if_current] = true unless opts.has_key?(:only_if_current)
+        opts[:safe] = true if !opts.has_key?(:safe) && opts[:only_if_current] == true
+        update_hash = build_update_hash(self.changelog)
+        return true if update_hash.empty?
+        update_query_hash = build_update_query_hash(persisted_mongohash.to_key_value, self.changelog)
+        if Mongoo.verbose_debug
+          puts "\n* update_query_hash: #{update_query_hash.merge({"_id" => get("_id")}).inspect}\n  update_hash: #{update_hash.inspect}\n  opts: #{opts.inspect}\n"
+        end
+        ret = self.collection.update(update_query_hash.merge({"_id" => get("_id")}), update_hash, opts)
+        if !ret.is_a?(Hash) || (ret["updatedExisting"] && ret["n"] == 1)
+          set_persisted_mongohash(mongohash.deep_clone)
+          @persisted = true
+          true
+        else
+          if opts[:only_if_current]
+            raise StaleUpdateError, ret.inspect
+          else
+            raise UpdateError, ret.inspect
+          end
+        end
+      end
+    end
+    
+    def update!(opts={})
+      update(opts.merge(:safe => true))
+    end
+    
+    def destroyed?
+      @destroyed != nil
+    end
+    
+    def new_record?
+      !persisted?
+    end
+    
+    def remove(opts={})
+      _run_remove_callbacks do
+        unless persisted?
+          raise NotInsertedError, "document must be inserted before it can be removed"
+        end
+        ret = self.collection.remove({"_id" => get("_id")}, opts)
+        if !ret.is_a?(Hash) || (ret["err"] == nil && ret["n"] == 1)
+          @destroyed = true
+          @persisted = false
+          true
+        else
+          raise RemoveError, ret.inspect
+        end
+      end
+    end
+    
+    def remove!(opts={})
+      remove(opts.merge(:safe => true))
+    end
+    
+    def reload
+      init_from_hash(collection.find_one(get("_id")))
+      @persisted = true
+      set_persisted_mongohash(mongohash.deep_clone)
+      true
+    end
+    
+    def build_update_hash(changelog)
+      update_hash = {}
+      changelog.each do |op, k, v|
+        update_hash["$#{op}"] ||= {}
+        update_hash["$#{op}"][k] = v
+      end
+      update_hash
+    end
+    protected :build_update_hash
+    
+    def build_update_query_hash(persisted_mongohash_kv, changelog)
+      update_query_hash = {}
+      changelog.each do |op, k, v|
+        if persisted_val = persisted_mongohash_kv[k]
+          if persisted_val == []
+            # work around a bug where mongo won't find a doc
+            # using an empty array [] if an index is defined
+            # on that field.
+            persisted_val = { "$size" => 0 }
+          end
+          update_query_hash[k] = persisted_val
+        end
+      end
+      update_query_hash
+    end
+    protected :build_update_query_hash
+    
+  end
+end