mongoid 0.2.5

data/.gitignore

@@ -0,0 +1,5 @@
+.DS_STORE
+coverage/*
+pkg/*
+scratch_directory/*
+tmp/*

data/History.txt

@@ -0,0 +1,2 @@
+0.2.5:
+- Switching pagination over to will_paginate

data/MIT_LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Durran Jordan
+
+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.textile

@@ -0,0 +1,135 @@
+<h2>Overview</h2>
+
+<h3>About Mongoid</h3>
+
+<p>
+  Mongoid is an ODM (Object-Document-Mapper) framework for MongoDB in Ruby. Mongoid differs from other
+  mapping frameworks in that it constrains the models into behaving in a manner appropriate for a
+  document database. That is to say there are no relationships between documents in the underlying datastore.
+  If a relationship is set up in the Model the child models are automatically embedded within the parent document
+  in the database. The concept of a foreign key relationship to another Document does not exist, as that is
+  design and thinking for a relational database, not a document database. Mongoloid does however provide
+  all the ActiveRecord style functionality you need, with the difference that it stores all associations
+  within the parent document.
+</p>
+
+<h3>Project Tracking</h3>
+
+<a href="http://www.pivotaltracker.com/projects/27482">Mongoid on Pivotal Tracker</a>
+<a href="http://groups.google.com/group/mongoid">Mongoid Google Group</a>
+
+<h3>Compatibility</h3>
+
+<p>
+  Mongoid is developed against Ruby 1.8.6, 1.8.7, 1.9.1
+</p>
+
+<h2>Mongoid in Action</h2>
+
+Initialize Mongoid:
+
+<pre>
+  Mongoid.connect_to("myapp_database_name")
+</pre>
+
+Example of a simple domain model:
+
+<pre>
+  class Person < Mongoid::Document
+    fields :title
+    has_many :addresses
+    has_one :name
+  end
+
+  class Address < Mongoid::Document
+    fields \
+      :street,
+      :city,
+      :state,
+      :post_code
+    belongs_to :person
+  end
+
+  class Name < Mongoid::Document
+    fields \
+      :first_name,
+      :last_name
+  end
+</pre>
+
+Create a new Document:
+
+<pre>
+  Person.create(:title => "Esquire")
+</pre>
+
+Save a Document:
+
+<pre>
+  person.save
+</pre>
+
+Delete a Document:
+
+<pre>
+  person.destroy
+</pre>
+
+Update a Document:
+
+<pre>
+  person.update_attributes(:title => "Sir")
+</pre>
+
+Search for a Document in the database:
+
+<pre>
+  Person.find(:all, :title => "Esquire")
+
+  Person.find(:first, :title => "Esquire")
+</pre>
+
+Paginate Document search results:
+
+<pre>
+  Person.paginate(:title => "Esquire", :page => 1, :per_page => 20)
+</pre>
+
+Validations:
+
+Mongoid supports all validations provided by Jay Fields' <tt>Validatable</tt> gem.
+For more information please see the <tt>Validatable</tt> documentation.
+
+<a href="http://validatable.rubyforge.org/">Validatable on RubyForge</a>
+
+<h2>License</h2>
+
+<p>
+  Copyright (c) 2009 Durran Jordan
+</p>
+<p>
+  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:
+</p>
+<p>
+  The above copyright notice and this permission notice shall be
+  included in all copies or substantial portions of the Software.
+</p>
+<p>
+  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.
+</p>
+
+<h2>Credits</h2>
+
+Durran Jordan: durran at gmail dot com

data/Rakefile

@@ -0,0 +1,49 @@
+require "rubygems"
+require "rake"
+require "rake/rdoctask"
+require "spec/rake/spectask"
+require "metric_fu"
+
+begin
+  require "jeweler"
+  Jeweler::Tasks.new do |gem|
+    gem.name = "mongoid"
+    gem.summary = %Q{Mongoid}
+    gem.email = "durran@gmail.com"
+    gem.homepage = "http://github.com/durran/mongoid"
+    gem.authors = ["Durran Jordan"]
+    gem.add_dependency "activesupport"
+    gem.add_dependency "mongodb-mongo"
+  end
+
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << "lib" << "spec"
+  spec.pattern = "spec/**/*_spec.rb"
+  spec.spec_opts = ['--options', "spec/spec.opts"]
+end
+
+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
+
+Rake::RDocTask.new do |rdoc|
+  if File.exist?("VERSION.yml")
+    config = YAML.load(File.read("VERSION.yml"))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.title = "my_emma #{version}"
+  rdoc.rdoc_files.include("README*")
+  rdoc.rdoc_files.include("lib/**/*.rb")
+end
+
+task :default => ["rcov", "metrics:all"]

