mongoid-locomotive 2.0.0.beta9

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

@@ -0,0 +1,15 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module ObjectID #:nodoc:
+      module Conversions #:nodoc:
+        def set(value)
+          value
+        end
+        def get(value)
+          value
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/extensions/proc/scoping.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module Proc #:nodoc:
+      module Scoping #:nodoc:
+        def scoped(*args)
+          call(*args).scoped
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module Set #:nodoc:
+      # This module converts set into mongoid related objects.
+      module Conversions #:nodoc:
+        extend ActiveSupport::Concern
+
+        module ClassMethods #:nodoc:
+          def get(value)
+            ::Set.new(value)
+          end
+          def set(value)
+            value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module String #:nodoc:
+      module Conversions #:nodoc:
+        def set(value)
+          value.to_s unless value.nil?
+        end
+        def get(value)
+          value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module String #:nodoc:
+      module Inflections #:nodoc:
+
+        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-",
+          "\"" => "-bckslsh-",
+          "#" => "-hash-",
+          "$" => "-dol-",
+          "%" => "-perc-",
+          "&" => "-and-",
+          "'" => "-quo-",
+          "(" => "-oparen-",
+          ")" => "-cparen-",
+          "*" => "-astx-",
+          "+" => "-plus-",
+          "," => "-comma-",
+          "-" => "-dash-",
+          "." => "-period-",
+          "/" => "-fwdslsh-",
+          ":" => "-colon-",
+          ";" => "-semicol-",
+          "<" => "-lt-",
+          "=" => "-eq-",
+          ">" => "-gt-",
+          "?" => "-ques-",
+          "@" => "-at-",
+          "[" => "-obrck-",
+          "\\" => "-bckslsh-",
+          "]" => "-clbrck-",
+          "^" => "-carat-",
+          "_" => "-undscr-",
+          "`" => "-bcktick-",
+          "{" => "-ocurly-",
+          "|" => "-pipe-",
+          "}" => "-clcurly-",
+          "~" => "-tilda-"
+        }
+
+        REVERSALS = {
+          "asc" => "desc",
+          "ascending" => "descending",
+          "desc" => "asc",
+          "descending" => "ascending"
+        }
+
+        def collectionize
+          tableize.gsub("/", "_")
+        end
+
+        def identify
+          if Mongoid.parameterize_keys
+            key = ""
+            each_char { |c| key += (CHAR_CONV[c] || c.downcase) }; key
+          else
+            self
+          end
+        end
+
+        def labelize
+          underscore.humanize
+        end
+
+        def invert
+          REVERSALS[self]
+        end
+
+        def singular?
+          singularize == self
+        end
+
+        def plural?
+          pluralize == self
+        end
+
+        def reader
+          writer? ? gsub("=", "") : self
+        end
+
+        def writer?
+          include?("=")
+        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,35 @@
+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?
+        if Mongoid::Config.instance.use_utc?
+          value
+        else
+          value.getlocal
+        end
+      end
+
+      protected
+
+      def strip_milliseconds(time)
+        ::Time.at(time.to_i)
+      end
+
+      def convert_to_time(value)
+        case value
+          when ::String then ::Time.parse(value)
+          when ::DateTime then ::Time.utc(value.year, value.month, value.day, value.hour, value.min, value.sec)
+          when ::Date then ::Time.utc(value.year, value.month, value.day)
+          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,61 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extras #:nodoc:
+    extend ActiveSupport::Concern
+    included do
+      class_inheritable_accessor :cached, :enslaved
+      self.cached = false
+      self.enslaved = false
+      delegate :cached?, :enslaved?, :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:
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     cache
+      #   end
+      def cache
+        self.cached = true
+      end
+
+      # Determines if the class is cached or not.
+      #
+      # Returns:
+      #
+      # True if cached, false if not.
+      def cached?
+        !!self.cached
+      end
+
+      # Set whether or not this documents read operations should delegate to
+      # the slave database by default.
+      #
+      # Example:
+      #
+      #   class Person
+      #     include Mongoid::Document
+      #     enslave
+      #   end
+      def enslave
+        self.enslaved = true
+      end
+
+      # Determines if the class is enslaved or not.
+      #
+      # Returns:
+      #
+      # True if enslaved, false if not.
+      def enslaved?
+        !!self.enslaved
+      end
+    end
+  end
+end

