mongoid-braxton 2.0.2

data/lib/mongoid/railtie.rb

@@ -0,0 +1,139 @@
+# encoding: utf-8
+require "singleton"
+require "mongoid"
+require "mongoid/config"
+require "mongoid/railties/document"
+require "rails"
+require "rails/mongoid"
+
+module Rails #:nodoc:
+  module Mongoid #:nodoc:
+    class Railtie < Rails::Railtie #:nodoc:
+
+      # Determine which generator to use. app_generators was introduced after
+      # 3.0.0.
+      #
+      # @example Get the generators method.
+      #   railtie.generators
+      #
+      # @return [ Symbol ] The method name to use.
+      #
+      # @since 2.0.0.rc.4
+      def self.generator
+        config.respond_to?(:app_generators) ? :app_generators : :generators
+      end
+
+      config.send(generator).orm :mongoid, :migration => false
+
+      rake_tasks do
+        load "mongoid/railties/database.rake"
+      end
+
+      # Exposes Mongoid's configuration to the Rails application configuration.
+      #
+      # @example Set up configuration in the Rails app.
+      #   module MyApplication
+      #     class Application < Rails::Application
+      #       config.mongoid.logger = Logger.new($stdout, :warn)
+      #       config.mongoid.persist_in_safe_mode = true
+      #     end
+      #   end
+      config.mongoid = ::Mongoid::Config
+
+      # Initialize Mongoid. This will look for a mongoid.yml in the config
+      # directory and configure mongoid appropriately.
+      #
+      # @example mongoid.yml
+      #
+      #   development:
+      #     host: localhost
+      #     database: mongoid
+      #     slaves:
+      #       # - host: localhost
+      #         # port: 27018
+      #       # - host: localhost
+      #         # port: 27019
+      #     allow_dynamic_fields: false
+      #     parameterize_keys: false
+      #     persist_in_safe_mode: false
+      #
+      initializer "setup database" do
+        config_file = Rails.root.join("config", "mongoid.yml")
+        if config_file.file?
+          settings = YAML.load(ERB.new(config_file.read).result)[Rails.env]
+          ::Mongoid.from_hash(settings) if settings.present?
+        end
+      end
+
+      # After initialization we will warn the user if we can't find a mongoid.yml and
+      # alert to create one.
+      initializer "warn when configuration is missing" do
+        config.after_initialize do
+          unless Rails.root.join("config", "mongoid.yml").file?
+            puts "\nMongoid config not found. Create a config file at: config/mongoid.yml"
+            puts "to generate one run: rails generate mongoid:config\n\n"
+          end
+        end
+      end
+
+      # Due to all models not getting loaded and messing up inheritance queries
+      # and indexing, we need to preload the models in order to address this.
+      #
+      # This will happen every request in development, once in ther other
+      # environments.
+      initializer "preload all application models" do |app|
+        config.to_prepare do
+          ::Rails::Mongoid.load_models(app) unless $rails_rake_task
+        end
+      end
+
+      # Set the proper error types for Rails. DocumentNotFound errors should be
+      # 404s and not 500s, validation errors are 422s.
+      initializer "load http errors" do |app|
+        config.after_initialize do
+          ActionDispatch::ShowExceptions.rescue_responses.update({
+            "Mongoid::Errors::DocumentNotFound" => :not_found,
+            "Mongoid::Errors::Validations" => 422
+          })
+        end
+      end
+
+      # When workers are forked in passenger and unicorn, we need to reconnect
+      # to the database to all the workers do not share the same connection.
+      initializer "reconnect to master if application is preloaded" do
+        config.after_initialize do
+
+          # Unicorn clears the START_CTX when a worker is forked, so if we have
+          # data in START_CTX then we know we're being preloaded. Unicorn does
+          # not provide application-level hooks for executing code after the
+          # process has forked, so we reconnect lazily.
+          if defined?(Unicorn) && !Unicorn::HttpServer::START_CTX.empty?
+            ::Mongoid.reconnect!(false)
+          end
+
+          # Passenger provides the :starting_worker_process event for executing
+          # code after it has forked, so we use that and reconnect immediately.
+          if defined?(PhusionPassenger)
+            PhusionPassenger.on_event(:starting_worker_process) do |forked|
+              if forked
+                ::Mongoid.reconnect!
+              end
+            end
+          end
+        end
+      end
+
+      # Instantitate any registered observers after Rails initialization and
+      # instantiate them after being reloaded in the development environment
+      initializer "instantiate observers" do
+        config.after_initialize do
+          ::Mongoid.instantiate_observers
+
+          ActionDispatch::Callbacks.to_prepare do
+            ::Mongoid.instantiate_observers
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/railties/database.rake

