activerecord 4.1.16 → 4.2.0.beta1

data/lib/active_record/type/mutable.rb

@@ -0,0 +1,16 @@
+module ActiveRecord
+  module Type
+    module Mutable # :nodoc:
+      def type_cast_from_user(value)
+        type_cast_from_database(type_cast_for_database(value))
+      end
+
+      # +raw_old_value+ will be the `_before_type_cast` version of the
+      # value (likely a string). +new_value+ will be the current, type
+      # cast value.
+      def changed_in_place?(raw_old_value, new_value)
+        raw_old_value != type_cast_for_database(new_value)
+      end
+    end
+  end
+end

data/lib/active_record/type/numeric.rb

@@ -0,0 +1,36 @@
+module ActiveRecord
+  module Type
+    module Numeric # :nodoc:
+      def number?
+        true
+      end
+
+      def type_cast(value)
+        value = case value
+                when true then 1
+                when false then 0
+                when ::String then value.presence
+                else value
+                end
+        super(value)
+      end
+
+      def changed?(old_value, _new_value, new_value_before_type_cast) # :nodoc:
+        super || number_to_non_number?(old_value, new_value_before_type_cast)
+      end
+
+      private
+
+      def number_to_non_number?(old_value, new_value_before_type_cast)
+        old_value != nil && non_numeric_string?(new_value_before_type_cast)
+      end
+
+      def non_numeric_string?(value)
+        # 'wibble'.to_i will give zero, we want to make sure
+        # that we aren't marking int zero to string zero as
+        # changed.
+        value.to_s !~ /\A\d+\.?\d*\z/
+      end
+    end
+  end
+end

data/lib/active_record/type/serialized.rb

@@ -0,0 +1,51 @@
+module ActiveRecord
+  module Type
+    class Serialized < SimpleDelegator # :nodoc:
+      include Mutable
+
+      attr_reader :subtype, :coder
+
+      def initialize(subtype, coder)
+        @subtype = subtype
+        @coder = coder
+        super(subtype)
+      end
+
+      def type_cast_from_database(value)
+        if default_value?(value)
+          value
+        else
+          coder.load(super)
+        end
+      end
+
+      def type_cast_for_database(value)
+        return if value.nil?
+        unless default_value?(value)
+          super coder.dump(value)
+        end
+      end
+
+      def accessor
+        ActiveRecord::Store::IndifferentHashAccessor
+      end
+
+      def init_with(coder)
+        @subtype = coder['subtype']
+        @coder = coder['coder']
+        __setobj__(@subtype)
+      end
+
+      def encode_with(coder)
+        coder['subtype'] = @subtype
+        coder['coder'] = @coder
+      end
+
+      private
+
+      def default_value?(value)
+        value == coder.load(nil)
+      end
+    end
+  end
+end

data/lib/active_record/type/string.rb

@@ -0,0 +1,36 @@
+module ActiveRecord
+  module Type
+    class String < Value # :nodoc:
+      def type
+        :string
+      end
+
+      def changed_in_place?(raw_old_value, new_value)
+        if new_value.is_a?(::String)
+          raw_old_value != new_value
+        end
+      end
+
+      def type_cast_for_database(value)
+        case value
+        when ::Numeric, ActiveSupport::Duration then value.to_s
+        when ::String then ::String.new(value)
+        when true then "1"
+        when false then "0"
+        else super
+        end
+      end
+
+      private
+
+      def cast_value(value)
+        case value
+        when true then "1"
+        when false then "0"
+        # String.new is slightly faster than dup
+        else ::String.new(value.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/active_record/type/text.rb

@@ -0,0 +1,11 @@
+require 'active_record/type/string'
+
+module ActiveRecord
+  module Type
+    class Text < String # :nodoc:
+      def type
+        :text
+      end
+    end
+  end
+end

data/lib/active_record/type/time.rb

@@ -0,0 +1,26 @@
+module ActiveRecord
+  module Type
+    class Time < Value # :nodoc:
+      include TimeValue
+
+      def type
+        :time
+      end
+
+      private
+
+      def cast_value(value)
+        return value unless value.is_a?(::String)
+        return if value.empty?
+
+        dummy_time_value = "2000-01-01 #{value}"
+
+        fast_string_to_time(dummy_time_value) || begin
+          time_hash = ::Date._parse(dummy_time_value)
+          return if time_hash[:hour].nil?
+          new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction))
+        end
+      end
+    end
+  end
+end