data/lib/mongoid/factory.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  class Factory #:nodoc:
+    # Builds a new +Document+ from the supplied attributes.
+    #
+    # Example:
+    #
+    # <tt>Mongoid::Factory.build(Person, {})</tt>
+    #
+    # Options:
+    #
+    # klass: The class to instantiate from if _type is not present.
+    # attributes: The +Document+ attributes.
+    def self.build(klass, attributes)
+      attrs = {}.merge(attributes)
+      type = attrs["_type"]
+      type ? type.constantize.instantiate(attrs) : klass.instantiate(attrs)
+    end
+  end
+end

data/lib/mongoid/field.rb

@@ -0,0 +1,83 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  class Field
+    attr_reader :name, :type
+
+    # Determine if the field is able to be accessible via a mass update.
+    #
+    # Returns:
+    #
+    # true if accessible, false if not.
+    def accessible?
+      !!@accessible
+    end
+
+    # Get the declared options for this field
+    #
+    # Returns:
+    #
+    # a hash of options 
+    def options
+      @options
+    end
+
+    # Get the default value for the field.
+    #
+    # Returns:
+    #
+    # The primitive value or a copy of the default.
+    def default
+      copy
+    end
+
+    # Create the new field with a name and optional additional options. Valid
+    # options are :default
+    #
+    # Options:
+    #
+    # name: The name of the field as a +Symbol+.
+    # options: A +Hash+ of options for the field.
+    #
+    # Example:
+    #
+    # <tt>Field.new(:score, :default => 0)</tt>
+    def initialize(name, options = {})
+      check_name!(name)
+      @type = options[:type] || String
+      @name, @default = name, options[:default]
+      @copyable = (@default.is_a?(Array) || @default.is_a?(Hash))
+      @accessible = options.has_key?(:accessible) ? options[:accessible] : true
+      @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.
+    def set(object)
+      type.set(object)
+    end
+
+    # Used for retrieving the object out of the attributes hash.
+    def get(object)
+      type.get(object)
+    end
+
+    protected
+    # Slightly faster default check.
+    def copy
+      @copyable ? @default.dup : @default
+    end
+
+    # Check if the name is valid.
+    def check_name!(name)
+      raise Mongoid::Errors::InvalidField.new(name) if Mongoid.destructive_fields.include?(name.to_s)
+    end
+
+    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,62 @@
+# encoding: utf-8
+module Mongoid #:nodoc
+  module Fields #:nodoc
+    extend ActiveSupport::Concern
+    included do
+      # Set up the class attributes that must be available to all subclasses.
+      # These include defaults, fields
+      class_inheritable_accessor :fields
+
+      self.fields = {}
+      delegate :defaults, :fields, :to => "self.class"
+    end
+
+    module ClassMethods #:nodoc
+      # Defines all the fields that are accessable on the Document
+      # For each field that is defined, a getter and setter will be
+      # added as an instance method to the Document.
+      #
+      # Options:
+      #
+      # name: The name of the field, as a +Symbol+.
+      # options: A +Hash+ of options to supply to the +Field+.
+      #
+      # Example:
+      #
+      # <tt>field :score, :default => 0</tt>
+      def field(name, options = {})
+        access = name.to_s
+        set_field(access, options)
+        attr_protected name if options[:accessible] == false
+      end
+
+      # Returns the default values for the fields on the document
+      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
+
+      protected
+      # Define a field attribute for the +Document+.
+      def set_field(name, options = {})
+        meth = options.delete(:as) || name
+        fields[name] = Field.new(name, options)
+        create_accessors(name, meth, options)
+        add_dirty_methods(name)
+      end
+
+      # Create the field accessors.
+      def create_accessors(name, meth, options = {})
+        define_method(meth) { read_attribute(name) }
+        define_method("#{meth}=") { |value| write_attribute(name, value) }
+        define_method("#{meth}?") do
+          attr = read_attribute(name)
+          (options[:type] == Boolean) ? attr == true : attr.present?
+        end
+      end
+    end
+  end
+end