novelys_mongo_mapper 0.6.10

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,38 @@
+= 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
+ 
+ $ gem install mongo_mapper
+
+== 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://groups.google.com/group/mongomapper
+
+== More Info
+
+* http://www.mongodb.org/
+* http://github.com/mongodb/mongo-ruby-driver/
+
+== Copyright
+
+Copyright (c) 2009 John Nunemaker. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'rake'
+require 'jeweler'
+require 'yard'
+require 'yard/rake/yardoc_task'
+
+Jeweler::Tasks.new do |gem|
+  gem.name        = "novelys_mongo_mapper"
+  gem.summary     = %Q{Fork of MongoMapper with Rails 3 patches}
+  gem.email       = "nicolas.blanco@novelys.com"
+  gem.homepage    = "http://github.com/novelys/mongomapper"
+  gem.authors     = ["John Nunemaker", "Nicolas Blanco"]
+  
+  gem.add_dependency('activesupport', '>= 2.3')
+  gem.add_dependency('mongo', '0.18.3')
+  
+  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.10

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,124 @@
+require 'set'
+
+# if Gem is defined i'll assume you are using rubygems and lock specific versions
+# call me crazy but a plain old require will just get the latest version you have installed
+# so i want to make sure that if you are using gems you do in fact have the correct versions
+# if there is a better way to do this, please enlighten me!
+if self.class.const_defined?(:Gem)
+  gem 'activesupport', '>= 2.3'
+  gem 'mongo', '0.18.3'
+end
+
+require 'active_support'
+require 'mongo'
+
+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.ensured_indexes=(value)
+    @@ensured_indexes = value
+  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
+  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
+  
+  # @api private
+  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/finder_options'
+require 'mongo_mapper/dynamic_finder'
+require 'mongo_mapper/descendant_appends'
+
+require 'mongo_mapper/plugins'
+require 'mongo_mapper/plugins/associations'
+require 'mongo_mapper/plugins/callbacks'
+require 'mongo_mapper/plugins/clone'
+require 'mongo_mapper/plugins/descendants'
+require 'mongo_mapper/plugins/dirty'
+require 'mongo_mapper/plugins/equality'
+require 'mongo_mapper/plugins/identity_map'
+require 'mongo_mapper/plugins/inspect'
+require 'mongo_mapper/plugins/keys'
+require 'mongo_mapper/plugins/logger'
+require 'mongo_mapper/plugins/pagination'
+require 'mongo_mapper/plugins/protected'
+require 'mongo_mapper/plugins/rails'
+require 'mongo_mapper/plugins/serialization'
+require 'mongo_mapper/plugins/validations'
+
+require 'mongo_mapper/document'
+require 'mongo_mapper/embedded_document'

data/lib/mongo_mapper/descendant_appends.rb

@@ -0,0 +1,44 @@
+module MongoMapper
+  module DescendantAppends
+    def included(model)
+      extra_extensions.each { |extension| model.extend(extension) }
+      extra_inclusions.each { |inclusion| model.send(:include, inclusion) }
+      descendants << model
+    end
+    
+    # @api public
+    def descendants
+      @descendants ||= Set.new
+    end
+
+    # @api public
+    def append_extensions(*extensions)
+      extra_extensions.concat extensions
+
+      # Add the extension to existing descendants
+      descendants.each do |model|
+        extensions.each { |extension| model.extend(extension) }
+      end
+    end
+
+    # @api public
+    def append_inclusions(*inclusions)
+      extra_inclusions.concat inclusions
+
+      # Add the inclusion to existing descendants
+      descendants.each do |model|
+        inclusions.each { |inclusion| model.send(:include, inclusion) }
+      end
+    end
+
+    # @api private
+    def extra_extensions
+      @extra_extensions ||= []
+    end
+
+    # @api private
+    def extra_inclusions
+      @extra_inclusions ||= []
+    end
+  end
+end

data/lib/mongo_mapper/document.rb