data/lib/active_record/type/time_value.rb

@@ -0,0 +1,38 @@
+module ActiveRecord
+  module Type
+    module TimeValue # :nodoc:
+      def klass
+        ::Time
+      end
+
+      def type_cast_for_schema(value)
+        "'#{value.to_s(:db)}'"
+      end
+
+      private
+
+      def new_time(year, mon, mday, hour, min, sec, microsec, offset = nil)
+        # Treat 0000-00-00 00:00:00 as nil.
+        return if year.nil? || (year == 0 && mon == 0 && mday == 0)
+
+        if offset
+          time = ::Time.utc(year, mon, mday, hour, min, sec, microsec) rescue nil
+          return unless time
+
+          time -= offset
+          Base.default_timezone == :utc ? time : time.getlocal
+        else
+          ::Time.public_send(Base.default_timezone, year, mon, mday, hour, min, sec, microsec) rescue nil
+        end
+      end
+
+      # Doesn't handle time zones.
+      def fast_string_to_time(string)
+        if string =~ ConnectionAdapters::Column::Format::ISO_DATETIME
+          microsec = ($7.to_r * 1_000_000).to_i
+          new_time $1.to_i, $2.to_i, $3.to_i, $4.to_i, $5.to_i, $6.to_i, microsec
+        end
+      end
+    end
+  end
+end

data/lib/active_record/type/type_map.rb

@@ -0,0 +1,48 @@
+module ActiveRecord
+  module Type
+    class TypeMap # :nodoc:
+      def initialize
+        @mapping = {}
+      end
+
+      def lookup(lookup_key, *args)
+        matching_pair = @mapping.reverse_each.detect do |key, _|
+          key === lookup_key
+        end
+
+        if matching_pair
+          matching_pair.last.call(lookup_key, *args)
+        else
+          default_value
+        end
+      end
+
+      def register_type(key, value = nil, &block)
+        raise ::ArgumentError unless value || block
+
+        if block
+          @mapping[key] = block
+        else
+          @mapping[key] = proc { value }
+        end
+      end
+
+      def alias_type(key, target_key)
+        register_type(key) do |sql_type, *args|
+          metadata = sql_type[/\(.*\)/, 0]
+          lookup("#{target_key}#{metadata}", *args)
+        end
+      end
+
+      def clear
+        @mapping.clear
+      end
+
+      private
+
+      def default_value
+        @default_value ||= Value.new
+      end
+    end
+  end
+end

data/lib/active_record/type/value.rb