@@ -0,0 +1,171 @@
+namespace :db do
+
+  if not Rake::Task.task_defined?("db:drop")
+    desc 'Drops all the collections for the database for the current Rails.env'
+    task :drop => :environment do
+      Mongoid.master.collections.select {|c| c.name !~ /system/ }.each(&:drop)
+    end
+  end
+
+  if not 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
+
+  if not Rake::Task.task_defined?("db:setup")
+    desc 'Create the database, and initialize with the seed data'
+    task :setup => [ 'db:create', 'db:mongoid:create_indexes', 'db:seed' ]
+  end
+
+  if not Rake::Task.task_defined?("db:reseed")
+    desc 'Delete data and seed'
+    task :reseed => [ 'db:drop', 'db:seed' ]
+  end
+
+  if not Rake::Task.task_defined?("db:create")
+    task :create => :environment do
+      # noop
+    end
+  end
+
+  if not Rake::Task.task_defined?("db:migrate")
+    task :migrate => :environment do
+      # noop
+    end
+  end
+
+  if not Rake::Task.task_defined?("db:schema:load")
+    namespace :schema do
+      task :load do
+        # noop
+      end
+    end
+  end
+
+  if not Rake::Task.task_defined?("db:test:prepare")
+    namespace :test do
+      task :prepare do
+        # noop
+      end
+    end
+  end
+
+  if not Rake::Task.task_defined?("db:create_indexes")
+    task :create_indexes => "mongoid:create_indexes"
+  end
+
+  namespace :mongoid do
+    # gets a list of the mongoid models defined in the app/models directory
+    def get_mongoid_models
+      documents = []
+      Dir.glob("app/models/**/*.rb").sort.each do |file|
+        model_path = file[0..-4].split('/')[2..-1]
+        begin
+          klass = model_path.map(&:classify).join('::').constantize
+          if klass.ancestors.include?(Mongoid::Document) && !klass.embedded
+            documents << klass
+          end
+        rescue => e
+          # Just for non-mongoid objects that dont have the embedded
+          # attribute at the class level.
+        end
+      end
+      documents
+    end
+
+    desc 'Create the indexes defined on your mongoid models'
+    task :create_indexes => :environment do
+      ::Rails::Mongoid.index_children(get_mongoid_models)
+    end
+
+    def convert_ids(obj)
+      if obj.is_a?(String) && obj =~ /^[a-f0-9]{24}$/
+        BSON::ObjectId(obj)
+      elsif obj.is_a?(Array)
+        obj.map do |v|
+          convert_ids(v)
+        end
+      elsif obj.is_a?(Hash)
+        obj.each do |k, v|
+          obj[k] = convert_ids(v)
+        end
+      else
+        obj
+      end
+    end
+
+    def collection_names
+      @collection_names ||= get_mongoid_models.map{ |d| d.collection.name }.uniq
+    end
+
+    desc "Convert string objectids in mongo database to ObjectID type"
+    task :objectid_convert => :environment do
+      collection_names.each do |collection_name|
+        puts "Converting #{collection_name} to use ObjectIDs"
+
+        # get old collection
+        collection = Mongoid.master.collection(collection_name)
+
+        # get new collection (a clean one)
+        collection.db["#{collection_name}_new"].drop
+        new_collection = collection.db["#{collection_name}_new"]
+
+        # convert collection documents
+        collection.find({}, :timeout => false, :sort => "_id") do |cursor|
+           cursor.each do |doc|
+            new_doc = convert_ids(doc)
+            new_collection.insert(new_doc, :safe => true)
+          end
+        end
+
+        puts "Done! Converted collection is in #{new_collection.name}\n\n"
+      end
+
+      # no errors. great! now rename _new to collection_name
+      collection_names.each do |collection_name|
+        collection = Mongoid.master.collection(collection_name)
+        new_collection = collection.db["#{collection_name}_new"]
+
+        # swap collection to _old
+        puts "Moving #{collection.name} to #{collection_name}_old"
+        collection.db["#{collection_name}_old"].drop
+
+        begin
+          collection.rename("#{collection_name}_old")
+        rescue Exception => e
+          puts "Unable to rename database #{collection_name} to #{collection_name}_old"
+          puts "reason: #{e.message}\n\n"
+        end
+
+        # swap _new to collection
+        puts "Moving #{new_collection.name} to #{collection_name}\n\n"
+
+        begin
+          new_collection.rename(collection_name)
+        rescue Exception => e
+          puts "Unable to rename database #{new_collection.name} to #{collection_name}"
+          puts "reason: #{e.message}\n\n"
+        end
+      end
+
+      puts "DONE! Run `rake db:mongoid:cleanup_old_collections` to remove old collections"
+    end
+
+    desc "Clean up old collections backed up by objectid_convert"
+    task :cleanup_old_collections => :environment do
+      collection_names.each do |collection_name|
+        collection = Mongoid.master.collection(collection_name)
+        collection.db["#{collection.name}_old"].drop
+      end
+    end
+
+    ########
+    # TODO: lots more useful db tasks can be added here. stuff like copyDatabase, etc
+    ########
+  end
+
+end

