mongoid_rails4 4.0.0

data/lib/rack/mongoid.rb

@@ -0,0 +1,2 @@
+# encoding: utf-8
+require "rack/mongoid/middleware/identity_map"

data/lib/rack/mongoid/middleware/identity_map.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+module Rack
+  module Mongoid
+    module Middleware
+
+      # This middleware contains the behaviour needed to properly use the
+      # identity map in Rack based applications. This middleware will properly
+      # handle Rails or Rack streaming responses.
+      class IdentityMap
+
+        # Initialize the new middleware.
+        #
+        # @example Init the middleware.
+        #   IdentityMap.new(app)
+        #
+        # @param [ Object ] app The application.
+        #
+        # @since 2.1.0
+        def initialize(app)
+          @app = app
+        end
+
+        # Make the request with the provided environment.
+        #
+        # @example Make the request.
+        #   identity_map.call(env)
+        #
+        # @param [ Object ] env The environment.
+        #
+        # @return [ Array ] The status, headers, and response.
+        #
+        # @since 2.1.0
+        def call(env)
+          ::Mongoid.unit_of_work { @app.call(env) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# encoding: utf-8
+require 'rails/generators/mongoid_generator'
+
+module Mongoid
+  module Generators
+    class ConfigGenerator < Rails::Generators::Base
+      desc "Creates a Mongoid configuration file at config/mongoid.yml"
+
+      argument :database_name, type: :string, optional: true
+
+      def self.source_root
+        @_mongoid_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 'mongoid.yml', File.join('config', "mongoid.yml")
+      end
+
+    end
+  end
+end

data/lib/rails/generators/mongoid/config/templates/mongoid.yml

@@ -0,0 +1,76 @@
+development:
+  # Configure available database sessions. (required)
+  sessions:
+    # Defines the default session. (required)
+    default:
+      # Defines the name of the default database that Mongoid can connect to.
+      # (required).
+      database: <%= database_name || app_name %>_development
+      # Provides the hosts the default session can connect to. Must be an array
+      # of host:port pairs. (required)
+      hosts:
+        - localhost:27017
+      options:
+        # Change whether the session persists in safe mode by default.
+        # (default: false)
+        # safe: false
+
+        # Change the default consistency model to :eventual or :strong.
+        # :eventual will send reads to secondaries, :strong sends everything
+        # to master. (default: :eventual)
+        # consistency: :eventual
+
+        # How many times Moped should attempt to retry an operation after
+        # failure. (default: 30)
+        # max_retries: 30
+
+        # The time in seconds that Moped should wait before retrying an
+        # operation on failure. (default: 1)
+        # retry_interval: 1
+  # Configure Mongoid specific options. (optional)
+  options:
+    # Enable the identity map, needed for eager loading. (default: false)
+    # identity_map_enabled: false
+
+    # Includes the root model name in json serialization. (default: false)
+    # include_root_in_json: false
+
+    # Include the _type field in serializaion. (default: false)
+    # include_type_for_serialization: false
+
+    # Preload all models in development, needed when models use
+    # inheritance. (default: false)
+    # preload_models: false
+
+    # Protect id and type from mass assignment. (default: true)
+    # protect_sensitive_fields: true
+
+    # Raise an error when performing a #find and the document is not found.
+    # (default: true)
+    # raise_not_found_error: true
+
+    # Raise an error when defining a scope with the same name as an
+    # existing method. (default: false)
+    # scope_overwrite_exception: false
+
+    # Skip the database version check, used when connecting to a db without
+    # admin access. (default: false)
+    # skip_version_check: false
+
+    # User Active Support's time zone in conversions. (default: true)
+    # use_activesupport_time_zone: true
+
+    # Ensure all times are UTC in the app side. (default: false)
+    # use_utc: false
+test:
+  sessions:
+    default:
+      database: <%= database_name || app_name %>_test
+      hosts:
+        - localhost:27017
+      options:
+        consistency: :strong
+        # In the test environment we lower the retries and retry interval to
+        # low amounts for fast failures.
+        max_retries: 1
+        retry_interval: 0

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

@@ -0,0 +1,25 @@
+# encoding: utf-8
+require "rails/generators/mongoid_generator"
+
+module Mongoid
+  module Generators
+    class ModelGenerator < Base
+
+      desc "Creates a Mongoid model"
+      argument :attributes, type: :array, default: [], banner: "field:type field:type"
+
+      check_class_collision
+
+      class_option :timestamps, type: :boolean
+      class_option :parent,     type: :string, desc: "The parent class for the generated model"
+      class_option :versioning, type: :boolean, default: false, desc: "Enable mongoid versioning"
+      class_option :collection, type: :string, desc: "The collection for storing model's documents"
+
+      def create_model_file
+        template "model.rb.tt", File.join("app/models", class_path, "#{file_name}.rb")
+      end
+
+      hook_for :test_framework
+    end
+  end
+end

data/lib/rails/generators/mongoid/model/templates/model.rb.tt

@@ -0,0 +1,19 @@
+<% module_namespacing do -%>
+class <%= class_name %><%= " < #{options[:parent].classify}" if options[:parent] %>
+<% unless options[:parent] -%>
+  include Mongoid::Document
+<% end -%>
+<% if options[:timestamps] -%>
+  include Mongoid::Timestamps
+<% end -%>
+<% if options[:collection] -%>
+  store_in collection: "<%= options[:collection] %>"
+<% end -%>
+<% attributes.reject{|attr| attr.reference?}.each do |attribute| -%>
+  field :<%= attribute.name %>, type: <%= attribute.type_class %>
+<% end -%>
+<% attributes.select{|attr| attr.reference? }.each do |attribute| -%>
+  embedded_in :<%= attribute.name%>
+<% end -%>
+end
+<% end -%>

data/lib/rails/generators/mongoid/observer/observer_generator.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+require "rails/generators/mongoid_generator"
+
+module Mongoid
+  module Generators
+    class ObserverGenerator < Base
+
+      check_class_collision suffix: "Observer"
+
+      def create_observer_file
+        template 'observer.rb.tt', File.join('app/models', class_path, "#{file_name}_observer.rb")
+      end
+
+      hook_for :test_framework
+    end
+  end
+end

data/lib/rails/generators/mongoid/observer/templates/observer.rb.tt

@@ -0,0 +1,4 @@
+<% module_namespacing do -%>
+class <%= class_name %>Observer < Mongoid::Observer
+end
+<% end -%>

data/lib/rails/generators/mongoid_generator.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+require "rails/generators/named_base"
+require "rails/generators/active_model"
+
+module Mongoid
+  module Generators
+    class Base < ::Rails::Generators::NamedBase
+
+      def self.source_root
+        @_mongoid_source_root ||=
+          File.expand_path("../#{base_name}/#{generator_name}/templates", __FILE__)
+      end
+    end
+
+    class ActiveModel < ::Rails::Generators::ActiveModel
+      def self.all(klass)
+        "#{klass}.all"
+      end
+
+      def self.find(klass, params=nil)
+        "#{klass}.find(#{params})"
+      end
+
+      def self.build(klass, params=nil)
+        if params
+          "#{klass}.new(#{params})"
+        else
+          "#{klass}.new"
+        end
+      end
+
+      def save
+        "#{name}.save"
+      end
+
+      def update_attributes(params=nil)
+        "#{name}.update_attributes(#{params})"
+      end
+
+      def errors
+        "#{name}.errors"
+      end
+
+      def delete
+        "#{name}.delete"
+      end
+
+      def destroy
+        "#{name}.destroy"
+      end
+    end
+  end
+end
+
+module Rails
+  module Generators
+    class GeneratedAttribute
+      def type_class
+        return "Time" if type.to_s == "datetime"
+        return "String" if type.to_s == "text"
+        type.to_s.camelcase
+      end
+    end
+  end
+end

data/lib/rails/mongoid.rb

@@ -0,0 +1,180 @@
+# encoding: utf-8
+module Rails
+  module Mongoid
+    extend self
+
+    # Create indexes for each model given the provided globs and the class is
+    # not embedded.
+    #
+    # @example Create all the indexes.
+    #   Rails::Mongoid.create_indexes
+    #
+    # @return [ Array<Class> ] The indexed models.
+    #
+    # @since 2.1.0
+    def create_indexes
+      ::Mongoid.models.each do |model|
+        next if model.index_specifications.empty?
+        unless model.embedded?
+          model.create_indexes
+          logger.info("MONGOID: Created indexes on #{model}:")
+          model.index_specifications.each do |spec|
+            logger.info("MONGOID: Index: #{spec.key}, Options: #{spec.options}")
+          end
+          model
+        else
+          logger.info("MONGOID: Index ignored on: #{model}, please define in the root model.")
+          nil
+        end
+      end.compact
+    end
+
+    # Return the list of indexes by model that exist in the database but aren't
+    # specified on the models.
+    #
+    # @example Return the list of unused indexes.
+    #   Rails::Mongoid.undefined_indexes
+    #
+    # @return Hash{Class => Array(Hash)} The list of undefined indexes by model.
+    def undefined_indexes
+      undefined_by_model = {}
+
+      ::Mongoid.models.each do |model|
+        unless model.embedded?
+          model.collection.indexes.each do |index|
+            # ignore default index
+            unless index['name'] == '_id_'
+              key = index['key'].symbolize_keys
+              spec = model.index_specification(key)
+              unless spec
+                # index not specified
+                undefined_by_model[model] ||= []
+                undefined_by_model[model] << index
+              end
+            end
+          end
+        end
+      end
+
+      undefined_by_model
+    end
+
+    # Remove indexes that exist in the database but aren't specified on the
+    # models.
+    #
+    # @example Remove undefined indexes.
+    #   Rails::Mongoid.remove_undefined_indexes
+    #
+    # @return [ Hash{Class => Array(Hash)}] The list of indexes that were removed by model.
+    #
+    # @since 4.0.0
+    def remove_undefined_indexes
+      undefined_indexes.each do |model, indexes|
+        indexes.each do |index|
+          key = index['key'].symbolize_keys
+          model.collection.indexes.drop(key)
+          logger.info("MONGOID: Removing index: #{index['name']} on #{model}.")
+        end
+      end
+    end
+
+    # Remove indexes for each model given the provided globs and the class is
+    # not embedded.
+    #
+    # @example Remove all the indexes.
+    #   Rails::Mongoid.remove_indexes
+    #
+    # @return [ Array<Class> ] The un-indexed models.
+    #
+    def remove_indexes
+      ::Mongoid.models.each do |model|
+        next if model.embedded?
+        indexes = model.collection.indexes.map{ |doc| doc["name"] }
+        indexes.delete_one("_id_")
+        model.remove_indexes
+        logger.info("MONGOID: Removing indexes on: #{model} for: #{indexes.join(', ')}.")
+        model
+      end.compact
+    end
+
+    # Use the application configuration to get every model and require it, so
+    # that indexing and inheritance work in both development and production
+    # with the same results.
+    #
+    # @example Load all the application models.
+    #   Rails::Mongoid.load_models(app)
+    #
+    # @param [ Application ] app The rails application.
+    def load_models(app)
+      app.config.paths["app/models"].each do |path|
+        preload = ::Mongoid.preload_models
+        if preload.resizable?
+          files = preload.map { |model| "#{path}/#{model}.rb" }
+        else
+          files = Dir.glob("#{path}/**/*.rb")
+        end
+
+        files.sort.each do |file|
+          load_model(file.gsub("#{path}/" , "").gsub(".rb", ""))
+        end
+      end
+    end
+
+    # Conditionally calls `Rails::Mongoid.load_models(app)` if the
+    # `::Mongoid.preload_models` is `true`.
+    #
+    # @param [ Application ] app The rails application.
+    def preload_models(app)
+      load_models(app) if ::Mongoid.preload_models
+    end
+
+    private
+
+    # I don't want to mock out kernel for unit testing purposes, so added this
+    # method as a convenience.
+    #
+    # @example Load the model.
+    #   Mongoid.load_model("/mongoid/behaviour")
+    #
+    # @param [ String ] file The base filename.
+    #
+    # @since 2.0.0.rc.3
+    def load_model(file)
+      begin
+        require_dependency(file)
+      rescue Exception => e
+        Logger.new($stdout).warn(e.message)
+      end
+    end
+
+    # Given the provided file name, determine the model and return the class.
+    #
+    # @example Determine the model from the file.
+    #   Rails::Mongoid.determine_model("app/models/person.rb")
+    #
+    # @param [ String ] file The filename.
+    #
+    # @return [ Class ] The model.
+    #
+    # @since 2.1.0
+    def determine_model(file, logger)
+      return nil unless file =~ /app\/models\/(.*).rb$/
+      return nil unless logger
+
+      model_path = $1.split('/')
+      begin
+        parts = model_path.map { |path| path.camelize }
+        name = parts.join("::")
+        klass = name.constantize
+      rescue NameError, LoadError
+        logger.info("MONGOID: Attempted to constantize #{name}, trying without namespacing.")
+        klass = parts.last.constantize rescue nil
+      end
+      klass if klass && klass.ancestors.include?(::Mongoid::Document)
+    end
+
+    def logger
+      @logger ||= Logger.new($stdout)
+    end
+  end
+end