@@ -0,0 +1,101 @@
+module ActiveRecord
+  module Type
+    class Value # :nodoc:
+      attr_reader :precision, :scale, :limit
+
+      # Valid options are +precision+, +scale+, and +limit+. They are only
+      # used when dumping schema.
+      def initialize(options = {})
+        options.assert_valid_keys(:precision, :scale, :limit)
+        @precision = options[:precision]
+        @scale = options[:scale]
+        @limit = options[:limit]
+      end
+
+      # The simplified type that this object represents. Returns a symbol such
+      # as +:string+ or +:integer+
+      def type; end
+
+      # Type casts a string from the database into the appropriate ruby type.
+      # Classes which do not need separate type casting behavior for database
+      # and user provided values should override +cast_value+ instead.
+      def type_cast_from_database(value)
+        type_cast(value)
+      end
+
+      # Type casts a value from user input (e.g. from a setter). This value may
+      # be a string from the form builder, or an already type cast value
+      # provided manually to a setter.
+      #
+      # Classes which do not need separate type casting behavior for database
+      # and user provided values should override +type_cast+ or +cast_value+
+      # instead.
+      def type_cast_from_user(value)
+        type_cast(value)
+      end
+
+      # Cast a value from the ruby type to a type that the database knows how
+      # to understand. The returned value from this method should be a
+      # +String+, +Numeric+, +Date+, +Time+, +Symbol+, +true+, +false+, or
+      # +nil+
+      def type_cast_for_database(value)
+        value
+      end
+
+      # Type cast a value for schema dumping. This method is private, as we are
+      # hoping to remove it entirely.
+      def type_cast_for_schema(value) # :nodoc:
+        value.inspect
+      end
+
+      # These predicates are not documented, as I need to look further into
+      # their use, and see if they can be removed entirely.
+      def number? # :nodoc:
+        false
+      end
+
+      def binary? # :nodoc:
+        false
+      end
+
+      def klass # :nodoc:
+      end
+
+      # Determines whether a value has changed for dirty checking. +old_value+
+      # and +new_value+ will always be type-cast. Types should not need to
+      # override this method.
+      def changed?(old_value, new_value, _new_value_before_type_cast)
+        old_value != new_value
+      end
+
+      # Determines whether the mutable value has been modified since it was
+      # read. Returns +false+ by default. This method should not be overridden
+      # directly. Types which return a mutable value should include
+      # +Type::Mutable+, which will define this method.
+      def changed_in_place?(*)
+        false
+      end
+
+      def ==(other)
+        self.class == other.class &&
+          precision == other.precision &&
+          scale == other.scale &&
+          limit == other.limit
+      end
+
+      private
+
+      def type_cast(value)
+        cast_value(value) unless value.nil?
+      end
+
+      # Convenience method for types which do not need separate type casting
+      # behavior for user and database inputs. Called by
+      # `type_cast_from_database` and `type_cast_from_user` for all values
+      # except `nil`.
+      def cast_value(value) # :doc:
+        value
+      end
+    end
+  end
+end

data/lib/active_record/validations.rb

@@ -29,21 +29,6 @@ module ActiveRecord
     extend ActiveSupport::Concern
     include ActiveModel::Validations
 
-    module ClassMethods
-      # Creates an object just like Base.create but calls <tt>save!</tt> instead of +save+
-      # so an exception is raised if the record is invalid.
-      def create!(attributes = nil, &block)
-        if attributes.is_a?(Array)
-          attributes.collect { |attr| create!(attr, &block) }
-        else
-          object = new(attributes)
-          yield(object) if block_given?
-          object.save!
-          object
-        end
-      end
-    end
-
     # The validation process on save can be skipped by passing <tt>validate: false</tt>.
     # The regular Base#save method is replaced with this when the validations
     # module is mixed in, which it is by default.
@@ -54,12 +39,14 @@ module ActiveRecord
     # Attempts to save the record just like Base#save but will raise a +RecordInvalid+
     # exception instead of returning +false+ if the record is not valid.
     def save!(options={})
-      perform_validations(options) ? super : raise(RecordInvalid.new(self))
+      perform_validations(options) ? super : raise_record_invalid
     end
 
     # Runs all the validations within the specified context. Returns +true+ if
     # no errors are found, +false+ otherwise.
     #
+    # Aliased as validate.
+    #
     # If the argument is +false+ (default is +nil+), the context is set to <tt>:create</tt> if
     # <tt>new_record?</tt> is +true+, and to <tt>:update</tt> if it is not.
     #
@@ -71,8 +58,26 @@ module ActiveRecord
       errors.empty? && output
     end
 
+    alias_method :validate, :valid?
+
+    # Runs all the validations within the specified context. Returns +true+ if
+    # no errors are found, raises +RecordInvalid+ otherwise.
+    #
+    # If the argument is +false+ (default is +nil+), the context is set to <tt>:create</tt> if
+    # <tt>new_record?</tt> is +true+, and to <tt>:update</tt> if it is not.
+    #
+    # Validations with no <tt>:on</tt> option will run no matter the context. Validations with
+    # some <tt>:on</tt> option will only run in the specified context.
+    def validate!(context = nil)
+      valid?(context) || raise_record_invalid
+    end
+
   protected
 
