webbynode-mongo_mapper 0.6.4

data/.gitignore

@@ -0,0 +1,10 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg
+*~
+*.gem
+tmp
+.yardoc
+doc/*

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 John Nunemaker
+
+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,53 @@
+= MongoMapper
+
+Awesome gem for modeling your domain and storing it in mongo.
+
+Releases are tagged on github and released on gemcutter. Master is pushed to whenever I add a patch or a new feature, but I do not release a new gem version each time I push.
+
+== Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a future version unintentionally.
+* Commit, do not mess with rakefile, version, or history. (if you want to have your own version, that is fine but bump version in a commit by itself in another branch so I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Install
+
+MongoMapper is only released on gemcutter. To install, you can setup gemcutter as your default gem source.
+
+ $ gem install gemcutter
+ $ gem tumble
+ 
+Then you can install MM:
+ 
+ $ gem install mongo_mapper
+
+You can also just declare the source:
+
+ $ gem install mongo_mapper -s http://gemcutter.org
+
+== Dependencies
+
+* ActiveSupport (typically the latest version)
+* Mongo Ruby Driver (mongo)
+* My fork of the validatable gem (jnunemaker-validatable)
+
+== Documentation
+
+Documentation is lacking right now because if you can't look through the code right now and feel comfortable, this is probably too young for you to use. Wait til it stabilizes a bit more.
+
+http://rdoc.info/projects/jnunemaker/mongomapper
+http://groups.google.com/group/mongomapper
+
+== More Info
+
+You can learn more about mongo here:
+http://www.mongodb.org/
+
+You can learn more about the mongo ruby driver here:
+http://github.com/mongodb/mongo-ruby-driver/tree/master
+
+== Copyright
+
+Copyright (c) 2009 John Nunemaker. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,55 @@
+require 'rubygems'
+require 'rake'
+require 'jeweler'
+require 'yard'
+require 'yard/rake/yardoc_task'
+
+Jeweler::Tasks.new do |gem|
+  gem.name        = "webbynode-mongo_mapper"
+  gem.summary     = %Q{Awesome gem for modeling your domain and storing it in mongo}
+  gem.email       = "nunemaker@gmail.com"
+  gem.homepage    = "http://github.com/jnunemaker/mongomapper"
+  gem.authors     = ["John Nunemaker", "Felipe Coury"]
+  
+  gem.add_dependency('activesupport', '>= 2.3')
+  gem.add_dependency('mongo', '0.17.1')
+  gem.add_dependency('jnunemaker-validatable', '1.8.1')
+  
+  gem.add_development_dependency('jnunemaker-matchy', '0.4.0')
+  gem.add_development_dependency('shoulda', '2.10.2')
+  gem.add_development_dependency('timecop', '0.3.1')
+  gem.add_development_dependency('mocha', '0.9.8')
+end
+
+Jeweler::GemcutterTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'test'
+  test.ruby_opts << '-rubygems'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+namespace :test do
+  Rake::TestTask.new(:units) do |test|
+    test.libs << 'test'
+    test.ruby_opts << '-rubygems'
+    test.pattern = 'test/unit/**/test_*.rb'
+    test.verbose = true
+  end
+  
+  Rake::TestTask.new(:functionals) do |test|
+    test.libs << 'test'
+    test.ruby_opts << '-rubygems'
+    test.pattern = 'test/functional/**/test_*.rb'
+    test.verbose = true
+  end
+end
+
+task :default  => :test
+task :test     => :check_dependencies
+
+YARD::Rake::YardocTask.new(:doc) do |t|
+  t.options = ["--legacy"] if RUBY_VERSION < "1.9.0"
+end

data/VERSION

@@ -0,0 +1 @@
+0.6.4

data/bin/mmconsole

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+begin
+  require 'mongo_mapper'
+  require 'irb'
+rescue LoadError
+  require 'rubygems'
+  retry
+end
+
+IRB.setup(nil)
+irb = IRB::Irb.new
+
+IRB.conf[:MAIN_CONTEXT] = irb.context
+
+irb.context.evaluate("require 'irb/completion'", 0)
+irb.context.evaluate(%@
+include MongoMapper
+
+MongoMapper.database = "mmtest"
+$db = MongoMapper.database
+
+@, 0)
+
+puts %@
+Welcome to the MongoMapper Console!
+
+Example 1:
+  things = $db.collection("things")
+  things.insert("name" => "Raw Thing")
+  things.insert("name" => "Another Thing", "date" => Time.now)
+
+  cursor = things.find("name" => "Raw Thing")
+  puts cursor.next_object.inspect
+
+Example 2:
+  class Thing
+    include MongoMapper::Document
+    key :name, String, :required => true
+    key :date, Time
+  end
+
+  thing = Thing.new
+  thing.name = "My thing"
+  thing.date = Time.now
+  thing.save
+
+  all_things = Thing.all
+  puts all_things.map { |object| object.name }.inspect
+@
+
+trap("SIGINT") do
+  irb.signal_handle
+end
+
+catch(:IRB_EXIT) do
+  irb.eval_input
+end
+

