stonegao-mongoid 2.0.0.rc.6

data/lib/mongoid/validations.rb

@@ -0,0 +1,117 @@
+# encoding: utf-8
+require "mongoid/validations/associated"
+require "mongoid/validations/uniqueness"
+
+module Mongoid #:nodoc:
+
+  # This module provides additional validations that ActiveModel does not
+  # provide: validates_associated and validates_uniqueness_of.
+  module Validations
+    extend ActiveSupport::Concern
+    include ActiveModel::Validations
+
+    attr_accessor :validated
+
+    # Overrides the default ActiveModel behaviour since we need to handle
+    # validations of relations slightly different than just calling the
+    # getter.
+    #
+    # @example Read the value.
+    #   person.read_attribute_for_validation(:addresses)
+    #
+    # @param [ Symbol ] attr The name of the field or relation.
+    #
+    # @return [ Object ] The value of the field or the relation.
+    #
+    # @since 2.0.0.rc.1
+    def read_attribute_for_validation(attr)
+      if relations[attr.to_s]
+        send(attr, false, :eager => true)
+      else
+        send(attr)
+      end
+    end
+
+    # Determine if the document is valid.
+    #
+    # @example Is the document valid?
+    #   person.valid?
+    #
+    # @example Is the document valid in a context?
+    #   person.valid?(:create)
+    #
+    # @param [ Symbol ] context The optional validation context.
+    #
+    # @return [ true, false ] True if valid, false if not.
+    #
+    # @since 2.0.0.rc.6
+    def valid?(context = nil)
+      super context ? context : (new? ? :create : :update)
+    end
+
+    # Used to prevent infinite loops in associated validations.
+    #
+    # @example Is the document validated?
+    #   document.validated?
+    #
+    # @return [ true, false ] Has the document already been validated?
+    #
+    # @since 2.0.0.rc.2
+    def validated?
+      !!@validated
+    end
+
+    module ClassMethods #:nodoc:
+
+      # Validates whether or not an association is valid or not. Will correctly
+      # handle has one and has many associations.
+      #
+      # @example
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     embeds_one :name
+      #     embeds_many :addresses
+      #
+      #     validates_associated :name, :addresses
+      #   end
+      #
+      # @param [ Array ] *args The arguments to pass to the validator.
+      def validates_associated(*args)
+        validates_with(AssociatedValidator, _merge_attributes(args))
+      end
+
+      # Validates whether or not a field is unique against the documents in the
+      # database.
+      #
+      # @example
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     field :title
+      #
+      #     validates_uniqueness_of :title
+      #   end
+      #
+      # @param [ Array ] *args The arguments to pass to the validator.
+      def validates_uniqueness_of(*args)
+        validates_with(UniquenessValidator, _merge_attributes(args))
+      end
+
+      protected
+
+      # Adds an associated validator for the relation if the validate option
+      # was not provided or set to true.
+      #
+      # @example Set up validation.
+      #   Person.validate_relation(metadata)
+      #
+      # @param [ Metadata ] metadata The relation metadata.
+      #
+      # @since 2.0.0.rc.1
+      def validate_relation(metadata)
+        validates_associated(metadata.name) if metadata.validate?
+      end
+    end
+  end
+end

data/lib/mongoid/version.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  VERSION = "2.0.0.rc.6"
+end

