mongoid-multi-db 3.0.0

data/lib/mongoid/extensions/string/conversions.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module String #:nodoc:
+      module Conversions #:nodoc:
+        extend ActiveSupport::Concern
+
+        # Convert the string to an array with the string in it.
+        #
+        # @example Convert the string to an array.
+        #   "Testing".to_a
+        #
+        # @return [ Array ] An array with only the string in it.
+        #
+        # @since 1.0.0
+        def to_a
+          [ self ]
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/extensions/string/inflections.rb

@@ -0,0 +1,118 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module String #:nodoc:
+
+      # This module contains convenience methods for string inflection and
+      # conversion.
+      module Inflections
+
+        ActiveSupport::Inflector.inflections do |inflect|
+          inflect.singular(/address$/, "address")
+          inflect.singular("addresses", "address")
+          inflect.irregular("canvas", "canvases")
+        end
+
+        # Represents how special characters will get converted when creating a
+        # composite key that should be unique and part of a url.
+        CHAR_CONV = {
+          " " => "-",
+          "!" => "-excl-",
+          "\"" => "-dblquo-",
+          "#" => "-hash-",
+          "$" => "-dol-",
+          "%" => "-perc-",
+          "&" => "-and-",
+          "'" => "-quo-",
+          "(" => "-oparen-",
+          ")" => "-cparen-",
+          "*" => "-astx-",
+          "+" => "-plus-",
+          "," => "-comma-",
+          "-" => "-",
+          "." => "-period-",
+          "/" => "-fwdslsh-",
+          ":" => "-colon-",
+          ";" => "-semicol-",
+          "<" => "-lt-",
+          "=" => "-eq-",
+          ">" => "-gt-",
+          "?" => "-ques-",
+          "@" => "-at-",
+          "[" => "-obrck-",
+          "\\" => "-bckslsh-",
+          "]" => "-clbrck-",
+          "^" => "-carat-",
+          "_" => "-undscr-",
+          "`" => "-bcktick-",
+          "{" => "-ocurly-",
+          "|" => "-pipe-",
+          "}" => "-clcurly-",
+          "~" => "-tilde-"
+        }
+
+        REVERSALS = {
+          "asc" => "desc",
+          "ascending" => "descending",
+          "desc" => "asc",
+          "descending" => "ascending"
+        }
+
+        # Convert the string to a collection friendly name.
+        #
+        # @example Collectionize the string.
+        #   "namespace/model".collectionize
+        #
+        # @return [ String ] The string in collection friendly form.
+        def collectionize
+          tableize.gsub("/", "_")
+        end
+
+        # Convert this string to a key friendly string.
+        #
+        # @example Convert to key.
+        #   "testing".identify
+        #
+        # @return [ String ] The key friendly string.
+        def identify
+          if Mongoid.parameterize_keys
+            key = ""
+            each_char { |c| key += (CHAR_CONV[c] || c.downcase) }; key
+          else
+            self
+          end
+        end
+
+        # Get the inverted sorting option.
+        #
+        # @example Get the inverted option.
+        #   "asc".invert
+        #
+        # @return [ String ] The string inverted.
+        def invert
+          REVERSALS[self]
+        end
+
+        # Get the string as a getter string.
+        #
+        # @example Get the reader/getter
+        #   "model=".reader
+        #
+        # @return [ String ] The string stripped of "=".
+        def reader
+          writer? ? gsub("=", "") : self
+        end
+
+        # Is this string a writer?
+        #
+        # @example Is the string a setter method?
+        #   "model=".writer?
+        #
+        # @return [ true, false ] If the string contains "=".
+        def writer?
+          include?("=")
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/extensions/symbol/checks.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module Symbol #:nodoc:
+
+      # This module has object checks in it.
+      module Checks #:nodoc:
+
+        # Is the symbol a valid value for a Mongoid id?
+        #
+        # @example Is the string an id value?
+        #   :_id.mongoid_id?
+        #
+        # @return [ true, false ] If the symbol is :id or :_id.
+        #
+        # @since 2.3.1
+        def mongoid_id?
+          to_s =~ /^(|_)id$/
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/extensions/symbol/inflections.rb

