lookout-mongo_mapper 0.11.3

data/lib/mongo_mapper/railtie.rb

@@ -0,0 +1,48 @@
+require "mongo_mapper"
+require "rails"
+require "active_model/railtie"
+
+module MongoMapper
+  # = MongoMapper Railtie
+  class Railtie < Rails::Railtie
+
+    config.mongo_mapper = ActiveSupport::OrderedOptions.new
+
+    rake_tasks do
+      load "mongo_mapper/railtie/database.rake"
+    end
+
+    initializer "mongo_mapper.set_configs" do |app|
+      ActiveSupport.on_load(:mongo_mapper) do
+        app.config.mongo_mapper.each do |k,v|
+          send "#{k}=", v
+        end
+      end
+    end
+
+    # This sets the database configuration and establishes the connection.
+    initializer "mongo_mapper.initialize_database" do |app|
+      config_file = Rails.root.join('config/mongo.yml')
+      if config_file.file?
+        config = YAML.load(ERB.new(config_file.read).result)
+        MongoMapper.setup(config, Rails.env, :logger => Rails.logger)
+      end
+    end
+
+    # Clear the identity map after each request
+    initializer "mongo_mapper.clear_identity_map" do |app|
+      app.config.middleware.use 'MongoMapper::Middleware::IdentityMap'
+    end
+
+    initializer "mongo_mapper.prepare_dispatcher" do |app|
+      # See http://groups.google.com/group/mongomapper/browse_thread/thread/68f62e8eda43b43a/4841dba76938290c
+      # to_prepare is called before each request in development mode and the first request in production.
+
+      ActionDispatch::Callbacks.to_prepare do
+        unless app.config.cache_classes
+          MongoMapper::Plugins::IdentityMap.models.clear
+        end
+      end
+    end
+  end
+end

data/lib/mongo_mapper/railtie/database.rake

@@ -0,0 +1,65 @@
+namespace :db do
+  unless Rake::Task.task_defined?("db:drop")
+    desc 'Drops all the collections for the database for the current Rails.env'
+    task :drop => :environment do
+      MongoMapper.database.collections.select {|c| c.name !~ /system/ }.each(&:drop)
+    end
+  end
+
+  unless Rake::Task.task_defined?("db:seed")
+    # if another ORM has defined db:seed, don't run it twice.
+    desc 'Load the seed data from db/seeds.rb'
+    task :seed => :environment do
+      seed_file = File.join(Rails.root, 'db', 'seeds.rb')
+      load(seed_file) if File.exist?(seed_file)
+    end
+  end
+
+  unless Rake::Task.task_defined?("db:setup")
+    desc 'Create the database, and initialize with the seed data'
+    task :setup => [ 'db:create', 'db:seed' ]
+  end
+
+  unless Rake::Task.task_defined?("db:reseed")
+    desc 'Delete data and seed'
+    task :reseed => [ 'db:drop', 'db:seed' ]
+  end
+
+  unless Rake::Task.task_defined?("db:create")
+    task :create => :environment do
+      # noop
+    end
+  end
+
+  unless Rake::Task.task_defined?("db:migrate")
+    task :migrate => :environment do
+      # noop
+    end
+  end
+
+  unless Rake::Task.task_defined?("db:schema:load")
+    namespace :schema do
+      task :load do
+        # noop
+      end
+    end
+  end
+
+  unless Rake::Task.task_defined?("db:test:prepare")
+    namespace :test do
+      task :prepare => :environment do
+        MongoMapper.connect('test')
+        MongoMapper.database.collections.select {|c| c.name !~ /system/ }.each(&:drop)
+        MongoMapper.connect(Rails.env)
+      end
+    end
+  end
+
+  desc 'Load indexes from db/indexes.rb'
+  task :index => :environment do
+    indexes = File.join(Rails.root, 'db', 'indexes.rb')
+    load(indexes) if File.exist?(indexes)
+  end
+end
+
+task 'test:prepare' => 'db:test:prepare'