data/lib/mongoid/railties/document.rb

@@ -0,0 +1,12 @@
+module Mongoid
+  module Document
+    # Used in conjunction with fields_for to build a form element for the
+    # destruction of this association. Always returns false because Mongoid
+    # only supports immediate deletion of associations.
+    #
+    # See ActionView::Helpers::FormHelper::fields_for for more info.
+    def _destroy
+      false
+    end
+  end
+end

data/lib/mongoid/relations.rb

@@ -0,0 +1,107 @@
+# encoding: utf-8
+require "mongoid/relations/accessors"
+require "mongoid/relations/auto_save"
+require "mongoid/relations/cascading"
+require "mongoid/relations/constraint"
+require "mongoid/relations/cyclic"
+require "mongoid/relations/proxy"
+require "mongoid/relations/bindings"
+require "mongoid/relations/builders"
+require "mongoid/relations/many"
+require "mongoid/relations/one"
+require "mongoid/relations/polymorphic"
+require "mongoid/relations/embedded/atomic"
+require "mongoid/relations/embedded/in"
+require "mongoid/relations/embedded/many"
+require "mongoid/relations/embedded/one"
+require "mongoid/relations/referenced/batch"
+require "mongoid/relations/referenced/in"
+require "mongoid/relations/referenced/many"
+require "mongoid/relations/referenced/many_to_many"
+require "mongoid/relations/referenced/one"
+require "mongoid/relations/reflections"
+require "mongoid/relations/metadata"
+require "mongoid/relations/macros"
+
+module Mongoid # :nodoc:
+
+  # All classes and modules under the relations namespace handle the
+  # functionality that has to do with embedded and referenced (relational)
+  # associations.
+  module Relations
+    extend ActiveSupport::Concern
+    include Accessors
+    include AutoSave
+    include Cascading
+    include Cyclic
+    include Builders
+    include Macros
+    include Polymorphic
+    include Reflections
+
+    included do
+      attr_accessor :metadata
+    end
+
+    # Determine if the document itself is embedded in another document via the
+    # proper channels. (If it has a parent document.)
+    #
+    # @example Is the document embedded?
+    #   address.embedded?
+    #
+    # @return [ true, false ] True if the document has a parent document.
+    #
+    # @since 2.0.0.rc.1
+    def embedded?
+      cyclic ? _parent.present? : self.class.embedded?
+    end
+
+    # Determine if the document is part of an embeds_many relation.
+    #
+    # @example Is the document in an embeds many?
+    #   address.embedded_many?
+    #
+    # @return [ true, false ] True if in an embeds many.
+    #
+    # @since 2.0.0.rc.1
+    def embedded_many?
+      metadata && metadata.macro == :embeds_many
+    end
+
+    # Determine if the document is part of an embeds_one relation.
+    #
+    # @example Is the document in an embeds one?
+    #   address.embedded_one?
+    #
+    # @return [ true, false ] True if in an embeds one.
+    #
+    # @since 2.0.0.rc.1
+    def embedded_one?
+      metadata && metadata.macro == :embeds_one
+    end
+
+    # Determine if the document is part of an references_many relation.
+    #
+    # @example Is the document in a references many?
+    #   post.referenced_many?
+    #
+    # @return [ true, false ] True if in a references many.
+    #
+    # @since 2.0.0.rc.1
+    def referenced_many?
+      metadata && metadata.macro == :references_many
+    end
+
+    # Determine if the document is part of an references_one relation.
+    #
+    # @example Is the document in a references one?
+    #   address.referenced_one?
+    #
+    # @return [ true, false ] True if in a references one.
+    #
+    # @since 2.0.0.rc.1
+    def referenced_one?
+      metadata && metadata.macro == :references_one
+    end
+  end
+end

data/lib/mongoid/relations/accessors.rb