data/lib/mongo_mapper.rb

@@ -0,0 +1,134 @@
+require 'active_support'
+require 'mongo'
+require 'validatable'
+
+module MongoMapper
+  # generic MM error
+  class MongoMapperError < StandardError; end
+  
+  # raised when key expected to exist but not found
+  class KeyNotFound < MongoMapperError; end
+  
+  # raised when document expected but not found
+  class DocumentNotFound < MongoMapperError; end
+  
+  # raised when document not valid and using !
+  class DocumentNotValid < MongoMapperError
+    def initialize(document)
+      super("Validation failed: #{document.errors.full_messages.join(", ")}")
+    end
+  end
+  
+  # @api public
+  def self.connection
+    @@connection ||= Mongo::Connection.new
+  end
+  
+  # @api public
+  def self.connection=(new_connection)
+    @@connection = new_connection
+  end
+  
+  # @api public
+  def self.logger
+    connection.logger
+  end
+  
+  # @api public
+  def self.database=(name)
+    @@database = nil
+    @@database_name = name
+  end
+  
+  # @api public
+  def self.database
+    if @@database_name.blank?
+      raise 'You forgot to set the default database name: MongoMapper.database = "foobar"'
+    end
+    
+    @@database ||= MongoMapper.connection.db(@@database_name)
+  end
+  
+  # @api private
+  def self.ensured_indexes
+    @@ensured_indexes ||= []
+  end
+  
+  # @api private
+  def self.ensure_index(klass, keys, options={})
+    ensured_indexes << {:klass => klass, :keys => keys, :options => options}
+  end
+  
+  # @api public
+  def self.ensure_indexes!
+    ensured_indexes.each do |index|
+      unique = index[:options].delete(:unique)
+      index[:klass].collection.create_index(index[:keys], unique)
+    end
+  end
+  
+  # @api private
+  module Finders
+    def dynamic_find(finder, args)
+      attributes = {}
+      finder.attributes.each_with_index do |attr, index|
+        attributes[attr] = args[index]
+      end
+      
+      options = args.extract_options!.merge(attributes)
+      result  = find(finder.finder, options)
+
+      if result.nil?
+        if finder.bang
+          raise DocumentNotFound, "Couldn't find Document with #{attributes.inspect} in collection named #{collection.name}"
+        end
+
+        if finder.instantiator
+          self.send(finder.instantiator, attributes)
+        end
+      else
+        result
+      end
+    end
+  end
+  
+  # @api private
+  def self.use_time_zone?
+    Time.respond_to?(:zone) && Time.zone ? true : false
+  end
+  
+  # @api private
+  def self.time_class
+    use_time_zone? ? Time.zone : Time
+  end
+  
+  def self.normalize_object_id(value)
+    value.is_a?(String) ? Mongo::ObjectID.from_string(value) : value
+  end
+end
+
+require 'mongo_mapper/support'
+require 'mongo_mapper/associations'
+require 'mongo_mapper/associations/base'
+require 'mongo_mapper/associations/proxy'
+require 'mongo_mapper/associations/many_documents_proxy'
+require 'mongo_mapper/associations/belongs_to_proxy'
+require 'mongo_mapper/associations/belongs_to_polymorphic_proxy'
+require 'mongo_mapper/associations/many_proxy'
+require 'mongo_mapper/associations/many_polymorphic_proxy'
+require 'mongo_mapper/associations/many_embedded_proxy'
+require 'mongo_mapper/associations/many_embedded_polymorphic_proxy'
+require 'mongo_mapper/associations/many_documents_as_proxy'
+require 'mongo_mapper/callbacks'
+require 'mongo_mapper/finder_options'
+require 'mongo_mapper/dirty'
+require 'mongo_mapper/dynamic_finder'
+require 'mongo_mapper/key'
+require 'mongo_mapper/observing'
+require 'mongo_mapper/pagination'
+require 'mongo_mapper/serialization'
+require 'mongo_mapper/validations'
+require 'mongo_mapper/rails_compatibility/document'
+require 'mongo_mapper/rails_compatibility/embedded_document'
+require 'mongo_mapper/embedded_document'
+require 'mongo_mapper/document'

data/lib/mongo_mapper/associations.rb