data/lib/mongo_mapper/translation.rb

@@ -0,0 +1,10 @@
+# encoding: UTF-8
+module MongoMapper
+  module Translation
+    include ActiveModel::Translation
+
+    def i18n_scope
+      :mongo_mapper
+    end
+  end
+end

data/lib/mongo_mapper/version.rb

@@ -0,0 +1,4 @@
+# encoding: UTF-8
+module MongoMapper
+  Version = '0.11.3'
+end

data/lib/rails/generators/mongo_mapper/config/config_generator.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+module MongoMapper
+  module Generators
+    class ConfigGenerator < Rails::Generators::Base
+      desc "creates the MongoMapper configuration at config/mongo.yml"
+
+      argument :database_name, :type => :string, :optional => true
+
+      def self.source_root
+        @source_root ||= File.expand_path("../templates", __FILE__)
+      end
+
+      def app_name
+        Rails::Application.subclasses.first.parent.to_s.underscore
+      end
+
+      def create_config_file
+        template 'mongo.yml', File.join('config', "mongo.yml")
+      end
+
+    end
+  end
+end

data/lib/rails/generators/mongo_mapper/config/templates/mongo.yml

@@ -0,0 +1,18 @@
+defaults: &defaults
+  host: 127.0.0.1
+  port: 27017
+
+development:
+  <<: *defaults
+  database: <%= database_name || app_name %>_development
+
+test:
+  <<: *defaults
+  database: <%= database_name || app_name %>_test
+
+# set these environment variables on your prod server
+production:
+  <<: *defaults
+  database: <%= database_name || app_name %>
+  username: <%%= ENV['MONGO_USERNAME'] %>
+  password: <%%= ENV['MONGO_PASSWORD'] %>

data/lib/rails/generators/mongo_mapper/model/model_generator.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+
+module MongoMapper
+  module Generators
+    class ModelGenerator < Rails::Generators::NamedBase
+      desc 'Creates a mongomapper model'
+      argument :name, :type => :string
+      argument :attributes, :type => :array, :default => [], :banner => "field:type field:type"
+      class_option :timestamps, :type => :boolean
+      check_class_collision
+
+      def self.source_root
+        @source_root ||= File.expand_path("../templates", __FILE__)
+      end
+
+      def create_model_file
+        template 'model.rb', File.join('app/models', class_path, "#{file_name}.rb")
+      end
+
+      hook_for :test_framework
+    end
+  end
+end

data/lib/rails/generators/mongo_mapper/model/templates/model.rb

@@ -0,0 +1,13 @@
+<% module_namespacing do -%>
+class <%= class_name %>
+  include MongoMapper::Document
+
+<% attributes.each do |attribute| -%>
+  key :<%= attribute.name %>, <%= attribute.type.to_s.camelcase %>
+<% end -%>
+<% if options[:timestamps] %>
+  timestamps!
+<% end -%>
+
+end
+<% end -%>

data/test/_NOTE_ON_TESTING

@@ -0,0 +1 @@
+I am doing my best to keep unit and functional tests separate. As I see them, functional tests hit the database and should never care about internals. Unit tests do not hit the database.

data/test/functional/associations/test_belongs_to_polymorphic_proxy.rb

