stonegao-mongoid 2.0.0.rc.6

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

@@ -0,0 +1,20 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module Float #:nodoc:
+      module Conversions #:nodoc:
+        def set(value)
+          return nil if value.blank?
+          begin
+            Float(value)
+          rescue ArgumentError => e
+            value
+          end
+        end
+        def get(value)
+          value
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module Hash #:nodoc:
+      module Conversions #:nodoc:
+        extend ActiveSupport::Concern
+
+        module ClassMethods #:nodoc:
+          def get(value)
+            value
+          end
+          def set(value)
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/extensions/hash/criteria_helpers.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module Hash #:nodoc:
+      module CriteriaHelpers #:nodoc:
+        def expand_complex_criteria
+          hsh = {}
+          each_pair do |k,v|
+            case k
+            when Mongoid::Criterion::Complex
+              hsh[k.key] ||= {}
+              hsh[k.key].merge!({"$#{k.operator}" => v})
+            else
+              hsh[k] = v
+            end
+          end
+          hsh
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,20 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module Integer #:nodoc:
+      module Conversions #:nodoc:
+        def set(value)
+          return nil if value.blank?
+          begin
+            Integer(value)
+          rescue ArgumentError => e
+            value
+          end
+        end
+        def get(value)
+          value
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/extensions/nil/collectionization.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module Nil #:nodoc:
+      module Collectionization #:nodoc:
+        def collectionize
+          to_s.collectionize
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module Object #:nodoc:
+      # This module converts objects into mongoid related objects.
+      module Conversions #:nodoc:
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          def set(value)
+            value.respond_to?(:raw_attributes) ? value.raw_attributes : value
+          end
+
+          def get(value)
+            if value && respond_to?(:instantiate)
+              instantiate(value)
+            else
+              value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/extensions/object/reflections.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module Object #:nodoc:
+      module Reflections #:nodoc:
+        extend ActiveSupport::Concern
+
+        def ivar(name)
+          if instance_variable_defined?("@#{name}")
+            return instance_variable_get("@#{name}")
+          end
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/extensions/object/yoda.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module Object #:nodoc:
+
+      # This module behaves like the master jedi.
+      module Yoda #:nodoc:
+
+        # Do or do not, there is no try. -- Yoda.
+        #
+        # @example Do or do not.
+        #   object.do_or_do_not(:use, "The Force")
+        #
+        # @param [ String, Symbol ] name The method name.
+        # @param [ Array ] *args The arguments.
+        #
+        # @return [ Object, nil ] The result of the method call or nil if the
+        #   method does not exist.
+        #
+        # @since 2.0.0.rc.1
+        def do_or_do_not(name, *args)
+          respond_to?(name) ? send(name, *args) : nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module ObjectId #:nodoc:
+      module Conversions #:nodoc:
+
+        def set(value)
+          if value.is_a?(::String)
+            BSON::ObjectId.from_string(value) unless value.blank?
+          else
+            value
+          end
+        end
+
+        def get(value)
+          value
+        end
+
+        # If the document is using BSON::ObjectIds the convert the argument to
+        # either an object id or an array of them if the supplied argument is an
+        # Array. Otherwise just return.
+        #
+        # Options:
+        #  args: A +String+ or an +Array+ convert to +BSON::ObjectId+
+        #  cast: A +Boolean+ define if we can or not cast to BSON::ObjectId.
+        #        If false, we use the default type of args
+        #
+        # Example:
+        #
+        # <tt>Mongoid.cast_ids!("4ab2bc4b8ad548971900005c", true)</tt>
+        # <tt>Mongoid.cast_ids!(["4ab2bc4b8ad548971900005c"])</tt>
+        #
+        # Returns:
+        #
+        # If using object ids:
+        #   An +Array+ of +BSON::ObjectId+ of each element if params is an +Array+
+        #   A +BSON::ObjectId+ from params if params is +String+
+        # Otherwise:
+        #   <tt>args</tt>
+        def cast!(klass, args, cast = true)
+          if !klass.using_object_ids? || args.is_a?(::BSON::ObjectId) || !cast
+            return args
+          end
+          if args.is_a?(::String)
+            ::BSON::ObjectId.from_string(args)
+          elsif args.is_a?(::Array)
+            args.map{ |a|
+              a.is_a?(::BSON::ObjectId) ? a : ::BSON::ObjectId(a)
+            }
+          else
+            args
+          end
+        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.to_a
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# 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:
+        #
+        # <tt>"Testing".to_a</tt>
+        #
+        # Returns:
+        #
+        # An array with only the string in it.
+        def to_a
+          [ self ]
+        end
+
+        module ClassMethods #:nodoc:
+
+          def get(value)
+            value
+          end
+
+          def set(value)
+            value.to_s unless value.nil?
+          end
+        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/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/extensions.rb