data/lib/mongoid/versioning.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  # Include this module to get automatic versioning of root level documents.
+  # This will add a version field to the +Document+ and a has_many association
+  # with all the versions contained in it.
+  module Versioning
+    extend ActiveSupport::Concern
+
+    included do
+      field :version, :type => Integer, :default => 1
+      embeds_many :versions, :class_name => self.name, :validate => false
+      set_callback :save, :before, :revise
+
+      delegate :version_max, :to => "self.class"
+    end
+
+    # Create a new version of the +Document+. This will load the previous
+    # document from the database and set it as the next version before saving
+    # the current document. It then increments the version number. If a #max_versions
+    # limit is set in the model and it's exceeded, the oldest version gets discarded.
+    #
+    # @example Revise the document.
+    #   person.revise
+    def revise
+      last_version = self.class.first(:conditions => { :_id => id, :version => version })
+      if last_version
+        versions.target << last_version.clone
+        versions.shift if version_max.present? && versions.length > version_max
+        self.version = (version || 1 ) + 1
+        @modifications["versions"] = [ nil, versions.to_hash ] if @modifications
+      end
+    end
+
+    module ClassMethods #:nodoc:
+      attr_accessor :version_max
+
+      # Sets the maximum number of versions to store.
+      #
+      # @example Set the maximum.
+      #   Person.max_versions(5)
+      #
+      # @param [ Integer ] number The maximum number to store.
+      #
+      # @return [ Integer ] The max number of versions.
+      def max_versions(number)
+        self.version_max = number.to_i
+      end
+    end
+  end
+end

data/lib/mongoid.rb

@@ -0,0 +1,139 @@
+# encoding: utf-8
+
+# Copyright (c) 2009 - 2011 Durran Jordan and friends.
+#
+# 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 "delegate"
+require "time"
+require "ostruct"
+require "active_support/core_ext"
+require 'active_support/json'
+require "active_support/inflector"
+require "active_support/time_with_zone"
+require "active_model"
+require "active_model/callbacks"
+require "active_model/conversion"
+require "active_model/errors"
+require "active_model/mass_assignment_security"
+require "active_model/naming"
+require "active_model/serialization"
+require "active_model/translation"
+require "active_model/validator"
+require "active_model/validations"
+require "will_paginate/collection"
+require "mongo"
+require "mongoid/errors"
+require "mongoid/extensions"
+require "mongoid/safe"
+require "mongoid/atomicity"
+require "mongoid/attributes"
+require "mongoid/callbacks"
+require "mongoid/collection"
+require "mongoid/collections"
+require "mongoid/config"
+require "mongoid/contexts"
+require "mongoid/copyable"
+require "mongoid/criteria"
+require "mongoid/cursor"
+require "mongoid/default_scope"
+require "mongoid/dirty"
+require "mongoid/extras"
+require "mongoid/factory"
+require "mongoid/field"
+require "mongoid/fields"
+require "mongoid/finders"
+require "mongoid/hierarchy"
+require "mongoid/identity"
+require "mongoid/indexes"
+require "mongoid/inspection"
+require "mongoid/javascript"
+require "mongoid/json"
+require "mongoid/keys"
+require "mongoid/logger"
+require "mongoid/matchers"
+require "mongoid/modifiers"
+require "mongoid/multi_parameter_attributes"
+require "mongoid/multi_database"
+require "mongoid/named_scope"
+require "mongoid/nested_attributes"
+require "mongoid/paths"
+require "mongoid/persistence"
+require "mongoid/relations"
+require "mongoid/safety"
+require "mongoid/scope"
+require "mongoid/serialization"
+require "mongoid/state"
+require "mongoid/timestamps"
+require "mongoid/validations"
+require "mongoid/versioning"
+require "mongoid/components"
+require "mongoid/paranoia"
+require "mongoid/document"
+
+# add railtie
+if defined?(Rails)
+  require "mongoid/railtie"
+end
+
+# add english load path by default
+I18n.load_path << File.join(File.dirname(__FILE__), "config", "locales", "en.yml")
+
+module Mongoid #:nodoc
+
+  MONGODB_VERSION = "1.6.0"
+
+  class << self
+
+    # Sets the Mongoid configuration options. Best used by passing a block.
+    #
+    # @example Set up configuration options.
+    #
+    #   Mongoid.configure do |config|
+    #     name = "mongoid_test"
+    #     host = "localhost"
+    #     config.allow_dynamic_fields = false
+    #     config.master = Mongo::Connection.new.db(name)
+    #     config.slaves = [
+    #       Mongo::Connection.new(host, 27018, :slave_ok => true).db(name),
+    #       Mongo::Connection.new(host, 27019, :slave_ok => true).db(name)
+    #     ]
+    #   end
+    #
+    # @return [ Config ] The configuration obejct.
+    def configure
+      config = Mongoid::Config
+      block_given? ? yield(config) : config
+    end
+    alias :config :configure
+  end
+
+  # Take all the public instance methods from the Config singleton and allow
+  # them to be accessed through the Mongoid module directly.
+  #
+  # @example Delegate the configuration methods.
+  #   Mongoid.database = Mongo::Connection.new.db("test")
+  Mongoid::Config.public_instance_methods(false).each do |name|
+    (class << self; self; end).class_eval <<-EOT
+      def #{name}(*args)
+        configure.send("#{name}", *args)
+      end
+    EOT
+  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,23 @@
+defaults: &defaults
+  host: localhost
+  # slaves:
+  #   - host: slave1.local
+  #     port: 27018
+  #   - host: slave2.local
+  #     port: 27019
+
+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:
+  host: <%%= ENV['MONGOID_HOST'] %>
+  port: <%%= ENV['MONGOID_PORT'] %>
+  username: <%%= ENV['MONGOID_USERNAME'] %>
+  password: <%%= ENV['MONGOID_PASSWORD'] %>
+  database: <%%= ENV['MONGOID_DATABASE'] %>

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