@@ -0,0 +1,64 @@
+require 'test_helper'
+require 'models'
+
+class BelongsToPolymorphicProxyTest < Test::Unit::TestCase
+  def setup
+    Status.collection.remove
+    Project.collection.remove
+  end
+
+  should "default to nil" do
+    status = Status.new
+    status.target.nil?.should be_true
+    status.target.inspect.should == "nil"
+  end
+
+  should "have boolean presence method" do
+    status = Status.new
+    status.target?.should be_false
+
+    status.target = Project.new(:name => 'mongomapper')
+    status.target?.should be_true
+  end
+
+  should "be able to replace the association" do
+    status = Status.new(:name => 'Foo!')
+    project = Project.new(:name => "mongomapper")
+    status.target = project
+    status.save.should be_true
+
+    status = status.reload
+    status.target.nil?.should be_false
+    status.target_id.should == project._id
+    status.target_type.should == "Project"
+    status.target.name.should == "mongomapper"
+  end
+
+  should "unset the association" do
+    status = Status.new(:name => 'Foo!')
+    project = Project.new(:name => "mongomapper")
+    status.target = project
+    status.save.should be_true
+
+    status = status.reload
+    status.target = nil
+    status.target_type.nil?.should be_true
+    status.target_id.nil?.should be_true
+    status.target.nil?.should be_true
+  end
+
+  context "association id set but document not found" do
+    setup do
+      @status = Status.new(:name => 'Foo!')
+      project = Project.new(:name => "mongomapper")
+      @status.target = project
+      @status.save.should be_true
+      project.destroy
+      @status.reload
+    end
+
+    should "return nil instead of raising error" do
+      @status.target.nil?.should be_true
+    end
+  end
+end

data/test/functional/associations/test_belongs_to_proxy.rb