@@ -0,0 +1,66 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module Symbol #:nodoc:
+
+      # This module contains convenience methods for symbol inflection and
+      # conversion.
+      module Inflections
+
+        REVERSALS = {
+          :asc => :desc,
+          :ascending => :descending,
+          :desc => :asc,
+          :descending => :ascending
+        }
+
+        # Get the inverted sorting option.
+        #
+        # @example Get the inverted option.
+        #   :asc.invert
+        #
+        # @return [ String ] The string inverted.
+        def invert
+          REVERSALS[self]
+        end
+
+        # Define all the necessary methods on symbol to support Mongoid's
+        # complex criterion.
+        #
+        # @example A greater than criterion.
+        #   :field.gt => 5
+        #
+        # @return [ Criterion::Complex ] The criterion.
+        #
+        # @since 1.0.0
+        [
+          "all",
+          "asc",
+          "ascending",
+          "desc",
+          "descending",
+          "exists",
+          "gt",
+          "gte",
+          "in",
+          "lt",
+          "lte",
+          "mod",
+          "ne",
+          "near",
+          "nin",
+          "size",
+          "within",
+          ["matches","elemMatch"] ].each do |oper|
+          m, oper = oper
+          oper = m unless oper
+          class_eval <<-OPERATORS
+            def #{m}
+              Criterion::Complex.new(:key => self, :operator => "#{oper}")
+            end
+          OPERATORS
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/extensions/true_class/equality.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module TrueClass #:nodoc:
+
+      # Adds equality hooks for true values.
+      module Equality
+
+        # Is the passed value a boolean?
+        #
+        # @example Is the value a boolean type?
+        #   true.is_a?(Boolean)
+        #
+        # @param [ Class ] other The class to check.
+        #
+        # @return [ true, false ] If the other is a boolean.
+        #
+        # @since 1.0.0
+        def is_a?(other)
+          return true if other.name == "Boolean"
+          super(other)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/extras.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  # Adds support for caching queries at the class level.
+  module Extras
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :cached
+      self.cached = false
+    end
+
+    module ClassMethods #:nodoc
+
+      # Sets caching on for this class. This class level configuration will
+      # default all queries to cache the results of the first iteration over
+      # the cursor into an internal array. This should only be used for queries
+      # that return a small number of results or have small documents, as after
+      # the first iteration the entire results will be stored in memory.
+      #
+      # @example Cache all reads for the class.
+      #   class Person
+      #     include Mongoid::Document
+      #     cache
+      #   end
+      def cache
+        self.cached = true
+      end
+    end
+  end
+end

data/lib/mongoid/factory.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  # Instantiates documents that came from the database.
+  module Factory
+    extend self
+
+    # Builds a new +Document+ from the supplied attributes.
+    #
+    # @example Build the document.
+    #   Mongoid::Factory.build(Person, { "name" => "Durran" })
+    #
+    # @param [ Class ] klass The class to instantiate from if _type is not present.
+    # @param [ Hash ] attributes The document attributes.
+    # @param [ Hash ] optiosn The mass assignment scoping options.
+    #
+    # @return [ Document ] The instantiated document.
+    def build(klass, attributes = {}, options = {})
+      type = (attributes || {})["_type"]
+      if type && klass._types.include?(type)
+        type.constantize.new(attributes, options)
+      else
+        klass.new(attributes, options)
+      end
+    end
+
+    # Builds a new +Document+ from the supplied attributes loaded from the
+    # database.
+    #
+    # @example Build the document.
+    #   Mongoid::Factory.from_db(Person, { "name" => "Durran" })
+    #
+    # @param [ Class ] klass The class to instantiate from if _type is not present.
+    # @param [ Hash ] attributes The document attributes.
+    #
+    # @return [ Document ] The instantiated document.
+    def from_db(klass, attributes = {})
+      type = attributes["_type"]
+      if type.blank?
+        klass.instantiate(attributes)
+      else
+        type.camelize.constantize.instantiate(attributes)
+      end
+    end
+  end
+end

data/lib/mongoid/fields.rb