@@ -0,0 +1,183 @@
+module MongoMapper
+  module Associations
+    module ClassMethods
+      ##
+      # This macro allows you define a "belongs-to" relationship between one 
+      # document and some other document.
+      #
+      # == Requirements
+      #
+      # Usage of this macro requires that your document define a key that can 
+      # be used to store the ID of the target document that is the parent of 
+      # this document.
+      #
+      # == Conventions
+      # 
+      # The following is a list of the conventions used by MongoMapper in 
+      # defining a belongs-to relationship. Each can likely be overridden via 
+      # the +options+ parameter.
+      #
+      # * The name of your belongs-to association is the lowercase, singular 
+      #   name of the target class
+      # * A key with the name of your association exists with an "_id" suffix 
+      #   to store the ID of the target of this relationship
+      #
+      # @param [Symbol] association_id The name of this association
+      # @param [Hash] options Optional parameters that define the 
+      #   characteristics of this relationship. These are often used to 
+      #   override MongoMapper conventions.
+      # @option options [Boolean] :polymorphic (false) Set this option to 
+      #   <code>true</code> to define a relationship that can be between this 
+      #   document and any other type of document. Note that you *must* also 
+      #   have a key on your document to store the type of document in this 
+      #   relationship.
+      # @option options [String] :class_name If your relationship doesn't use 
+      #   the name of some class, you *must* use this option to indicate the 
+      #   target class for this relationship.
+      # @option options [Symbol] :foreign_key Use this option to specify a 
+      #   non-conventional key that stores the ID of the parent in this 
+      #   relationship
+      #
+      # @example Conventional, and simple, usage of <code>belongs_to</code>
+      #   class Novel
+      #     include MongoMapper::Document
+      #
+      #     key :author_id, String # our "foreign key"
+      #
+      #     belongs_to :author
+      #   end
+      #
+      # @example Using :foreign_key and :class_name
+      #   class Pet
+      #     include MongoMapper::Document
+      #
+      #     key :person_id, String
+      #
+      #     belongs_to :owner,
+      #       :foreign_key => :person_id,
+      #       :class_name  => "Person"
+      #   end
+      #
+      # @example Defining a polymorphic belongs-to relationship
+      #   class Vehicle
+      #     include MongoMapper::Document
+      #
+      #     key :owner_id,   String
+      #     key :owner_type, String
+      #
+      #     belongs_to :owner,
+      #       :polymorphic => true
+      #   end
+      #
+      # @example Non-standard polymorphic belongs-to relationship
+      #   class Vehicle
+      #     include MongoMapper::Document
+      #
+      #     key :person_id,   String
+      #     key :person_type, String
+      #
+      #     belongs_to :owner,
+      #       :polymorphic   => true,
+      #       :foreign_key   => "person_id",
+      #       :type_key_name => "person_type"
+      #   end
+      def belongs_to(association_id, options={}, &extension)
+        create_association(:belongs_to, association_id, options, &extension)
+        self
+      end
+
+      ##
+      # This macro allows you to define a "has-many" relationship between a 
+      # document, and numerous child documents.
+      #
+      # == Conventions
+      #
+      # The following is a list of the conventions used by MongoMapper in 
+      # defining this relationship. Each can likely be overridden via the 
+      # +options+ parameter.
+      #
+      # * The name of your association is the lowercase, *plural* name of the 
+      #   target class
+      # * Your target class must have a "foreign key" bearing the name of this 
+      #   class suffixed by "_id"
+      #
+      # @param [Symbol] association_id The name of this association
+      # @param [Hash] options Optional parameters that define the 
+      #   characteristics of this relationship. These are often used to 
+      #   override MongoMapper conventions.
+      # @option options [String] :class_name If your relationship doesn't use 
+      #   the name of some class, you *must* use this option to indicate the 
+      #   target class for this relationship.
+      # @option options [Symbol] :foreign_key Use this option to specify a 
+      #   non-conventional key that stores the ID of the parent in this 
+      #   relationship
+      # @option options [#to_s] :as Used when the target relationship is 
+      #   polymorphic (i.e. the +belongs_to+ has set <tt>:polymorphic</tt> to 
+      #   +true+). See examples for usage.
+      def many(association_id, options={}, &extension)
+        create_association(:many, association_id, options, &extension)
+        self
+      end
+
+      def associations
+        @associations ||= self.superclass.respond_to?(:associations) ? 
+                            self.superclass.associations : 
+                            HashWithIndifferentAccess.new
+      end
+
+      private
+        def create_association(type, name, options, &extension)
+          association = Associations::Base.new(type, name, options, &extension)
+          associations[association.name] = association
+          define_association_methods(association)
+          define_dependent_callback(association)
+          association
+        end
+
+        def define_association_methods(association)
+          define_method(association.name) do
+            get_proxy(association)
+          end
+
+          define_method("#{association.name}=") do |value|
+            get_proxy(association).replace(value)
+            value
+          end
+        end
+
+        def define_dependent_callback(association)
+          if association.options[:dependent]
+            if association.many?
+              define_dependent_callback_for_many(association)
+            end
+          end
+        end
+
+        def define_dependent_callback_for_many(association)
+          after_destroy do |doc|
+            if !association.embeddable?
+              case association.options[:dependent]
+              when :destroy
+                doc.get_proxy(association).destroy_all
+              when :delete_all
+                doc.get_proxy(association).delete_all
+              when :nullify
+                doc.get_proxy(association).nullify
+              end
+            end
+          end
+        end
+    end
+
+    module InstanceMethods
+      def get_proxy(association)
+        unless proxy = self.instance_variable_get(association.ivar)
+          proxy = association.proxy_class.new(self, association)
+          self.instance_variable_set(association.ivar, proxy) if !frozen?
+        end
+
+        proxy
+      end
+    end
+  end
+end