mongo_mapper-rails3 0.7.0.1

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,15 @@
+source :gemcutter
+
+gem 'activesupport', '>= 3.0.0.beta'
+gem "activemodel", ">= 3.0.0.beta"
+gem "mongo", ">= 0.18.2"
+gem "mongo_ext", ">= 0.18.2"
+gem "yard", ">= 0.5.0"
+gem "jeweler", ">= 1.4.0"
+
+group :test do
+  gem 'jnunemaker-matchy', '0.4.0'
+  gem 'shoulda', '2.10.2'
+  gem 'timecop', '0.3.1'
+  gem 'mocha', '0.9.8'
+end

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,60 @@
+= MongoMapper (Rails 3 Fork)
+
+== Updated to work on Rails3
+
+=== To Install
+
+This project is a fork of MongoMapper that works with Rails3. To install the gem run:
+ 
+  gem install `mongo_mapper-rails3`
+
+To use with Rails3 / Bundler, add this to your Gemfile:
+
+  gem "mongo_mapper-rails3", :require => "mongo_mapper"
+
+Then run:
+
+  bundle install
+
+
+If not using bundler, you can just clone it to your projects vendor/plugins folder.
+
+
+=== Bugs / Issues
+
+Please report all Rails 3 bugs via the Github Issue tracker associated with this fork (merbjedi/mongomapper).
+
+=== Commit access
+
+Want to make changes? Either fork this repo or just msg me for direct commit access to my fork.
+
+Would greatly appreciate your help. Thanks!
+
+
+== Original README
+
+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
+
+=== Problems or Questions?
+
+Hit up the google group.
+http://groups.google.com/group/mongomapper
+
+To see if the problem you are having is a verified issue, you can see the MM pivotal tracker project:
+http://www.pivotaltracker.com/projects/33576
+
+=== Copyright
+
+Copyright (c) 2009 John Nunemaker. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,58 @@
+require 'rubygems'
+require 'rake'
+require 'jeweler'
+require 'yard'
+require 'yard/rake/yardoc_task'
+
+Jeweler::Tasks.new do |gem|
+  gem.name        = "mongo_mapper-rails3"
+  gem.summary     = %Q{Rails3 / ActiveModel compatible fork of MongoMapper.}
+  gem.email       = "merbjedi@gmail.com"
+  gem.homepage    = "http://github.com/merbjedi/mongomapper"
+  gem.authors     = ["Mike Harris", "Paul Bowsher", "Jacques Crocker", "John Nunemaker"]
+  
+  gem.add_dependency('activesupport', '>= 3.0.0.beta')
+  gem.add_dependency('activemodel', '>= 3.0.0.beta')
+  gem.add_dependency('bundler', '>= 0.9.7')
+  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')
+  gem.add_development_dependency('yard', '>= 0.5.3')
+  gem.add_development_dependency('jeweler', '>= 1.4.0')
+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.7.0.1

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,131 @@
+require 'set'
+
+begin
+  # Require the preresolved locked set of gems.
+  require File.expand_path('../.bundle/environment', __FILE__)
+rescue LoadError
+  # Fallback on doing the resolve at runtime.
+  require "rubygems"
+  require "bundler"
+  Bundler.setup
+end
+
+require "active_model"
+require "active_model/callbacks"
+require "active_model/conversion"
+require "active_model/deprecated_error_methods"
+require "active_model/errors"
+require "active_model/naming"
+require "active_model/serialization"
+require "active_model/translation"
+require "active_model/validator"
+require "active_model/validations"
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/hash'
+require 'active_support/core_ext/object/try'
+require 'active_support/core_ext/module'
+
+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
+
+  def self.config=(hash)
+    @@config = hash
+  end
+
+  def self.config
+    raise 'Set config before connecting. MongoMapper.config = {...}' unless defined?(@@config)
+    @@config
+  end
+
+  def self.connect(environment, options={})
+    raise 'Set config before connecting. MongoMapper.config = {...}' if config.blank?
+    MongoMapper.connection = Mongo::Connection.new(config[environment]['host'], config[environment]['port'], options)
+    MongoMapper.database = config[environment]['database']
+    if config[environment]['username'].present? && config[environment]['password'].present?
+      MongoMapper.database.authenticate(config[environment]['username'], config[environment]['password'])
+    end
+  end
+
+  def self.setup(config, environment, options={})
+    using_passenger = options.delete(:passenger)
+    handle_passenger_forking if using_passenger
+    self.config = config
+    connect(environment, options)
+  end
+
+  def self.handle_passenger_forking
+    if defined?(PhusionPassenger)
+      PhusionPassenger.on_event(:starting_worker_process) do |forked|
+        connection.connect_to_master if forked
+      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
+
+  # @api private
+  def self.normalize_object_id(value)
+    value.is_a?(String) ? Mongo::ObjectID.from_string(value) : value
+  end
+
+  autoload :Query,            'mongo_mapper/query'
+  autoload :Document,         'mongo_mapper/document'
+  autoload :EmbeddedDocument, 'mongo_mapper/embedded_document'
+end
+
+require 'mongo_mapper/support'
+require 'mongo_mapper/plugins'

data/lib/mongo_mapper/document.rb

@@ -0,0 +1,439 @@
+module MongoMapper
+  module Document
+    extend Support::DescendantAppends
+    extend ActiveSupport::Concern
+    
+    included do
+      include InstanceMethods
+      include ActiveModel::Conversion
+      extend  Support::Find
+      extend  ClassMethods
+      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
+      
+      extend Plugins::Validations::DocumentMacros
+    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
+
+        collection.create_index(keys_to_index, options[:unique])
+      end
+
+      def find(*args)
+        assert_no_first_last_or_all(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)
+        assert_no_first_last_or_all(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_each(options={})
+        criteria, options = to_query(options)
+        collection.find(criteria, options).each do |doc|
+          yield load(doc)
+        end
+      end
+
+      def find_by_id(id)
+        find(id)
+      end
+
+      def first_or_create(arg)
+        first(arg) || create(arg)
+      end
+
+      def first_or_new(arg)
+        first(arg) || new(arg)
+      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={})
+        find_each(options) { |document| document.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 assert_no_first_last_or_all(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_query(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_query(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={})
+          Query.new(self, options).criteria
+        end
+
+        def to_query(options={})
+          Query.new(self, options).to_a
+        end
+    end
+
+    module InstanceMethods
+      def initialize(attrs={}, from_database=false)
+        unless attrs.nil?
+          provided_keys = attrs.keys.map { |k| k.to_s }
+          unless provided_keys.include?('_id') || provided_keys.include?('id')
+            write_key :_id, Mongo::ObjectID.new
+          end
+        end
+        
+        #here for ActiveModel compatibility, should do something real with this
+        def destroyed?
+          false
+        end
+
+        assign_type_if_present
+
+        if from_database
+          @new = false
+          self.attributes = attrs
+        else
+          @new = true
+          assign(attrs)
+        end
+      end
+      
+      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 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[: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