data/VERSION

@@ -0,0 +1 @@
+0.2.5

data/lib/mongoid.rb

@@ -0,0 +1,79 @@
+# Copyright (c) 2009 Durran Jordan
+# 
+# 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.
+require "rubygems"
+
+gem "activesupport", "2.3.4"
+gem "mongodb-mongo", "0.14.1"
+gem "durran-validatable", "1.7.5"
+gem "mislav-will_paginate", "2.3.11"
+
+require "validatable"
+require "active_support/callbacks"
+require "active_support/core_ext"
+require "delegate"
+require "will_paginate/collection"
+require "mongo"
+require "mongoid/associations/association_factory"
+require "mongoid/associations/belongs_to_association"
+require "mongoid/associations/has_many_association"
+require "mongoid/associations/has_one_association"
+require "mongoid/extensions/array/conversions"
+require "mongoid/extensions/object/conversions"
+require "mongoid/extensions"
+require "mongoid/document"
+require "mongoid/paginator"
+
+module Mongoid
+
+  # Thrown when the database connection has not been set up.
+  class NoConnectionError < RuntimeError
+  end
+
+  # Thrown when :document_class is not provided in the attributes
+  # hash when creating a new Document
+  class ClassNotProvidedError < RuntimeError
+  end
+
+  # Thrown when an association is defined on the class, but the
+  # attribute in the hash is not an Array or Hash.
+  class TypeMismatchError < RuntimeError
+  end
+
+  # Thrown when an association is defined that is not valid. Must
+  # be belongs_to, has_many, has_one
+  class InvalidAssociationError < RuntimeError
+  end
+
+  # Connect to the database name supplied. This should be run
+  # for initial setup, potentially in a rails initializer.
+  def self.connect_to(name)
+    @@connection ||= Mongo::Connection.new
+    @@database ||= @@connection.db(name)
+  end
+
+  # Get the MongoDB database. If initialization via Mongoid.connect_to()
+  # has not happened, an exception will occur.
+  def self.database
+    raise NoConnectionError unless @@database
+    @@database
+  end
+
+end

data/lib/mongoid/associations/association_factory.rb

@@ -0,0 +1,21 @@
+module Mongoid #:nodoc:
+  module Associations #:nodoc:
+    class AssociationFactory #:nodoc:
+
+      # Creates a new association, based on the type provided and 
+      # passes the name and document into the newly instantiated
+      # association.
+      #
+      # If the type is invalid a InvalidAssociationError will be thrown.
+      def self.create(association_type, association_name, document)
+        case association_type
+          when :belongs_to then BelongsToAssociation.new(document)
+          when :has_many then HasManyAssociation.new(association_name, document)
+          when :has_one then HasOneAssociation.new(association_name, document)
+          else raise InvalidAssociationError
+        end
+      end
+
+    end
+  end
+end

data/lib/mongoid/associations/belongs_to_association.rb

@@ -0,0 +1,23 @@
+module Mongoid #:nodoc:
+  module Associations #:nodoc:
+    class BelongsToAssociation #:nodoc:
+
+      # Creates the new association by setting the internal 
+      # document as the passed in Document. This should be the
+      # parent.
+      #
+      # All method calls on this object will then be delegated
+      # to the internal document itself.
+      def initialize(document)
+        @document = document.parent
+      end
+
+      # All calls to this association will be delegated straight
+      # to the encapsulated document.
+      def method_missing(method, *args)
+        @document.send(method, *args)
+      end
+
+    end
+  end
+end

data/lib/mongoid/associations/has_many_association.rb