@@ -0,0 +1,332 @@
+# encoding: utf-8
+require "mongoid/fields/mappings"
+require "mongoid/fields/serializable"
+require "mongoid/fields/serializable/timekeeping"
+require "mongoid/fields/serializable/array"
+require "mongoid/fields/serializable/big_decimal"
+require "mongoid/fields/serializable/binary"
+require "mongoid/fields/serializable/boolean"
+require "mongoid/fields/serializable/date"
+require "mongoid/fields/serializable/date_time"
+require "mongoid/fields/serializable/float"
+require "mongoid/fields/serializable/hash"
+require "mongoid/fields/serializable/integer"
+require "mongoid/fields/serializable/bignum"
+require "mongoid/fields/serializable/fixnum"
+require "mongoid/fields/serializable/localized"
+require "mongoid/fields/serializable/nil_class"
+require "mongoid/fields/serializable/object"
+require "mongoid/fields/serializable/object_id"
+require "mongoid/fields/serializable/range"
+require "mongoid/fields/serializable/set"
+require "mongoid/fields/serializable/string"
+require "mongoid/fields/serializable/symbol"
+require "mongoid/fields/serializable/time"
+require "mongoid/fields/serializable/time_with_zone"
+require "mongoid/fields/serializable/foreign_keys/array"
+require "mongoid/fields/serializable/foreign_keys/object"
+
+module Mongoid #:nodoc
+
+  # This module defines behaviour for fields.
+  module Fields
+    extend ActiveSupport::Concern
+
+    included do
+      field(:_type, :type => String)
+      field(:_id, :type => BSON::ObjectId)
+
+      alias :id :_id
+      alias :id= :_id=
+    end
+
+    # Get the default fields.
+    #
+    # @note Refactored from using delegate for class load performance.
+    #
+    # @example Get the defaults.
+    #   model.defaults
+    #
+    # @return [ Array<String> ] The default field names.
+    def defaults
+      self.class.defaults
+    end
+
+    # Get the document's fields.
+    #
+    # @note Refactored from using delegate for class load performance.
+    #
+    # @example Get the fields.
+    #   model.fields
+    #
+    # @return [ Hash ] The fields.
+    def fields
+      self.class.fields
+    end
+
+    class << self
+
+      # Stores the provided block to be run when the option name specified is
+      # defined on a field.
+      #
+      # No assumptions are made about what sort of work the handler might
+      # perform, so it will always be called if the `option_name` key is
+      # provided in the field definition -- even if it is false or nil.
+      #
+      # @example
+      #   Mongoid::Fields.option :required do |model, field, value|
+      #     model.validates_presence_of field if value
+      #   end
+      #
+      # @param [ Symbol ] option_name the option name to match against
+      # @param [ Proc ] block the handler to execute when the option is
+      #   provided.
+      #
+      # @since 2.1.0
+      def option(option_name, &block)
+        options[option_name] = block
+      end
+
+      # Return a map of custom option names to their handlers.
+      #
+      # @example
+      #   Mongoid::Fields.options
+      #   # => { :required => #<Proc:0x00000100976b38> }
+      #
+      # @return [ Hash ] the option map
+      #
+      # @since 2.1.0
+      def options
+        @options ||= {}
+      end
+    end
+
+    module ClassMethods #:nodoc
+
+      # Returns the default values for the fields on the document.
+      #
+      # @example Get the defaults.
+      #   Person.defaults
+      #
+      # @return [ Hash ] The field defaults.
+      def defaults
+        @defaults ||= []
+      end
+
+      # Set the defaults for the class.
+      #
+      # @example Set the defaults.
+      #   Person.defaults = defaults
+      #
+      # @param [ Array ] defaults The array of defaults to set.
+      #
+      # @since 2.0.0.rc.6
+      def defaults=(defaults)
+        @defaults = defaults
+      end
+
+      # Defines all the fields that are accessible on the Document
+      # For each field that is defined, a getter and setter will be
+      # added as an instance method to the Document.
+      #
+      # @example Define a field.
+      #   field :score, :type => Integer, :default => 0
+      #
+      # @param [ Symbol ] name The name of the field.
+      # @param [ Hash ] options The options to pass to the field.
+      #
+      # @option options [ Class ] :type The type of the field.
+      # @option options [ String ] :label The label for the field.
+      # @option options [ Object, Proc ] :default The field's default
+      #
+      # @return [ Field ] The generated field
+      def field(name, options = {})
+        check_field_name!(name)
+        add_field(name.to_s, options)
+      end
+
+      # Return the fields for this class.
+      #
+      # @example Get the fields.
+      #   Person.fields
+      #
+      # @return [ Hash ] The fields for this document.
+      #
+      # @since 2.0.0.rc.6
+      def fields
+        @fields ||= {}
+      end
+
+      # Set the fields for the class.
+      #
+      # @example Set the fields.
+      #   Person.fields = fields
+      #
+      # @param [ Hash ] fields The hash of fields to set.
+      #
+      # @since 2.0.0.rc.6
+      def fields=(fields)
+        @fields = fields
+      end
+
+      # When inheriting, we want to copy the fields from the parent class and
+      # set the on the child to start, mimicking the behaviour of the old
+      # class_inheritable_accessor that was deprecated in Rails edge.
+      #
+      # @example Inherit from this class.
+      #   Person.inherited(Doctor)
+      #
+      # @param [ Class ] subclass The inheriting class.
+      #
+      # @since 2.0.0.rc.6
+      def inherited(subclass)
+        super
+        subclass.defaults, subclass.fields = defaults.dup, fields.dup
+      end
+
+      # Is the field with the provided name a BSON::ObjectId?
+      #
+      # @example Is the field a BSON::ObjectId?
+      #   Person.object_id_field?(:name)
+      #
+      # @param [ String, Symbol ] name The name of the field.
+      #
+      # @return [ true, false ] If the field is a BSON::ObjectId.
+      #
+      # @since 2.2.0
+      def object_id_field?(name)
+        field_name = name.to_s
+        field_name = "_id" if field_name == "id"
+        field = fields[field_name]
+        field ? field.object_id_field? : false
+      end
+
+      # Replace a field with a new type.
+      #
+      # @example Replace the field.
+      #   Model.replace_field("_id", String)
+      #
+      # @param [ String ] name The name of the field.
+      # @param [ Class ] type The new type of field.
+      #
+      # @return [ Serializable ] The new field.
+      #
+      # @since 2.1.0
+      def replace_field(name, type)
+        defaults.delete_one(name)
+        add_field(name, fields[name].options.merge(:type => type))
+      end
+
+      protected
+
+      # Define a field attribute for the +Document+.
+      #
+      # @example Set the field.
+      #   Person.add_field(:name, :default => "Test")
+      #
+      # @param [ Symbol ] name The name of the field.
+      # @param [ Hash ] options The hash of options.
+      def add_field(name, options = {})
+        meth = options.delete(:as) || name
+        type = options[:localize] ? Fields::Serializable::Localized : options[:type]
+        Mappings.for(type, options[:identity]).instantiate(name, options).tap do |field|
+          fields[name] = field
+          defaults << name unless field.default_val.nil?
+          create_accessors(name, meth, options)
+          process_options(field)
+          define_attribute_method(name)
+        end
+      end
+
+      # Run through all custom options stored in Mongoid::Fields.options and
+      # execute the handler if the option is provided.
+      #
+      # @example
+      #   Mongoid::Fields.option :custom do
+      #     puts "called"
+      #   end
+      #
+      #   field = Mongoid::Fields.new(:test, :custom => true)
+      #   Person.process_options(field)
+      #   # => "called"
+      #
+      # @param [ Field ] field the field to process
+      def process_options(field)
+        field_options = field.options
+
+        Fields.options.each_pair do |option_name, handler|
+          if field_options.has_key?(option_name)
+            handler.call(self, field, field_options[option_name])
+          end
+        end
+      end
+
+      # Determine if the field name is allowed, if not raise an error.
+      #
+      # @example Check the field name.
+      #   Model.check_field_name!(:collection)
+      #
+      # @param [ Symbol ] name The field name.
+      #
+      # @raise [ Errors::InvalidField ] If the name is not allowed.
+      #
+      # @since 2.1.8
+      def check_field_name!(name)
+        if Mongoid.destructive_fields.include?(name)
+          raise Errors::InvalidField.new(name)
+        end
+      end
+
+      # Create the field accessors.
+      #
+      # @example Generate the accessors.
+      #   Person.create_accessors(:name, "name")
+      #   person.name #=> returns the field
+      #   person.name = "" #=> sets the field
+      #   person.name? #=> Is the field present?
+      #
+      # @param [ Symbol ] name The name of the field.
+      # @param [ Symbol ] meth The name of the accessor.
+      # @param [ Hash ] options The options.
+      def create_accessors(name, meth, options = {})
+        field = fields[name]
+        generated_field_methods.module_eval do
+          if field.cast_on_read?
+            define_method(meth) do
+              field.deserialize(read_attribute(name))
+            end
+          else
+            define_method(meth) do
+              read_attribute(name).tap do |value|
+                if value.is_a?(Array) || value.is_a?(Hash)
+                  unless changed_attributes.include?(name)
+                    changed_attributes[name] = value.clone
+                  end
+                end
+              end
+            end
+          end
+          define_method("#{meth}=") do |value|
+            write_attribute(name, value)
+          end
+          define_method("#{meth}?") do
+            attr = read_attribute(name)
+            (options[:type] == Boolean) ? attr == true : attr.present?
+          end
+        end
+      end
+
+      # Include the field methods as a module, so they can be overridden.
+      #
+      # @example Include the fields.
+      #   Person.generated_field_methods
+      def generated_field_methods
+        @generated_field_methods ||= begin
+          Module.new.tap do |mod|
+            include mod
+          end
+        end
+      end
+    end
+  end
+end