mongoid-braxton 2.0.2

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

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module Symbol#:nodoc:
+      # This module converts objects into mongoid related objects.
+      module Conversions #:nodoc:
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          def set(value)
+            (value.nil? or (value.respond_to?(:empty?) && value.empty?)) ? nil : value.to_sym
+          end
+
+          def get(value)
+            value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module Symbol #:nodoc:
+      module Inflections #:nodoc:
+
+        REVERSALS = {
+          :asc => :desc,
+          :ascending => :descending,
+          :desc => :asc,
+          :descending => :ascending
+        }
+
+        def invert
+          REVERSALS[self]
+        end
+
+        def singular?
+          to_s.singular?
+        end
+
+        def plural?
+          to_s.plural?
+        end
+
+        [ "asc", "ascending", "desc", "descending", "gt", "lt", "gte",
+          "lte", "ne", "near", "in", "nin", "mod", "all", "size", "exists",
+          "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/time_conversions.rb

@@ -0,0 +1,38 @@
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module TimeConversions #:nodoc:
+      def set(value)
+        return nil if value.blank?
+        time = convert_to_time(value)
+        strip_milliseconds(time).utc
+      end
+
+      def get(value)
+        return nil if value.blank?
+        value = value.getlocal unless Mongoid::Config.use_utc?
+        if Mongoid::Config.use_activesupport_time_zone?
+          time_zone = Mongoid::Config.use_utc? ? 'UTC' : Time.zone
+          value = value.in_time_zone(time_zone)
+        end
+        value
+      end
+
+      protected
+
+      def strip_milliseconds(time)
+        ::Time.at(time.to_i)
+      end
+
+      def convert_to_time(value)
+        time = Mongoid::Config.use_activesupport_time_zone? ? ::Time.zone : ::Time
+        case value
+          when ::String then time.parse(value)
+          when ::DateTime then time.local(value.year, value.month, value.day, value.hour, value.min, value.sec)
+          when ::Date then time.local(value.year, value.month, value.day)
+          when ::Array then time.local(*value)
+          else value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module TrueClass #:nodoc:
+      module Equality #:nodoc:
+        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,42 @@
+# 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
+      delegate :cached?, :to => "self.class"
+    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
+
+      # Determines if the class is cached or not.
+      #
+      # @example Are class reads cached?
+      #   Document.cached?
+      #
+      # @return [ true, false ] If the reads are cached.
+      def cached?
+        !!self.cached
+      end
+    end
+  end
+end

data/lib/mongoid/factory.rb

@@ -0,0 +1,37 @@
+# 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.
+    #
+    # @return [ Document ] The instantiated document.
+    def build(klass, attributes = {})
+      type = (attributes || {})["_type"]
+      type.blank? ? klass.new(attributes) : type.constantize.new(attributes)
+    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"]
+      type.blank? ? klass.instantiate(attributes) : type.constantize.instantiate(attributes)
+    end
+  end
+end

data/lib/mongoid/field.rb

@@ -0,0 +1,162 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+
+  # Defines the behaviour for defined fields in the document.
+  class Field
+
+    NO_CAST_ON_READ = [
+      Array, Binary, Boolean, Float, Hash,
+      Integer, BSON::ObjectId, Set, String, Symbol
+    ]
+
+    attr_accessor :type
+    attr_reader :copyable, :klass, :label, :name, :options
+
+    class << self
+
+      # Return a map of custom option names to their handlers.
+      #
+      # @example
+      #   Mongoid::Field.options
+      #   # => { :required => #<Proc:0x00000100976b38> }
+      #
+      # @return [ Hash ] the option map
+      def options
+        @options ||= {}
+      end
+
+      # 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::Field.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.
+      def option(option_name, &block)
+        options[option_name] = block
+      end
+
+    end
+
+    # When reading the field do we need to cast the value? This holds true when
+    # times are stored or for big decimals which are stored as strings.
+    #
+    # @example Typecast on a read?
+    #   field.cast_on_read?
+    #
+    # @return [ true, false ] If the field should be cast.
+    def cast_on_read?
+      !NO_CAST_ON_READ.include?(type)
+    end
+
+    # Get the default value for the field.
+    #
+    # @example Get the default.
+    #   field.default
+    #
+    # @return [ Object ] The typecast default value.
+    #
+    # @since 1.0.0
+    def default
+      copy.respond_to?(:call) ? copy : set(copy)
+    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 1.0.0
+    def initialize(name, options = {})
+      @type = options[:type] || Object
+      @name, @default, @label = name, options[:default], options[:label]
+      @copyable = (@default.is_a?(Array) || @default.is_a?(Hash))
+      @options = options
+      check_default!
+    end
+
+    # Used for setting an object in the attributes hash.
+    #
+    # If nil is provided the default will get returned if it exists.
+    #
+    # If the field is an identity field, ie an id, it performs the necessary
+    # cast.
+    #
+    # @example Get the setter value.
+    #   field.set("New Value")
+    #
+    # @param [ Object ] object The value to cast to a database value.
+    #
+    # @return [ Object ] The typecast value.
+    #
+    # @since 1.0.0
+    def set(object)
+      unless options[:identity]
+        type.set(object)
+      else
+        if object.blank?
+          type.set(object) if object.is_a?(Array)
+        else
+          options[:metadata].constraint.convert(object)
+        end
+      end
+    end
+
+    # Used for retrieving the object out of the attributes hash.
+    #
+    # @example Get the value.
+    #   field.get("Value")
+    #
+    # @param [ Object ] The object to cast from the database.
+    #
+    # @return [ Object ] The converted value.
+    #
+    # @since 1.0.0
+    def get(object)
+      type.get(object)
+    end
+
+    protected
+
+    # Copy the default value if copyable.
+    #
+    # @example Copy the default.
+    #   field.copy
+    #
+    # @return [ Object ] The copied object or the original.
+    #
+    # @since 1.0.0
+    def copy
+      copyable ? @default.dup : @default
+    end
+
+    # Checks if the default value is of the same type as the field.
+    #
+    # @example Check the default value.
+    #   field.check_default!
+    #
+    # @raise [ Errors::InvalidType ] If the types differ.
+    #
+    # @since 1.0.0
+    def check_default!
+      return if @default.is_a?(Proc)
+      if !@default.nil? && !@default.is_a?(type)
+        raise Mongoid::Errors::InvalidType.new(type, @default)
+      end
+    end
+  end
+end

data/lib/mongoid/fields.rb

@@ -0,0 +1,183 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+
+  # This module defines behaviour for fields.
+  module Fields
+    extend ActiveSupport::Concern
+
+    included do
+      # Set up the class attributes that must be available to all subclasses.
+      # These include defaults, fields
+      delegate :defaults, :fields, :to => "self.class"
+
+      field(:_type, :type => String)
+      field(:_id, :type => BSON::ObjectId)
+
+      alias :id :_id
+      alias :id= :_id=
+    end
+
+    module ClassMethods #:nodoc
+
+      # 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 = {})
+        access = name.to_s
+        set_field(access, 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
+
+      # Returns the default values for the fields on the document.
+      #
+      # @example Get the defaults.
+      #   Person.defaults
+      #
+      # @return [ Hash ] The field defaults.
+      def defaults
+        fields.inject({}) do |defs, (field_name,field)|
+          next(defs) if field.default.nil?
+          defs[field_name.to_s] = field.default
+          defs
+        end
+      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.fields = fields.dup
+      end
+
+      protected
+
+      # Define a field attribute for the +Document+.
+      #
+      # @example Set the field.
+      #   Person.set_field(:name, :default => "Test")
+      #
+      # @param [ Symbol ] name The name of the field.
+      # @param [ Hash ] options The hash of options.
+      def set_field(name, options = {})
+        meth = options.delete(:as) || name
+        Field.new(name, options).tap do |field|
+          fields[name] = field
+          create_accessors(name, meth, options)
+          add_dirty_methods(name)
+          process_options(field)
+        end
+      end
+
+      # Run through all custom options stored in Mongoid::Field.options and
+      # execute the handler if the option is provided.
+      #
+      # @example
+      #   Mongoid::Field.option :custom do
+      #     puts "called"
+      #   end
+      #
+      #   field = Mongoid::Field.new(:test, :custom => true)
+      #   Person.process_options(field)
+      #   # => "called"
+      #
+      # @param [ Field ] field the field to process
+      def process_options(field)
+        options = field.options
+
+        Field.options.each do |option_name, handler|
+          if options.has_key?(option_name)
+            handler.call(self, field, options[option_name])
+          end
+        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.get(read_attribute(name))
+            end
+          else
+            define_method(meth) do
+              read_attribute(name)
+            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