@@ -0,0 +1,36 @@
+module Mongoid #:nodoc:
+  module Associations #:nodoc:
+    class HasManyAssociation < DelegateClass(Array) #:nodoc:
+
+      # Creates the new association by finding the attributes in
+      # the parent document with its name, and instantiating a
+      # new document for each one found. These will then be put in an
+      # internal array.
+      #
+      # This then delegated all methods to the array class since this is
+      # essentially a proxy to an array itself.
+      def initialize(association_name, document)
+        @klass = association_name.to_s.classify.constantize
+        attributes = document.attributes[association_name]
+        @documents = attributes ? attributes.collect do |attribute|
+          child = @klass.new(attribute)
+          child.parent = document
+          child
+        end : []
+        super(@documents)
+      end
+
+      # Builds a new Document and adds it to the association collection. The
+      # document created will be of the same class as the others in the
+      # association, and the attributes will be passed into the constructor.
+      #
+      # Returns the newly created object.
+      def build(attributes)
+        object = @klass.new(attributes)
+        push(object)
+        object
+      end
+
+    end
+  end
+end

data/lib/mongoid/associations/has_one_association.rb

@@ -0,0 +1,35 @@
+module Mongoid #:nodoc:
+  module Associations #:nodoc:
+    class HasOneAssociation #:nodoc:
+
+      attr_reader :document
+      delegate :valid?, :to => :document
+
+      # Creates the new association by finding the attributes in 
+      # the parent document with its name, and instantiating a 
+      # new document for it.
+      #
+      # All method calls on this object will then be delegated
+      # to the internal document itself.
+      def initialize(association_name, document)
+        klass = association_name.to_s.titleize.constantize
+        attributes = document.attributes[association_name]
+        @document = klass.new(attributes)
+        @document.parent = document
+        decorate!
+      end
+
+      private
+      def decorate!
+        @document.public_methods(false).each do |method|
+          (class << self; self; end).class_eval do
+            define_method method do |*args|
+              @document.send method, *args
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/mongoid/document.rb