+    def raise_record_invalid
+      raise(RecordInvalid.new(self))
+    end
+
     def perform_validations(options={}) # :nodoc:
       options[:validate] == false || valid?(options[:context])
     end

data/lib/active_record/validations/uniqueness.rb

@@ -13,8 +13,7 @@ module ActiveRecord
       def validate_each(record, attribute, value)
         finder_class = find_finder_class_for(record)
         table = finder_class.arel_table
-        value = map_enum_attribute(finder_class,attribute,value)
-        value = deserialize_attribute(record, attribute, value)
+        value = map_enum_attribute(finder_class, attribute, value)
 
         relation = build_relation(finder_class, table, attribute, value)
         relation = relation.and(table[finder_class.primary_key.to_sym].not_eq(record.id)) if record.persisted?
@@ -49,7 +48,7 @@ module ActiveRecord
       def build_relation(klass, table, attribute, value) #:nodoc:
         if reflection = klass._reflect_on_association(attribute)
           attribute = reflection.foreign_key
-          value = value.attributes[reflection.primary_key_column.name] unless value.nil?
+          value = value.attributes[reflection.klass.primary_key] unless value.nil?
         end
 
         attribute_name = attribute.to_s
@@ -62,14 +61,15 @@ module ActiveRecord
 
         column = klass.columns_hash[attribute_name]
         value  = klass.connection.type_cast(value, column)
-        value  = value.to_s[0, column.limit] if value && column.limit && column.text?
+        if value.is_a?(String) && column.limit
+          value = value.to_s[0, column.limit]
+        end
 
-        if !options[:case_sensitive] && value && column.text?
+        if !options[:case_sensitive] && value.is_a?(String)
           # will use SQL LOWER function before comparison, unless it detects a case insensitive collation
           klass.connection.case_insensitive_comparison(table, attribute, column, value)
         else
-          value = klass.connection.case_sensitive_modifier(value) unless value.nil?
-          table[attribute].eq(value)
+          klass.connection.case_sensitive_comparison(table, attribute, column, value)
         end
       end
 
@@ -81,26 +81,12 @@ module ActiveRecord
           else
             scope_value = record.read_attribute(scope_item)
           end
-
-          # This is basically emulating an Arel::Nodes::Casted
-          column = record.class.columns_hash[scope_item.to_s]
-          quoted_value = record.class.connection.quote(scope_value, column)
-          unless scope_value.nil?
-            node = Arel::Nodes::SqlLiteral.new(quoted_value)
-          end
-
-          relation = relation.and(table[scope_item].eq(node))
+          relation = relation.and(table[scope_item].eq(scope_value))
         end
 
         relation
       end
 
-      def deserialize_attribute(record, attribute, value)
-        coder = record.class.serialized_attributes[attribute.to_s]
-        value = coder.dump value if value && coder
-        value
-      end
-
       def map_enum_attribute(klass, attribute, value)
         mapping = klass.defined_enums[attribute.to_s]
         value = mapping[value] if value && mapping
@@ -166,7 +152,7 @@ module ActiveRecord
       #   or <tt>if: Proc.new { |user| user.signup_step > 2 }</tt>). The method,
       #   proc or string should return or evaluate to a +true+ or +false+ value.
       # * <tt>:unless</tt> - Specifies a method, proc or string to call to
-      #   determine if the validation should ot occur (e.g. <tt>unless: :skip_validation</tt>,
+      #   determine if the validation should not occur (e.g. <tt>unless: :skip_validation</tt>,
       #   or <tt>unless: Proc.new { |user| user.signup_step <= 2 }</tt>). The
       #   method, proc or string should return or evaluate to a +true+ or +false+
       #   value.