mongo_mapper-unstable 2010.3.8 → 2010.06.23

data/README.rdoc

@@ -2,8 +2,6 @@
 
 A Ruby Object Mapper for 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.
@@ -18,14 +16,12 @@ Releases are tagged on github and released on gemcutter. Master is pushed to whe
 
 == Problems or Questions?
 
-Hit up the google group.
+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
-
-There is no need to request to join the Pivotal Tracker project as I am only granting access to a select few (easier to keep things organized). If you have a problem, please use the mailing list. If I confirm it to be a bug, I am happy to add it to PT. Thanks!
+Hop on IRC:
+irc://chat.freenode.net/#mongomapper
 
 == Copyright
 
-Copyright (c) 2009 John Nunemaker. See LICENSE for details.
+See LICENSE for details.

data/bin/mmconsole

@@ -18,7 +18,7 @@ irb.context.evaluate("require 'irb/completion'", 0)
 irb.context.evaluate(%@
 include MongoMapper
 
-MongoMapper.database = "mmtest"
+MongoMapper.database = "mm-test"
 $db = MongoMapper.database
 
 @, 0)

data/examples/keys.rb

@@ -0,0 +1,37 @@
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+require 'mongo_mapper'
+require 'pp'
+
+MongoMapper.database = 'testing'
+
+class User
+  include MongoMapper::Document
+
+  key :first_name,  String, :required => true
+  key :last_name,   String, :required => true
+  key :token,       String, :default => lambda { 'some random string' }
+  key :age,         Integer
+  key :skills,      Array
+  key :friend_ids,  Array, :typecast => 'ObjectId'
+  timestamps!
+end
+User.collection.remove # empties collection
+
+john = User.create({
+  :first_name => 'John',
+  :last_name  => 'Nunemaker',
+  :age        => 28,
+  :skills     => ['ruby', 'mongo', 'javascript'],
+}) 
+
+steve = User.create({
+  :first_name => 'Steve',
+  :last_name  => 'Smith',
+  :age        => 29,
+  :skills     => ['html', 'css', 'javascript', 'design'],
+})
+
+john.friend_ids << steve.id.to_s # will get typecast to ObjectId
+john.save
+
+pp john

data/examples/plugins.rb

@@ -0,0 +1,41 @@
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+require 'mongo_mapper'
+require 'pp'
+
+MongoMapper.database = 'testing'
+
+# To create your own plugin, just create a module.
+module FooPlugin
+  
+  # ClassMethods module will automatically get extended
+  module ClassMethods
+    def foo
+      'Foo class method!'
+    end
+  end
+
+  # InstanceMethods module will automatically get included
+  module InstanceMethods
+    def foo
+      'Foo instance method!'
+    end
+  end
+
+  # If present, configure method will be called and passed the 
+  # model as an argument. Feel free to class_eval or add keys.
+  # if method is not present, it doesn't call it.
+  def self.configure(model)
+    puts "Configuring #{model}..."
+    model.key :foo, String
+  end
+
+end
+
+class User
+  include MongoMapper::Document
+  plugin FooPlugin
+end
+
+puts User.foo
+puts User.new.foo
+puts User.key?(:foo)

data/examples/querying.rb

@@ -0,0 +1,35 @@
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+require 'mongo_mapper'
+require 'pp'
+
+MongoMapper.database = 'testing'
+
+class User
+  include MongoMapper::Document
+  
+  key :name, String
+  key :tags, Array
+end
+User.collection.remove # empties collection
+
+User.create(:name => 'John',  :tags => %w[ruby mongo], :age => 28)
+User.create(:name => 'Bill',  :tags => %w[ruby mongo], :age => 30)
+User.create(:name => 'Frank', :tags => %w[mongo],      :age => 35)
+User.create(:name => 'Steve', :tags => %w[html5 css3], :age => 27)
+
+[
+
+  User.all(:name => 'John'),
+  User.all(:tags => %w[mongo]),
+  User.all(:tags.all => %w[ruby mongo]),
+  User.all(:age.gte => 30),
+
+  User.where(:age.gt => 27).sort(:age).all,
+  User.where(:age.gt => 27).sort(:age.desc).all,
+  User.where(:age.gt => 27).sort(:age).limit(1).all,
+  User.where(:age.gt => 27).sort(:age).skip(1).limit(1).all,
+
+].each do |result|
+  pp result
+  puts
+end

data/examples/scopes.rb