@@ -0,0 +1,423 @@
+module MongoMapper
+  module Document
+    extend DescendantAppends
+
+    def self.included(model)
+      model.class_eval do
+        include InstanceMethods
+        extend  ClassMethods
+        extend  Finders
+        extend Plugins
+
+        plugin Plugins::Associations
+        plugin Plugins::Clone
+        plugin Plugins::Descendants
+        plugin Plugins::Equality
+        plugin Plugins::Inspect
+        plugin Plugins::Keys
+        plugin Plugins::Dirty # for now dirty needs to be after keys
+        plugin Plugins::Logger
+        plugin Plugins::Pagination
+        plugin Plugins::Protected
+        plugin Plugins::Rails
+        plugin Plugins::Serialization
+        plugin Plugins::Validations
+        plugin Plugins::Callbacks # for now callbacks needs to be after validations
+        
+        extend Plugins::Validations::DocumentMacros
+      end
+      
+      super
+    end
+    
+    module ClassMethods
+      def inherited(subclass)
+        subclass.set_collection_name(collection_name)
+        super
+      end
+
+      def ensure_index(name_or_array, options={})
+        keys_to_index = if name_or_array.is_a?(Array)
+          name_or_array.map { |pair| [pair[0], pair[1]] }
+        else
+          name_or_array
+        end
+
+        MongoMapper.ensure_index(self, keys_to_index, options)
+      end
+
+      def find(*args)
+        find_all_first_last_error(args)
+        options = args.extract_options!
+        return nil if args.size == 0
+
+        if args.first.is_a?(Array) || args.size > 1
+          find_some(args, options)
+        else
+          find_one(options.merge({:_id => args[0]}))
+        end
+      end
+
+      def find!(*args)
+        find_all_first_last_error(args)
+        options = args.extract_options!
+        raise DocumentNotFound, "Couldn't find without an ID" if args.size == 0
+
+        if args.first.is_a?(Array) || args.size > 1
+          find_some!(args, options)
+        else
+          find_one(options.merge({:_id => args[0]})) || raise(DocumentNotFound, "Document match #{options.inspect} does not exist in #{collection.name} collection")
+        end
+      end
+
+      def find_or_create(arg)
+        first(arg) || create(arg)
+      end
+
+      def find_each(options={})
+        criteria, options = to_finder_options(options)
+        collection.find(criteria, options).each do |doc|
+          yield load(doc)
+        end
+      end
+
+      def find_by_id(id)
+        find(id)
+      end
+
+      def first(options={})
+        find_one(options)
+      end
+
+      def last(options={})
+        raise ':order option must be provided when using last' if options[:order].blank?
+        find_one(options.merge(:order => invert_order_clause(options[:order])))
+      end
+
+      def all(options={})
+        find_many(options)
+      end
+
+      def count(options={})
+        collection.find(to_criteria(options)).count
+      end
+
+      def exists?(options={})
+        !count(options).zero?
+      end
+
+      def create(*docs)
+        initialize_each(*docs) { |doc| doc.save }
+      end
+
+      def create!(*docs)
+        initialize_each(*docs) { |doc| doc.save! }
+      end
+
+      def update(*args)
+        if args.length == 1
+          update_multiple(args[0])
+        else
+          id, attributes = args
+          update_single(id, attributes)
+        end
+      end
+
+      def delete(*ids)
+        collection.remove(to_criteria(:_id => ids.flatten))
+      end
+
+      def delete_all(options={})
+        collection.remove(to_criteria(options))
+      end
+
+      def destroy(*ids)
+        find_some!(ids.flatten).each(&:destroy)
+      end
+
+      def destroy_all(options={})
+        all(options).each(&:destroy)
+      end
+      
+      def increment(*args)
+        modifier_update('$inc', args)
+      end
+      
+      def decrement(*args)
+        criteria, keys = criteria_and_keys_from_args(args)
+        values, to_decrement = keys.values, {}
+        keys.keys.each_with_index { |k, i| to_decrement[k] = -values[i].abs }
+        collection.update(criteria, {'$inc' => to_decrement}, :multi => true)
+      end
+      
+      def set(*args)
+        modifier_update('$set', args)
+      end
+      
+      def push(*args)
+        modifier_update('$push', args)
+      end
+      
+      def push_all(*args)
+        modifier_update('$pushAll', args)
+      end
+      
+      def push_uniq(*args)
+        criteria, keys = criteria_and_keys_from_args(args)
+        keys.each { |key, value | criteria[key] = {'$ne' => value} }
+        collection.update(criteria, {'$push' => keys}, :multi => true)
+      end
+      
+      def pull(*args)
+        modifier_update('$pull', args)
+      end
+      
+      def pull_all(*args)
+        modifier_update('$pullAll', args)
+      end
+      
+      def pop(*args)
+        modifier_update('$pop', args)
+      end
+
+      def embeddable?
+        false
+      end
+
+      def connection(mongo_connection=nil)
+        if mongo_connection.nil?
+          @connection ||= MongoMapper.connection
+        else
+          @connection = mongo_connection
+        end
+        @connection
+      end
+
+      def set_database_name(name)
+        @database_name = name
+      end
+      
+      def database_name
+        @database_name
+      end
+
+      def database
+        if database_name.nil?
+          MongoMapper.database
+        else
+          connection.db(database_name)
+        end
+      end
+
+      def set_collection_name(name)
+        @collection_name = name
+      end
+
+      def collection_name
+        @collection_name ||= self.to_s.tableize.gsub(/\//, '.')
+      end
+
+      def collection
+        database.collection(collection_name)
+      end
+
+      def timestamps!
+        key :created_at, Time
+        key :updated_at, Time
+        class_eval { before_save :update_timestamps }
+      end
+
+      def userstamps!
+        key :creator_id, ObjectId
+        key :updater_id, ObjectId
+        belongs_to :creator, :class_name => 'User'
+        belongs_to :updater, :class_name => 'User'
+      end
+
+      def single_collection_inherited?
+        keys.key?(:_type) && single_collection_inherited_superclass?
+      end
+
+      def single_collection_inherited_superclass?
+        superclass.respond_to?(:keys) && superclass.keys.key?(:_type)
+      end
+
+      private
+        def initialize_each(*docs)
+          instances = []
+          docs = [{}] if docs.blank?
+          docs.flatten.each do |attrs|
+            doc = new(attrs)
+            yield(doc)
+            instances << doc
+          end
+          instances.size == 1 ? instances[0] : instances
+        end
+
+        def modifier_update(modifier, args)
+          criteria, keys = criteria_and_keys_from_args(args)
+          modifiers = {modifier => keys}
+          collection.update(criteria, modifiers, :multi => true)
+        end
+
+        def criteria_and_keys_from_args(args)
+          keys     = args.pop
+          criteria = args[0].is_a?(Hash) ? args[0] : {:id => args}
+          [to_criteria(criteria), keys]
+        end
+
+        def find_all_first_last_error(args)
+          if args[0] == :first || args[0] == :last || args[0] == :all
+            raise ArgumentError, "#{self}.find(:#{args}) is no longer supported, use #{self}.#{args} instead."
+          end
+        end
+
+        def find_some(ids, options={})
+          ids = ids.flatten.compact.uniq
+          find_many(options.merge(:_id => ids)).compact
+        end
+        
+        def find_some!(ids, options={})
+          ids = ids.flatten.compact.uniq
+          documents = find_some(ids, options)
+          
+          if ids.size == documents.size
+            documents
+          else
+            raise DocumentNotFound, "Couldn't find all of the ids (#{ids.to_sentence}). Found #{documents.size}, but was expecting #{ids.size}"
+          end
+        end
+
+        # All query methods that load documents pass through find_one or find_many
+        def find_one(options={})
+          criteria, options = to_finder_options(options)
+          if doc = collection.find_one(criteria, options)
+            load(doc)
+          end
+        end
+
+        # All query methods that load documents pass through find_one or find_many
+        def find_many(options)
+          criteria, options = to_finder_options(options)
+          collection.find(criteria, options).to_a.map do |doc|
+            load(doc)
+          end
+        end
+
+        def invert_order_clause(order)
+          order.split(',').map do |order_segment|
+            if order_segment =~ /\sasc/i
+              order_segment.sub /\sasc/i, ' desc'
+            elsif order_segment =~ /\sdesc/i
+              order_segment.sub /\sdesc/i, ' asc'
+            else
+              "#{order_segment.strip} desc"
+            end
+          end.join(',')
+        end
+
+        def update_single(id, attrs)
+          if id.blank? || attrs.blank? || !attrs.is_a?(Hash)
+            raise ArgumentError, "Updating a single document requires an id and a hash of attributes"
+          end
+
+          doc = find(id)
+          doc.update_attributes(attrs)
+          doc
+        end
+
+        def update_multiple(docs)
+          unless docs.is_a?(Hash)
+            raise ArgumentError, "Updating multiple documents takes 1 argument and it must be hash"
+          end
+
+          instances = []
+          docs.each_pair { |id, attrs| instances << update(id, attrs) }
+          instances
+        end
+
+        def to_criteria(options={})
+          FinderOptions.new(self, options).criteria
+        end
+
+        def to_finder_options(options={})
+          FinderOptions.new(self, options).to_a
+        end
+    end
+
+    module InstanceMethods
+      def collection
+        self.class.collection
+      end
+
+      def database
+        self.class.database
+      end
+
+      def save(options={})
+        options.assert_valid_keys(:validate, :safe)
+        options.reverse_merge!(:validate => true)
+        !options[:validate] || valid? ? create_or_update(options) : false
+      end
+
+      def save!(options={})
+        options.assert_valid_keys(:safe)
+        save(options) || raise(DocumentNotValid.new(self))
+      end
+      
+      def update_attributes(attrs={})
+        self.attributes = attrs
+        save
+      end
+
+      def update_attributes!(attrs={})
+        self.attributes = attrs
+        save!
+      end
+
+      def destroy
+        delete
+      end
+      
+      def delete
+        self.class.delete(id) unless new?
+      end
+
+      def reload
+        if attrs = collection.find_one({:_id => _id})
+          self.class.associations.each { |name, assoc| send(name).reset if respond_to?(name) }
+          self.attributes = attrs
+          self
+        else
+          raise DocumentNotFound, "Document match #{_id.inspect} does not exist in #{collection.name} collection"
+        end
+      end
+
+    private
+      def create_or_update(options={})
+        result = new? ? create(options) : update(options)
+        result != false
+      end
+
+      def create(options={})
+        save_to_collection(options)
+      end
+
+      def update(options={})
+        save_to_collection(options)
+      end
+
+      def save_to_collection(options={})
+        safe = options.delete(:safe) || false
+        @new = false
+        collection.save(to_mongo, :safe => safe)
+      end
+
+      def update_timestamps
+        now = Time.now.utc
+        self[:created_at] = now if new? && !created_at?
+        self[:updated_at] = now
+      end
+    end
+  end # Document
+end # MongoMapper