mongoid 2.4.10 → 3.0.0.rc

data/lib/mongoid/fields/standard.rb

@@ -0,0 +1,268 @@
+# encoding: utf-8
+module Mongoid
+  module Fields
+    class Standard
+
+      # Defines the behaviour for defined fields in the document.
+      # Set readers for the instance variables.
+      attr_accessor :default_val, :label, :name, :options
+
+      delegate :demongoize, :evolve, :mongoize, to: :type
+
+      # Adds the atomic changes for this type of resizable field.
+      #
+      # @example Add the atomic changes.
+      # field.add_atomic_changes(doc, "key", {}, [], [])
+      #
+      # @param [ Document ] document The document to add to.
+      # @param [ String ] name The name of the field.
+      # @param [ String ] key The atomic location of the field.
+      # @param [ Hash ] mods The current modifications.
+      # @param [ Array ] new The new elements to add.
+      # @param [ Array ] old The old elements getting removed.
+      #
+      # @since 2.4.0
+      def add_atomic_changes(document, name, key, mods, new, old)
+        mods[key] = new
+      end
+
+      # Get the constraint from the metadata once.
+      #
+      # @example Get the constraint.
+      #   field.constraint
+      #
+      # @return [ Constraint ] The relation's contraint.
+      #
+      # @since 2.1.0
+      def constraint
+        @constraint ||= metadata.constraint
+      end
+
+      # Evaluate the default value and return it. Will handle the
+      # serialization, proc calls, and duplication if necessary.
+      #
+      # @example Evaluate the default value.
+      #   field.eval_default(document)
+      #
+      # @param [ Document ] doc The document the field belongs to.
+      #
+      # @return [ Object ] The serialized default value.
+      #
+      # @since 2.1.8
+      def eval_default(doc)
+        if fields = Threaded.selection
+          evaluated_default(doc) if included?(fields)
+        else
+          evaluated_default(doc)
+        end
+      end
+
+      # Is this field a foreign key?
+      #
+      # @example Is the field a foreign key?
+      #   field.foreign_key?
+      #
+      # @return [ true, false ] If the field is a foreign key.
+      #
+      # @since 2.4.0
+      def foreign_key?
+        false
+      end
+
+      # Create the new field with a name and optional additional options.
+      #
+      # @example Create the new field.
+      #   Field.new(:name, :type => String)
+      #
+      # @param [ Hash ] options The field options.
+      #
+      # @option options [ Class ] :type The class of the field.
+      # @option options [ Object ] :default The default value for the field.
+      # @option options [ String ] :label The field's label.
+      #
+      # @since 3.0.0
+      def initialize(name, options = {})
+        @name = name
+        @options = options
+        @label = options[:label]
+        @default_val = options[:default]
+      end
+
+      # Is the field localized or not?
+      #
+      # @example Is the field localized?
+      #   field.localized?
+      #
+      # @return [ true, false ] If the field is localized.
+      #
+      # @since 2.3.0
+      def localized?
+        false
+      end
+
+      # Get the metadata for the field if its a foreign key.
+      #
+      # @example Get the metadata.
+      #   field.metadata
+      #
+      # @return [ Metadata ] The relation metadata.
+      #
+      # @since 2.2.0
+      def metadata
+        @metadata ||= options[:metadata]
+      end
+
+      # Is the field a BSON::ObjectId?
+      #
+      # @example Is the field a BSON::ObjectId?
+      #   field.object_id_field?
+      #
+      # @return [ true, false ] If the field is a BSON::ObjectId.
+      #
+      # @since 2.2.0
+      def object_id_field?
+        @object_id_field ||= (type == Moped::BSON::ObjectId)
+      end
+
+      # Does the field pre-process it's default value?
+      #
+      # @example Does the field pre-process the default?
+      #   field.pre_processed?
+      #
+      # @return [ true, false ] If the field's default is pre-processed.
+      #
+      # @since 3.0.0
+      def pre_processed?
+        @pre_processed ||=
+          (options[:pre_processed] || (default_val && !default_val.is_a?(::Proc)))
+      end
+
+      # Get the type of this field - inferred from the class name.
+      #
+      # @example Get the type.
+      #   field.type
+      #
+      # @return [ Class ] The name of the class.
+      #
+      # @since 2.1.0
+      def type
+        @type ||= options[:type] || Object
+      end
+
+      # Is this field included in versioned attributes?
+      #
+      # @example Is the field versioned?
+      #   field.versioned?
+      #
+      # @return [ true, false ] If the field is included in versioning.
+      #
+      # @since 2.1.0
+      def versioned?
+        @versioned ||= (options[:versioned].nil? ? true : options[:versioned])
+      end
+
+      private
+
+      # Get the name of the default method for this field.
+      #
+      # @api private
+      #
+      # @example Get the default name.
+      #   field.default_name
+      #
+      # @return [ String ] The method name.
+      #
+      # @since 3.0.0
+      def default_name
+        @default_name ||= "__#{name}_default__"
+      end
+
+      # Define the method for getting the default on the document.
+      #
+      # @api private
+      #
+      # @example Define the method.
+      #   field.define_default_method(doc)
+      #
+      # @note Ruby's instance_exec was just too slow.
+      #
+      # @param [ Document ] doc The document.
+      #
+      # @since 3.0.0
+      def define_default_method(doc)
+        unless doc.respond_to?(default_name)
+          doc.class.__send__(:define_method, default_name, default_val)
+        end
+      end
+
+      # Is the field included in the fields that were returned from the
+      # database? We can apply the default if:
+      #   1. The field is included in an only limitation (field: 1)
+      #   2. The field is not excluded in a without limitation (field: 0)
+      #
+      # @example Is the field included?
+      #   field.included?(fields)
+      #
+      # @param [ Hash ] fields The field limitations.
+      #
+      # @return [ true, false ] If the field was included.
+      #
+      # @since 2.4.4
+      def included?(fields)
+        (fields.values.first == 1 && fields[name.to_s] == 1) ||
+          (fields.values.first == 0 && !fields.has_key?(name.to_s))
+      end
+
+      # Get the evaluated default.
+      #
+      # @example Get the evaluated default.
+      #   field.evaluated_default.
+      #
+      # @param [ Document ] doc The doc being applied to.
+      #
+      # @return [ Object ] The default value.
+      #
+      # @since 2.4.4
+      def evaluated_default(doc)
+        if default_val.respond_to?(:call)
+          evaluate_default_proc(doc)
+        else
+          serialize_default(default_val.__deep_copy__)
+        end
+      end
+
+      # Evaluate the default proc. In some cases we need to instance exec,
+      # in others we don't.
+      #
+      # @example Eval the default proc.
+      #   field.evaluate_default_proc(band)
+      #
+      # @param [ Document ] doc The document.
+      #
+      # @return [ Object ] The called proc.
+      #
+      # @since 3.0.0
+      def evaluate_default_proc(doc)
+        define_default_method(doc)
+        serialize_default(doc.__send__(default_name))
+      end
+
+      # This is used when default values need to be serialized. Most of the
+      # time just return the object.
+      #
+      # @api private
+      #
+      # @example Serialize the default value.
+      #   field.serialize_default(obj)
+      #
+      # @param [ Object ] object The default.
+      #
+      # @return [ Object ] The serialized default.
+      #
+      # @since 3.0.0
+      def serialize_default(object)
+        mongoize(object)
+      end
+    end
+  end
+end