@@ -0,0 +1,116 @@
+# encoding: utf-8
+require "mongoid/extensions/time_conversions"
+require "mongoid/extensions/array/conversions"
+require "mongoid/extensions/array/parentization"
+require "mongoid/extensions/set/conversions"
+require "mongoid/extensions/big_decimal/conversions"
+require "mongoid/extensions/binary/conversions"
+require "mongoid/extensions/boolean/conversions"
+require "mongoid/extensions/date/conversions"
+require "mongoid/extensions/datetime/conversions"
+require "mongoid/extensions/false_class/equality"
+require "mongoid/extensions/float/conversions"
+require "mongoid/extensions/hash/conversions"
+require "mongoid/extensions/hash/criteria_helpers"
+require "mongoid/extensions/hash/scoping"
+require "mongoid/extensions/integer/conversions"
+require "mongoid/extensions/nil/collectionization"
+require "mongoid/extensions/object/conversions"
+require "mongoid/extensions/object/reflections"
+require "mongoid/extensions/object/yoda"
+require "mongoid/extensions/proc/scoping"
+require "mongoid/extensions/string/conversions"
+require "mongoid/extensions/string/inflections"
+require "mongoid/extensions/symbol/inflections"
+require "mongoid/extensions/symbol/conversions"
+require "mongoid/extensions/true_class/equality"
+require "mongoid/extensions/object_id/conversions"
+
+class Array #:nodoc
+  include Mongoid::Extensions::Array::Conversions
+  include Mongoid::Extensions::Array::Parentization
+end
+
+class Set #:nodoc
+  include Mongoid::Extensions::Set::Conversions
+end
+
+class BigDecimal #:nodoc
+  extend Mongoid::Extensions::BigDecimal::Conversions
+end
+
+class Binary #:nodoc
+  extend Mongoid::Extensions::Binary::Conversions
+end
+
+class Boolean #:nodoc
+  include Mongoid::Extensions::Boolean::Conversions
+end
+
+class DateTime #:nodoc
+  extend Mongoid::Extensions::TimeConversions
+  extend Mongoid::Extensions::DateTime::Conversions
+end
+
+class Date #:nodoc
+  extend Mongoid::Extensions::TimeConversions
+  extend Mongoid::Extensions::Date::Conversions
+end
+
+class FalseClass #:nodoc
+  include Mongoid::Extensions::FalseClass::Equality
+end
+
+class Float #:nodoc
+  extend Mongoid::Extensions::Float::Conversions
+end
+
+class Hash #:nodoc
+  include Mongoid::Extensions::Hash::CriteriaHelpers
+  include Mongoid::Extensions::Hash::Scoping
+  include Mongoid::Extensions::Hash::Conversions
+end
+
+class Integer #:nodoc
+  extend Mongoid::Extensions::Integer::Conversions
+end
+
+class NilClass #:nodoc
+  include Mongoid::Extensions::Nil::Collectionization
+end
+
+class Object #:nodoc:
+  include Mongoid::Extensions::Object::Conversions
+  include Mongoid::Extensions::Object::Reflections
+  include Mongoid::Extensions::Object::Yoda
+end
+
+class Proc #:nodoc:
+  include Mongoid::Extensions::Proc::Scoping
+end
+
+class String #:nodoc
+  include Mongoid::Extensions::String::Inflections
+  include Mongoid::Extensions::String::Conversions
+end
+
+class Symbol #:nodoc
+  remove_method :size if instance_methods.include? :size # temporal fix for ruby 1.9
+  include Mongoid::Extensions::Symbol::Inflections
+  include Mongoid::Extensions::Symbol::Conversions
+end
+
+class Time #:nodoc
+  extend Mongoid::Extensions::TimeConversions
+end
+
+class TrueClass #:nodoc
+  include Mongoid::Extensions::TrueClass::Equality
+end
+
+class BSON::ObjectId #:nodoc
+  extend Mongoid::Extensions::ObjectId::Conversions
+  def as_json(options = nil)
+    to_s
+  end
+end