mongo_odm 0.1.8

data/Gemfile

@@ -0,0 +1,11 @@
+source 'http://rubygems.org'
+
+gem "activesupport", "3.0.0.beta3"
+gem "activemodel", "3.0.0.beta3"
+gem "mongo", "~>1.0.2"
+gem "bson_ext", "~>1.0.1"
+gem "tzinfo", "~>0.3.22"
+
+group :test do
+  gem 'rspec', '~>1.3.0'
+end

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright 2010 Carlos Paramio
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,251 @@
+= mongo_odm
+
+Flexible persistence module for any Ruby class to MongoDB.
+
+= Why another ODM for MongoDB?
+
+MongoMapper, Mongoid, and others, are amazing projects. But I still think it's too much for an ODM for MongoDB.
+The Mongo Ruby driver allows you to query the database with a nice interface, the only required thing is a way to instanciate
+the results as objects of predefined classes, so you can encapsulate all the logic under a particular class and don't have to
+worry about type conversions.
+
+= Basics
+
+A piece of code is better than a hundred words:
+
+  class Shape
+    include MongoODM::Document
+    field :name
+    field :x, Float, :default => 0.0
+    field :y, Float, :default => 0.0
+  end
+  
+  shape = Shape.new(:name => "Point", :x => 0, :y => 5)
+  shape.save
+  
+  # Saves:
+  # { "_id"    : ObjectId("4be97178715dd2c4be000006"),
+  #   "_class" : "Shape",
+  #   "x"      : 0,
+  #   "y"      : 5,
+  #   "color"  : null,
+  #   "name"   : "Point"
+  # }
+  
+  class Circle < Shape
+    set_collection :shapes # Because we don't want them to be saved on a separated collection
+    field :radius, Float, :default => 1.0
+  end
+  
+  circle = Circle.new.save
+  
+  # Saves:
+  # { "_id"    : ObjectId("4be97203715dd2c4be000007"),
+  #   "_class" : "Circle",
+  #   "x"      : 1,
+  #   "y"      : 1,
+  #   "color"  : null,
+  #   "radius" : 1 }
+
+  all_shapes = Shape.find.to_a
+  
+  # Returns all the shapes; notice they are of different classes:
+  # [ #<Shape x: 0.0, y: 5.0, color: nil, name: "Point", _id: {"$oid"=>"4be97178715dd2c4be000006"}>,
+  #   #<Circle x: 1.0, y: 1.0, color: nil, radius: 1.0, _id: {"$oid"=>"4be97293715dd2c4be000008"}> ]
+
+In fact, you can instanciate any document stored as a hash to the appropiate class. The document just need
+to have the attribute "_class" set to the name of the class you want to use as the object type. Example:
+
+  MongoODM.instanciate({ :x => 12, :y => 5, '_class' => 'Circle' })
+
+  # Returns:
+  # #<Circle x: 12.0, y: 5.0, color: nil, radius: 1.0>
+
+= Associations
+
+To embed just one copy of another class, just define the field type of that class. The class just need to respond to the "type_cast" class method and the "to_mongo" instance method. Example:
+
+  class RGB
+    def initialize(r, g, b)
+      @r, @g, @b = r, g, b
+    end
+    
+    def inspect
+      "RGB(#{@r},#{@g},#{@b})"
+    end
+    
+    def to_mongo
+      [@r, @g, @b]
+    end
+    
+    def self.type_cast(value)
+      return nil if value.nil?
+      return value if value.is_a?(RGB)
+      return new(value[0], value[1], value[2]) if value.is_a?(Array)
+    end
+  end
+
+  class Color
+    include MongoODM::Document
+    field :name
+    field :rgb, RGB
+    
+    create_index :name, :unique => true
+  end
+  
+  color = Color.new(:name => "red", :rgb => RGB.new(255,0,0))
+  color.save
+  
+  # Saves:
+  # {"_class":"Color","name":"red","rgb":[255,0,0],"_id":{"$oid": "4bf070fb715dd271c2000001"}}
+
+  red = Color.find({:name => "red"}).first
+  
+  # Returns:
+  # #<Color name: "red", rgb: RGB(255,0,0), _id: {"$oid"=>"4bf070fb715dd271c2000001"}>
+  
+
+Of course, if the embedded object's class includes the MongoODM::Document module, you don't need to
+define those methods. Just define the field as that class:
+
+  class RGB
+    include MongoODM::Document
+    field :r, Fixnum
+    field :g, Fixnum
+    field :b, Fixnum
+  end
+
+  class Color
+    include MongoODM::Document
+    field :name
+    field :rgb, RGB
+  end
+  
+  color = Color.new(:name => "red", :rgb => RGB.new(:r => 255, :g => 0, :b => 0))
+  color.save
+  
+  # Saves:
+  # {"_class":"Color","name":"red","rgb":{"_class":"RGB","r":255,"g":0,"b":0},"_id":{"$oid": "4bf073e3715dd27212000001"}}
+
+  red = Color.find({:name => "red"}).first
+  
+  # Returns:
+  # #<Color name: "red", rgb: #<RGB r: 255, g: 0, b: 0>, _id: {"$oid"=>"4bf073e3715dd27212000001"}>
+
+
+If you want to save a collection of objects, just define the field as an Array. You can even store objects of different types!
+
+  class Shape
+    include MongoODM::Document
+    field :x, Float
+    field :y, Float
+  end
+  
+  class Circle < Shape
+    include MongoODM::Document
+    field :radius, Float
+  end
+  
+  class Line < Shape
+    include MongoODM::Document
+    field :dx, Float
+    field :dy, Float
+  end
+
+  class Draw
+    include MongoODM::Document
+    field :objects, Array
+  end
+
+  circle1 = Circle.new(:x => 1, :y => 1, :radius => 10)
+  circle2 = Circle.new(:x => 2, :y => 2, :radius => 20)
+  line = Line.new(:x => 0, :y => 0, :dx => 10, :dy => 5)
+
+  draw = Draw.new(:objects => [circle1, line, circle2])
+  draw.save
+  
+  # Saves:
+  # { "_class" : "Draw",
+  #   "objects" : [ { "_class" : "Circle",
+  #                   "x" : 1.0,
+  #                   "y" : 1.0,
+  #                   "color" : null,
+  #                   "radius" : 10.0 },
+  #                 { "_class" : "Line",
+  #                   "x" : 0.0,
+  #                   "y" : 0.0,
+  #                   "color" : null,
+  #                   "dx" : 10.0,
+  #                   "dy" : 5.0},
+  #                 { "_class" : "Circle",
+  #                   "x" : 2.0,
+  #                   "y" : 2.0,
+  #                   "color" : null,
+  #                   "radius" : 20.0 } ],
+  #   "_id":{"$oid": "4bf0775d715dd2725a000001"}}
+
+  Draw.find_one
+  
+  # Returns
+  # #<Draw objects: [#<Circle x: 1.0, y: 1.0, color: nil, radius: 10.0>, #<Line x: 0.0, y: 0.0, color: nil, dx: 10.0, dy: 5.0>, #<Circle x: 2.0, y: 2.0, color: nil, radius: 20.0>], _id: {"$oid"=>"4bf0775d715dd2725a000001"}>
+
+
+To reference the associated objects instead of embed them, for now you need to define your own methods. Example:
+
+  class Flag
+    include MongoODM::Document
+    field :colors, Array
+    
+    def colors
+      Color.find(:_id => {'$in' => read_attribute(:colors)})
+    end
+  end
+
+  class Color
+    include MongoODM::Document
+    field :name
+  end
+
+  Color.new(:name => "red").save
+  Color.new(:name => "green").save
+
+  flag = Flag.new(:colors => [ Color.find_one(:name => "red").id, Color.find_one(:name => "green").id ])
+  flag.save
+
+  # Saves:
+  # { "_id"    : ObjectId("4be96c15715dd2c4be000003"),
+  #   "_class" : "Flag",
+  #   "colors" : [ ObjectId("4be96bfe715dd2c4be000001"), ObjectId("4be96c08715dd2c4be000002") ]
+  # }
+  
+  flag.colors
+  
+  # Returns a cursor
+  
+  flag.colors.to_a
+  
+  # Returns:
+  # [#<Color name: "red", _id: {"$oid"=>"4be96bfe715dd2c4be000001"}>, #<Color name: "green", _id: {"$oid"=>"4be96c08715dd2c4be000002"}>]
+
+= Callbacks
+
+For now, the available callbacks are: after_initialize, before_save, after_save
+
+= Validations
+
+All the validation methods defined in ActiveModel::Validations are included
+
+= Dirty
+
+All the dirty object methods defined in ActiveModel::Dirty are included
+
+= TODO
+
+ * Add helpers to define attributes as referenced objects
+ * Increase rspec coverage
+ * Document, document, document!
+ * Create useful modules to make common operations easier (versioning, localization, etc)
+
+= Copyright
+
+Copyright © 2010 Carlos Paramio. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,70 @@
+require 'rubygems'
+require 'rake'
+
+## gem building
+require File.dirname(__FILE__) + "/lib/mongo_odm/version.rb"
+if Gem.available? 'jeweler'
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "mongo_odm"
+    gemspec.summary = "mongo_odm is a flexible persistence module for any Ruby class to MongoDB."
+    gemspec.description = "mongo_odm is a flexible persistence module for any Ruby class to MongoDB."
+    gemspec.email = "carlos@evolve.st"
+    gemspec.homepage = "http://github.com/carlosparamio/mongo_odm"
+    gemspec.authors = ["Carlos Paramio"]
+    gemspec.files =  FileList["[A-Z]*", "{lib,spec}/**/*"]
+    gemspec.version = MongoODM::VERSION
+    gemspec.add_dependency 'activesupport', ['3.0.0.beta3']
+    gemspec.add_dependency 'activemodel', ['3.0.0.beta3']
+    gemspec.add_dependency 'mongo', ['1.0.1']
+    gemspec.add_dependency 'bson', ['1.0.1']
+    gemspec.add_dependency 'bson_ext', ['1.0.1']
+  end
+  Jeweler::GemcutterTasks.new
+else
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: gem install jeweler"
+end
+
+## rspec tasks
+if Gem.available? 'rspec'
+  require 'spec/rake/spectask'
+  desc "Run all specs"
+  Spec::Rake::SpecTask.new('spec') do |t|
+    t.spec_files = FileList['spec/**/*_spec.rb']
+  end
+  
+  ## rcov task
+  if Gem.available? 'rcov'
+    require 'rcov/rcovtask'
+    Spec::Rake::SpecTask.new(:rcov) do |spec|
+      spec.libs << "lib" << "spec"
+      spec.pattern = "spec/**/*_spec.rb"
+      spec.spec_opts = ["--options", "spec/spec.opts"]
+      spec.rcov = true
+    end
+  end
+else
+  puts "WARNING: Install rspec to run tests"
+end
+
+## yard task
+if Gem.available? 'yard'
+  require 'yard'
+  YARD::Rake::YardocTask.new do |yard|
+    docfiles = FileList['lib/**/*.rb', 'README.rdoc']
+    yard.files = docfiles
+    yard.options = ["--no-private"]
+  end
+end
+
+task :release => :build do
+  puts "Tagging #{MongoODM::VERSION}..."
+  system "git tag -a #{MongoODM::VERSION} -m 'Release #{MongoODM::VERSION}'"
+  puts "Pushing to Github..."
+  system "git push --tags"
+  puts "Pushing to Gemcutter..."
+  system "gem push pkg/mongo_odm-#{MongoODM::VERSION}.gem"
+end
+
+## default task
+task :default => :spec