@@ -0,0 +1,238 @@
+require 'test_helper'
+require 'models'
+
+class BelongsToProxyTest < Test::Unit::TestCase
+  def setup
+    @post_class = Doc()
+    @comment_class = Doc do
+      key :post_id, ObjectId
+    end
+
+    @comment_class.belongs_to :post, :class => @post_class
+  end
+
+  should "default to nil" do
+    @comment_class.new.post.nil?.should be_true
+  end
+
+  should "return nil instead of a proxy" do
+    nil.should === @comment_class.new.post
+  end
+
+  should "have boolean presence method" do
+    comment = @comment_class.new(:name => 'Foo!')
+    comment.post?.should be_false
+
+    comment.post = @post_class.new(:name => 'mongomapper')
+    comment.post?.should be_true
+  end
+
+  should "allow overriding association methods" do
+    @comment_class.class_eval do
+      def post?
+        super
+      end
+    end
+
+    instance = @comment_class.new
+    instance.post?.should be_false
+    instance.post = @post_class.new
+    instance.post?.should be_true
+  end
+
+  should "be able to replace the association" do
+    post = @post_class.new(:name => 'mongomapper')
+    comment = @comment_class.new(:name => 'Foo!', :post => post)
+    comment.save.should be_true
+
+    comment = comment.reload
+    comment.post.should == post
+    comment.post.nil?.should be_false
+  end
+  
+  should "not reload the association when replacing" do
+    post = @post_class.new(:name => 'mongomapper')
+    comment = @comment_class.new(:name => 'Foo!', :post => post)
+    comment.post.proxy_target.object_id.should == post.object_id
+  end
+
+  should "properly assign the associated object when assigning the association with create" do
+    child_class = Doc('Child')
+    parent_class = Doc('Parent')
+    
+    parent_class.one :child, :class => child_class
+    child_class.belongs_to :parent, :class => parent_class
+    
+    child = child_class.create(:parent => parent_class.create)
+    child.parent.child.should == child
+  end
+
+  should "generate a new proxy when replacing the association" do
+    post1 = @post_class.create(:name => 'post1')
+    post2 = @post_class.create(:name => 'post2')
+
+    comment = @comment_class.new(:name => 'Foo!', :post => post1)
+    comment.save.should be_true
+
+
+    comment = comment.reload
+    comment.post.should == post1
+    comment.post.nil?.should be_false
+
+    original_post = comment.post
+    original_post.name.should == 'post1'
+
+    comment.post = post2
+    comment.post.name.should == 'post2'
+    original_post.name.should == 'post1'
+  end
+
+  should "unset the association" do
+    post = @post_class.new(:name => 'mongomapper')
+    comment = @comment_class.new(:name => 'Foo!', :post => post)
+    comment.save.should be_true
+
+    comment = comment.reload
+    comment.post = nil
+    comment.post.nil?.should be_true
+  end
+
+  should "return nil if id set but document not found" do
+    id = BSON::ObjectId.new
+    @comment_class.new(:name => 'Foo', :post_id => id).post.nil?.should be_true
+  end
+
+  should "define foreign key if it doesn't exist" do
+    @category_class = Doc()
+    @post_class.belongs_to :category, :class => @category_class
+
+    @post_class.key?(:category_id).should be_true
+  end
+
+  should "not define foreign key if it already exists" do
+    @category_class = Doc()
+    @post_class.key :category_id, String
+    @post_class.belongs_to :category, :class => @category_class
+
+    @post_class.keys['category_id'].type.should == String
+  end
+
+  context ":dependent" do
+    setup do
+      # FIXME: make use of already defined models
+      class ::Property
+        include MongoMapper::Document
+      end
+      Property.collection.remove
+
+      class ::Thing
+        include MongoMapper::Document
+        key :name, String
+      end
+      Thing.collection.remove
+    end
+
+    teardown do
+      Object.send :remove_const, 'Property' if defined?(::Property)
+      Object.send :remove_const, 'Thing' if defined?(::Thing)
+    end
+
+    context "=> destroy" do
+      setup do
+        Property.key :thing_id, ObjectId
+        Property.belongs_to :thing, :dependent => :destroy
+        Thing.many :properties
+
+        @thing = Thing.create(:name => "Tree")
+        @property1 = Property.create
+        @property2 = Property.create
+        @property3 = Property.create
+        @thing.properties << @property1
+        @thing.properties << @property2
+        @thing.properties << @property3
+      end
+
+      should "not execute on a belongs_to association" do
+        Thing.count.should == 1
+        @property1.destroy
+        Thing.count.should == 1
+      end
+    end
+  end
+
+  should "be able to build" do
+    @comment_class.belongs_to :post, :class => @post_class
+
+    comment = @comment_class.create
+    post = comment.build_post(:title => 'Hello, world!')
+    comment.post.should be_instance_of(@post_class)
+    comment.post.should be_new
+    comment.post.title.should == 'Hello, world!'
+    comment.post.should == post
+    comment.post_id.should == post.id
+  end
+
+  should "be able to create" do
+    @comment_class.belongs_to :post, :class => @post_class
+
+    comment = @comment_class.create
+    post = comment.create_post(:title => 'Hello, world!')
+    comment.post.should be_instance_of(@post_class)
+    comment.post.should_not be_new
+    comment.post.title.should == 'Hello, world!'
+    comment.post.should == post
+    comment.post_id.should == post.id
+  end
+
+  context "#create!" do
+    setup do
+      @post_class.key :title, String, :required => true
+      @comment_class.belongs_to :post, :class => @post_class
+    end
+
+    should "raise exception if invalid" do
+      comment = @comment_class.create
+      assert_raises(MongoMapper::DocumentNotValid) do
+        comment.create_post!
+      end
+    end
+
+    should "work if valid" do
+      comment = @comment_class.create
+      post = comment.create_post!(:title => 'Hello, world!')
+      comment.post.should be_instance_of(@post_class)
+      comment.post.should_not be_new
+      comment.post.title.should == 'Hello, world!'
+      comment.post.should == post
+      comment.post_id.should == post.id
+    end
+  end
+
+  context 'autosave' do
+    should 'not be true by default' do
+      @comment_class.associations[:post].options[:autosave].should_not be_true
+    end
+
+    should 'save parent changes when true' do
+      @comment_class.associations[:post].options[:autosave] = true
+
+      comment = @comment_class.create
+      post = comment.create_post(:title => 'Hello, world!')
+
+      comment.post.attributes = {:title => 'Hi, world.'}
+      comment.save
+
+      post.reload.title.should == 'Hi, world.'
+    end
+
+    should 'not save parent changes when false' do
+      comment = @comment_class.create
+      post = comment.create_post(:title => 'Hello, world!')
+
+      comment.post.attributes = {:title => 'Hi, world.'}
+      comment.save
+
+      post.reload.title.should == 'Hello, world!'
+    end
+  end
+end