data/lib/mongoid/fields/validators/macro.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+module Mongoid
+  module Fields
+    module Validators
+
+      # Validates the params passed to the field macro.
+      module Macro
+        extend self
+
+        OPTIONS = [
+          :as,
+          :default,
+          :identity,
+          :label,
+          :localize,
+          :metadata,
+          :pre_processed,
+          :subtype,
+          :type,
+          :versioned
+        ]
+
+        # Validate the field definition.
+        #
+        # @example Validate the field definition.
+        #   Macro.validate(Model, :name, { localized: true })
+        #
+        # @param [ Class ] klass The model class.
+        # @param [ Symbol ] name The field name.
+        # @param [ Hash ] options The provided options.
+        #
+        # @since 3.0.0
+        def validate(klass, name, options)
+          validate_name(klass, name)
+          validate_options(klass, name, options)
+        end
+
+        private
+
+        # Determine if the field name is allowed, if not raise an error.
+        #
+        # @api private
+        #
+        # @example Check the field name.
+        #   Macro.validate_name(Model, :name)
+        #
+        # @param [ Class ] klass The model class.
+        # @param [ Symbol ] name The field name.
+        #
+        # @raise [ Errors::InvalidField ] If the name is not allowed.
+        #
+        # @since 3.0.0
+        def validate_name(klass, name)
+          if Mongoid.destructive_fields.include?(name)
+            raise Errors::InvalidField.new(klass, name)
+          end
+        end
+
+        # Validate that the field options are allowed.
+        #
+        # @api private
+        #
+        # @example Validate the field options.
+        #   Macro.validate_options(Model, :name, { localized: true })
+        #
+        # @param [ Class ] klass The model class.
+        # @param [ Symbol ] name The field name.
+        # @param [ Hash ] options The provided options.
+        #
+        # @raise [ Errors::InvalidFieldOption ] If an option is invalid.
+        #
+        # @since 3.0.0
+        def validate_options(klass, name, options)
+          options.keys.each do |option|
+            if !OPTIONS.include?(option) && !Fields.options.include?(option)
+              raise Errors::InvalidFieldOption.new(klass, name, option, OPTIONS)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/fields/validators.rb

@@ -0,0 +1,2 @@
+# encoding: utf-8
+require "mongoid/fields/validators/macro"