data/lib/mongo_odm.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+require 'rubygems'
+require 'mongo'
+require 'active_support'
+require 'active_model'
+
+# Contains the classes and modules related to the ODM built on top of the basic Mongo client.
+module MongoODM
+
+  extend ActiveSupport::Autoload
+  include ActiveSupport::Configurable
+
+  autoload :VERSION
+  autoload :Cursor
+  autoload :Collection
+  autoload :Document
+  autoload :Errors
+  
+  def self.connection
+    Thread.current[:mongo_odm_connection] ||= Mongo::Connection.new(config[:host], config[:port], config)
+  end
+  
+  def self.connection=(value)
+    Thread.current[:mongo_odm_connection] = value
+  end
+  
+  def self.database
+    connection.db(config[:database] || 'test')
+  end
+  
+  def self.config=(value)
+    self.connection = nil
+    super
+  end
+  
+  def self.instanciate(value)
+    return nil if value.nil?
+    return instanciate_doc(value) if value.is_a?(Hash)
+    return value if value.class.included_modules.include?(MongoODM::Document)
+    value.class.type_cast(value.to_mongo)
+  end
+  
+  def self.instanciate_doc(doc)
+    return doc if doc["_class"].nil?
+    doc["_class"].constantize.new(doc)
+  end
+
+end