@@ -0,0 +1,175 @@
+# encoding: utf-8
+module Mongoid # :nodoc:
+  module Relations #:nodoc:
+
+    # This module contains all the behaviour related to accessing relations
+    # through the getters and setters, and how to delegate to builders to
+    # create new ones.
+    module Accessors
+      extend ActiveSupport::Concern
+
+      # Builds the related document and creates the relation unless the
+      # document is nil, then sets the relation on this document.
+      #
+      # @example Build the relation.
+      #   person.build(:addresses, { :id => 1 }, metadata)
+      #
+      # @param [ String, Symbol ] name The name of the relation.
+      # @param [ Hash, BSON::ObjectId ] object The id or attributes to use.
+      # @param [ Metadata ] metadata The relation's metadata.
+      # @param [ true, false ] building If we are in a build operation.
+      #
+      # @return [ Proxy ] The relation.
+      #
+      # @since 2.0.0.rc.1
+      def build(name, object, metadata, options = {})
+        relation = create_relation(object, metadata)
+        set(name, relation).tap do |relation|
+          relation.load!(options) if relation && options[:eager]
+        end
+      end
+
+      # Return the options passed to the builders.
+      #
+      # @example Get the options.
+      #   person.configurables(document, :continue => true)
+      #
+      # @param [ Array ] args The arguments to check.
+      #
+      # @return [ Hash ] The options.
+      #
+      # @since 2.0.0.rc.1
+      def options(args)
+        Mongoid.binding_defaults.merge(args.extract_options!)
+      end
+
+      # Create a relation from an object and metadata.
+      #
+      # @example Create the relation.
+      #   person.create_relation(document, metadata)
+      #
+      # @param [ Document, Array<Document ] object The relation target.
+      # @param [ Metadata ] metadata The relation metadata.
+      #
+      # @return [ Proxy ] The relation.
+      #
+      # @since 2.0.0.rc.1
+      def create_relation(object, metadata)
+        type = @attributes[metadata.inverse_type]
+        target = metadata.builder(object).build(type)
+        target ? metadata.relation.new(self, target, metadata) : nil
+      end
+
+      # Determines if the relation exists or not.
+      #
+      # @example Does the relation exist?
+      #   person.relation_exists?(:people)
+      #
+      # @param [ String ] name The name of the relation to check.
+      #
+      # @return [ true, false ] True if set and not nil, false if not.
+      #
+      # @since 2.0.0.rc.1
+      def relation_exists?(name)
+        ivar(name)
+      end
+
+      # Set the supplied relation to an instance variable on the class with the
+      # provided name. Used as a helper just for code cleanliness.
+      #
+      # @example Set the proxy on the document.
+      #   person.set(:addresses, addresses)
+      #
+      # @param [ String, Symbol ] name The name of the relation.
+      # @param [ Proxy ] relation The relation to set.
+      #
+      # @return [ Proxy ] The relation.
+      #
+      # @since 2.0.0.rc.1
+      def set(name, relation)
+        instance_variable_set("@#{name}", relation)
+      end
+
+      # Replace an existing relation with a new one.
+      #
+      # @example Replace the relation.
+      #   document.substitute("addresses", Address.new)
+      #
+      # @param [ String ] name The name of the relation.
+      # @param [ Document ] object The document to replace with.
+      # @options [ Hash ] options The options.
+      #
+      # @since 2.0.0
+      def substitute(name, object, options)
+        set(name, ivar(name).substitute(object, options))
+      end
+
+      module ClassMethods #:nodoc:
+
+        # Defines the getter for the relation. Nothing too special here: just
+        # return the instance variable for the relation if it exists or build
+        # the thing.
+        #
+        # @example Set up the getter for the relation.
+        #   Person.getter("addresses", metadata)
+        #
+        # @param [ String, Symbol ] name The name of the relation.
+        # @param [ Metadata ] metadata The metadata for the relation.
+        #
+        # @return [ Class ] The class being set up.
+        #
+        # @since 2.0.0.rc.1
+        def getter(name, metadata)
+          tap do
+            define_method(name) do |*args|
+              reload, variable = args.first, "@#{name}"
+              options = options(args)
+              if instance_variable_defined?(variable) && !reload
+                instance_variable_get(variable)
+              else
+                build(
+                  name,
+                  @attributes[metadata.key],
+                  metadata,
+                  options.merge(:binding => true, :eager => metadata.embedded?)
+                )
+              end
+            end
+          end
+        end
+
+        # Defines the setter for the relation. This does a few things based on
+        # some conditions. If there is an existing association, a target
+        # substitution will take place, otherwise a new relation will be
+        # created with the supplied target.
+        #
+        # @example Set up the setter for the relation.
+        #   Person.setter("addresses", metadata)
+        #
+        # @param [ String, Symbol ] name The name of the relation.
+        # @param [ Metadata ] metadata The metadata for the relation.
+        #
+        # @return [ Class ] The class being set up.
+        #
+        # @since 2.0.0.rc.1
+        def setter(name, metadata)
+          tap do
+            define_method("#{name}=") do |*args|
+              object, options = args.first, options(args)
+              variable = "@#{name}"
+              if relation_exists?(name) && !object.is_a?(Hash)
+                substitute(name, object, options)
+              else
+                if metadata.embedded? && object.blank? && send(name)
+                  substitute(name, object, options)
+                else
+                  build(name, object, metadata, options.merge(:eager => true))
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end