@@ -0,0 +1,208 @@
+module Mongoid #:nodoc:
+  class Document #:nodoc:
+    include ActiveSupport::Callbacks
+    include Validatable
+
+    AGGREGATE_REDUCE = "function(obj, prev) { prev.count++; }"
+    GROUP_BY_REDUCE = "function(obj, prev) { prev.group.push(obj); }"
+
+    attr_reader :attributes, :parent
+
+    define_callbacks \
+      :after_create,
+      :after_save,
+      :before_create,
+      :before_save
+
+    class << self
+
+      # Get an aggregate count for the supplied group of fields and the
+      # selector that is provided.
+      def aggregate(fields, selector)
+        collection.group(fields, selector, { :count => 0 }, AGGREGATE_REDUCE)
+      end
+
+      # Create an association to a parent Document.
+      def belongs_to(association_name)
+        add_association(:belongs_to, association_name.to_s.classify, association_name)
+      end
+
+      # Get the Mongo::Collection associated with this Document.
+      def collection
+        @collection_name = self.to_s.demodulize.tableize
+        @collection ||= Mongoid.database.collection(@collection_name)
+      end
+
+      # Create a new Document with the supplied attribtues, and insert it into the database.
+      def create(attributes = {})
+        new(attributes).save
+      end
+
+      # Defines all the fields that are accessable on the Document
+      # For each field that is defined, a getter and setter will be
+      # added as an instance method to the Document.
+      def fields(*names)
+        @fields = []
+        names.flatten.each do |name|
+          @fields << name
+          define_method(name) { read_attribute(name) }
+          define_method("#{name}=") { |value| write_attribute(name, value) }
+        end
+      end
+
+      # Find all Documents in several ways.
+      # Model.find(:first, :attribute => "value")
+      # Model.find(:all, :attribute => "value")
+      def find(*args)
+        type, selector = args[0], args[1]
+        case type
+        when :all then find_all(selector[:conditions])
+        when :first then find_first(selector[:conditions])
+        else find_first(Mongo::ObjectID.from_string(type.to_s))
+        end
+      end
+
+      # Find a single Document given the passed selector, which is a Hash of attributes that
+      # must match the Document in the database exactly.
+      def find_first(selector = nil)
+        new(collection.find_one(selector))
+      end
+
+      # Find all Documents given the passed selector, which is a Hash of attributes that
+      # must match the Document in the database exactly.
+      def find_all(selector = nil)
+        collection.find(selector).collect { |doc| new(doc) }
+      end
+
+      # Find all Documents given the supplied criteria, grouped by the fields
+      # provided.
+      def group_by(fields, selector)
+        collection.group(fields, selector, { :group => [] }, GROUP_BY_REDUCE).collect do |docs|
+          group!(docs)
+        end
+      end
+
+      # Create a one-to-many association between Documents.
+      def has_many(association_name)
+        add_association(:has_many, association_name.to_s.classify, association_name)
+      end
+
+      # Create a one-to-many association between Documents.
+      def has_one(association_name)
+        add_association(:has_one, association_name.to_s.titleize, association_name)
+      end
+
+      # Adds an index on the field specified. Options can be :unique => true or
+      # :unique => false. It will default to the latter.
+      def index(name, options = { :unique => false })
+        collection.create_index(name, options)
+      end
+
+      # Find all documents in paginated fashion given the supplied arguments.
+      # If no parameters are passed just default to offset 0 and limit 20.
+      def paginate(selector = {}, params = {})
+        WillPaginate::Collection.create(
+          params[:page] || 1,
+          params[:per_page] || 20,
+          0) do |pager|
+            results = collection.find(selector[:conditions], { :limit => pager.per_page, :offset => pager.offset })
+            pager.total_entries = results.count
+            pager.replace(results.collect { |doc| new(doc) })
+        end
+      end
+
+    end
+
+    # Get the Mongo::Collection associated with this Document.
+    def collection
+      self.class.collection
+    end
+
+    # Delete this Document from the database.
+    def destroy
+      collection.remove(:_id => id)
+    end
+
+    # Get the Mongo::ObjectID associated with this object.
+    # This is in essence the primary key.
+    def id
+      @attributes[:_id]
+    end
+
+    # Instantiate a new Document, setting the Document's attirbutes if given.
+    # If no attributes are provided, they will be initialized with an empty Hash.
+    def initialize(attributes = {})
+      @attributes = attributes.symbolize_keys if attributes
+      @attributes = {} unless attributes
+    end
+
+    # Returns true is the Document has not been persisted to the database, false if it has.
+    def new_record?
+      @attributes[:_id].nil?
+    end
+
+    # Set the parent to this document.
+    def parent=(document)
+      @parent = document
+    end
+
+    # Save this document to the database. If this document is the root document
+    # in the object graph, it will save itself, and return self. If the
+    # document is embedded within another document, or is multiple levels down
+    # the tree, the root object will get saved, and return itself.
+    def save
+      if @parent
+        @parent.save
+      else
+        run_callbacks(:before_save)
+        collection.save(@attributes)
+        run_callbacks(:after_save)
+        return self
+      end
+    end
+
+    # Returns the id of the Document
+    def to_param
+      id.to_s
+    end
+
+    # Update the attributes of this Document and return true
+    def update_attributes(attributes)
+      @attributes = attributes.symbolize_keys!; save; true
+    end
+
+    private
+
+    class << self
+
+      # Adds the association to the associations hash with the type as the key,
+      # then adds the accessors for the association.
+      def add_association(type, class_name, name)
+        define_method(name) do
+          Mongoid::Associations::AssociationFactory.create(type, name, self)
+        end
+        define_method("#{name}=") do |object|
+          @attributes[name] = object.mongoidize
+        end
+      end
+
+      # Takes the supplied raw grouping of documents and alters it to a
+      # grouping of actual document objects.
+      def group!(docs)
+        docs["group"] = docs["group"].collect { |attrs| new(attrs) }; docs
+      end
+
+    end
+
+    # Read from the attributes hash.
+    def read_attribute(name)
+      @attributes[name.to_sym]
+    end
+
+    # Write to the attributes hash.
+    def write_attribute(name, value)
+      @attributes[name.to_sym] = value
+    end
+
+  end
+end