data/lib/mongo_odm/collection.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+module MongoODM
+
+  class Collection < Mongo::Collection
+    def find(selector={}, opts={})
+      fields = opts.delete(:fields)
+      fields = ["_id"] if fields && fields.empty?
+      skip   = opts.delete(:skip) || skip || 0
+      limit  = opts.delete(:limit) || 0
+      sort   = opts.delete(:sort)
+      hint   = opts.delete(:hint)
+      snapshot = opts.delete(:snapshot)
+      batch_size = opts.delete(:batch_size)
+      if opts[:timeout] == false && !block_given?
+        raise ArgumentError, "Timeout can be set to false only when #find is invoked with a block."
+      end
+      timeout = block_given? ? (opts.delete(:timeout) || true) : true
+      if hint
+        hint = normalize_hint_fields(hint)
+      else
+        hint = @hint        # assumed to be normalized already
+      end
+      raise RuntimeError, "Unknown options [#{opts.inspect}]" unless opts.empty?
+
+      cursor = MongoODM::Cursor.new(self, :selector => selector, :fields => fields, :skip => skip, :limit => limit,
+                          :order => sort, :hint => hint, :snapshot => snapshot, :timeout => timeout, :batch_size => batch_size)
+      if block_given?
+        yield cursor
+        cursor.close()
+        nil
+      else
+        cursor
+      end
+    end
+    
+    def insert(doc_or_docs, options={})
+      doc_or_docs = [doc_or_docs] unless doc_or_docs.is_a?(Array)
+      super doc_or_docs.map{|doc| doc.respond_to?(:to_mongo) ? doc.to_mongo : doc}
+    end
+  end
+
+end