@@ -0,0 +1,24 @@
+# encoding: utf-8
+require "rails/generators/mongoid_generator"
+
+module Mongoid #:nodoc:
+  module Generators #:nodoc:
+    class ModelGenerator < Base #:nodoc:
+
+      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"
+
+      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/mongoid/model/templates/model.rb

@@ -0,0 +1,17 @@
+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[:versioning] -%>
+  include Mongoid::Versioning
+<% 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%>, :inverse_of => :<%= class_name.tableize %>
+<% end -%>
+end

data/lib/rails/generators/mongoid_generator.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+require "rails/generators/named_base"
+require "rails/generators/active_model"
+
+module Mongoid #:nodoc:
+  module Generators #:nodoc:
+    class Base < ::Rails::Generators::NamedBase #:nodoc:
+
+      def self.source_root
+        @_mongoid_source_root ||=
+        File.expand_path("../#{base_name}/#{generator_name}/templates", __FILE__)
+      end
+    end
+
+    class ActiveModel < ::Rails::Generators::ActiveModel #:nodoc:
+      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 destroy
+        "#{name}.destroy"
+      end
+    end
+  end
+end
+
+module Rails
+  module Generators
+    class GeneratedAttribute #:nodoc:
+      def type_class
+        return "Time" if type.to_s == "datetime"
+        return "String" if type.to_s == "text"
+        return type.to_s.camelcase
+      end
+    end
+  end
+end

data/lib/rails/mongoid.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+module Rails #:nodoc:
+  module Mongoid #:nodoc:
+    extend self
+
+    # 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|
+        Dir.glob("#{path}/**/*.rb").sort.each do |file|
+          load_model(file.gsub("#{path}/" , "").gsub(".rb", ""))
+        end
+      end
+    end
+
+    # Recursive function to create all the indexes for the model, then
+    # potentially and subclass of the model since both are still root
+    # documents in the hierarchy.
+    #
+    # Note there is a tricky naming scheme going on here that needs to be
+    # revisisted. Module.descendants vs Class.descendents is way too
+    # confusing.
+    #
+    # @example Index the children.
+    #   Rails::Mongoid.index_children(classes)
+    #
+    # @param [ Array<Class> ] children The child model classes.
+    def index_children(children)
+      children.each do |model|
+        Logger.new($stdout).info("Generating indexes for #{model}")
+        model.create_indexes
+        index_children(model.descendants)
+      end
+    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)
+      require_dependency(file)
+    end
+  end
+end