@@ -0,0 +1,52 @@
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+require 'mongo_mapper'
+require 'pp'
+
+MongoMapper.database = 'testing'
+
+class User
+  include MongoMapper::Document
+
+  # plain old vanilla scopes with fancy queries
+  scope :johns,   where(:name => 'John')
+
+  # plain old vanilla scopes with hashes
+  scope :bills, :name => 'Bill'
+
+  # dynamic scopes with parameters
+  scope :by_name,  lambda { |name| where(:name => name) }
+  scope :by_ages,  lambda { |low, high| where(:age.gte => low, :age.lte => high) }
+
+  # Yep, even plain old methods work as long as they return a query
+  def self.by_tag(tag)
+    where(:tags => tag)
+  end
+
+  # You can even make a method that returns a scope
+  def self.twenties; by_ages(20, 29) end
+
+  key :name, String
+  key :tags, Array
+end
+User.collection.remove # empties collection
+
+User.create(:name => 'John',  :tags => %w[ruby mongo], :age => 28)
+User.create(:name => 'Bill',  :tags => %w[ruby mongo], :age => 30)
+User.create(:name => 'Frank', :tags => %w[mongo],      :age => 35)
+User.create(:name => 'Steve', :tags => %w[html5 css3], :age => 27)
+
+# simple scopes
+pp User.johns.first
+pp User.bills.first
+
+# scope with arg
+pp User.by_name('Frank').first
+
+# scope with two args
+pp User.by_ages(20, 29).all
+
+# chaining class methods on scopes
+pp User.by_ages(20, 40).by_tag('ruby').all
+
+# scope made using method that returns scope
+pp User.twenties.all

data/lib/mongo_mapper/connection.rb

@@ -0,0 +1,83 @@
+# encoding: UTF-8
+require 'uri'
+
+module MongoMapper
+  module Connection
+    # @api public
+    def connection
+      @@connection ||= Mongo::Connection.new
+    end
+
+    # @api public
+    def connection=(new_connection)
+      @@connection = new_connection
+    end
+
+    # @api public
+    def logger
+      connection.logger
+    end
+
+    # @api public
+    def database=(name)
+      @@database = nil
+      @@database_name = name
+    end
+
+    # @api public
+    def 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 config=(hash)
+      @@config = hash
+    end
+
+    def config
+      raise 'Set config before connecting. MongoMapper.config = {...}' unless defined?(@@config)
+      @@config
+    end
+
+    # @api private
+    def config_for_environment(environment)
+      env = config[environment]
+      return env if env['uri'].blank?
+
+      uri = URI.parse(env['uri'])
+      raise InvalidScheme.new('must be mongodb') unless uri.scheme == 'mongodb'
+      {
+        'host'     => uri.host,
+        'port'     => uri.port,
+        'database' => uri.path.gsub(/^\//, ''),
+        'username' => uri.user,
+        'password' => uri.password,
+      }
+    end
+
+    def connect(environment, options={})
+      raise 'Set config before connecting. MongoMapper.config = {...}' if config.blank?
+      env = config_for_environment(environment)
+      MongoMapper.connection = Mongo::Connection.new(env['host'], env['port'], options)
+      MongoMapper.database = env['database']
+      MongoMapper.database.authenticate(env['username'], env['password']) if env['username'] && env['password']
+    end
+
+    def setup(config, environment, options={})
+      handle_passenger_forking
+      self.config = config
+      connect(environment, options)
+    end
+
+    def handle_passenger_forking
+      if defined?(PhusionPassenger)
+        PhusionPassenger.on_event(:starting_worker_process) do |forked|
+          connection.connect_to_master if forked
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/document.rb

@@ -1,359 +1,41 @@
+# encoding: UTF-8
 module MongoMapper
   module Document
     extend Support::DescendantAppends
 
     def self.included(model)
       model.class_eval do
-        include InstanceMethods
-        extend  Support::Find
-        extend  ClassMethods
         extend  Plugins
 
+        plugin Plugins::Document
+        plugin Plugins::Querying # for now needs to be before associations (save_to_collection)
         plugin Plugins::Associations
+        plugin Plugins::Caching
         plugin Plugins::Clone
         plugin Plugins::Descendants
+        plugin Plugins::DynamicQuerying
         plugin Plugins::Equality
         plugin Plugins::Inspect
+        plugin Plugins::Indexes
         plugin Plugins::Keys
         plugin Plugins::Dirty # for now dirty needs to be after keys
         plugin Plugins::Logger
         plugin Plugins::Modifiers
         plugin Plugins::Pagination
+        plugin Plugins::Persistence
+        plugin Plugins::Accessible
         plugin Plugins::Protected
         plugin Plugins::Rails
+        plugin Plugins::Safe # needs to be after querying (save_to_collection)
+        plugin Plugins::Sci
+        plugin Plugins::Scopes
         plugin Plugins::Serialization
         plugin Plugins::Timestamps
         plugin Plugins::Userstamps
         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
-
-        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 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 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 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 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
-        @_destroyed = true
-        self.class.delete(id) unless new?
-      end
-
-      def destroyed?
-        @_destroyed == true
-      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
-
-      # Used by embedded docs to find root easily without if/respond_to? stuff.
-      # Documents are always root documents.
-      def _root_document
-        self
-      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
-    end
   end # Document
 end # MongoMapper