activerecord 4.2.0

data/lib/active_record/translation.rb

@@ -0,0 +1,22 @@
+module ActiveRecord
+  module Translation
+    include ActiveModel::Translation
+
+    # Set the lookup ancestors for ActiveModel.
+    def lookup_ancestors #:nodoc:
+      klass = self
+      classes = [klass]
+      return classes if klass == ActiveRecord::Base
+
+      while klass != klass.base_class
+        classes << klass = klass.superclass
+      end
+      classes
+    end
+
+    # Set the i18n scope to overwrite ActiveModel.
+    def i18n_scope #:nodoc:
+      :activerecord
+    end
+  end
+end

data/lib/active_record/type.rb

@@ -0,0 +1,23 @@
+require 'active_record/type/decorator'
+require 'active_record/type/mutable'
+require 'active_record/type/numeric'
+require 'active_record/type/time_value'
+require 'active_record/type/value'
+
+require 'active_record/type/big_integer'
+require 'active_record/type/binary'
+require 'active_record/type/boolean'
+require 'active_record/type/date'
+require 'active_record/type/date_time'
+require 'active_record/type/decimal'
+require 'active_record/type/decimal_without_scale'
+require 'active_record/type/float'
+require 'active_record/type/integer'
+require 'active_record/type/serialized'
+require 'active_record/type/string'
+require 'active_record/type/text'
+require 'active_record/type/time'
+require 'active_record/type/unsigned_integer'
+
+require 'active_record/type/type_map'
+require 'active_record/type/hash_lookup_type_map'

data/lib/active_record/type/big_integer.rb

@@ -0,0 +1,13 @@
+require 'active_record/type/integer'
+
+module ActiveRecord
+  module Type
+    class BigInteger < Integer # :nodoc:
+      private
+
+      def max_value
+        ::Float::INFINITY
+      end
+    end
+  end
+end

data/lib/active_record/type/binary.rb

@@ -0,0 +1,50 @@
+module ActiveRecord
+  module Type
+    class Binary < Value # :nodoc:
+      def type
+        :binary
+      end
+
+      def binary?
+        true
+      end
+
+      def type_cast(value)
+        if value.is_a?(Data)
+          value.to_s
+        else
+          super
+        end
+      end
+
+      def type_cast_for_database(value)
+        return if value.nil?
+        Data.new(super)
+      end
+
+      def changed_in_place?(raw_old_value, value)
+        old_value = type_cast_from_database(raw_old_value)
+        old_value != value
+      end
+
+      class Data # :nodoc:
+        def initialize(value)
+          @value = value.to_s
+        end
+
+        def to_s
+          @value
+        end
+        alias_method :to_str, :to_s
+
+        def hex
+          @value.unpack('H*')[0]
+        end
+
+        def ==(other)
+          other == to_s || super
+        end
+      end
+    end
+  end
+end

data/lib/active_record/type/boolean.rb

@@ -0,0 +1,30 @@
+module ActiveRecord
+  module Type
+    class Boolean < Value # :nodoc:
+      def type
+        :boolean
+      end
+
+      private
+
+      def cast_value(value)
+        if value == ''
+          nil
+        elsif ConnectionAdapters::Column::TRUE_VALUES.include?(value)
+          true
+        else
+          if !ConnectionAdapters::Column::FALSE_VALUES.include?(value)
+            ActiveSupport::Deprecation.warn(<<-MSG.squish)
+              You attempted to assign a value which is not explicitly `true` or `false`
+              to a boolean column. Currently this value casts to `false`. This will
+              change to match Ruby's semantics, and will cast to `true` in Rails 5.
+              If you would like to maintain the current behavior, you should
+              explicitly handle the values you would like cast to `false`.
+            MSG
+          end
+          false
+        end
+      end
+    end
+  end
+end

data/lib/active_record/type/date.rb

@@ -0,0 +1,46 @@
+module ActiveRecord
+  module Type
+    class Date < Value # :nodoc:
+      def type
+        :date
+      end
+
+      def klass
+        ::Date
+      end
+
+      def type_cast_for_schema(value)
+        "'#{value.to_s(:db)}'"
+      end
+
+      private
+
+      def cast_value(value)
+        if value.is_a?(::String)
+          return if value.empty?
+          fast_string_to_date(value) || fallback_string_to_date(value)
+        elsif value.respond_to?(:to_date)
+          value.to_date
+        else
+          value
+        end
+      end
+
+      def fast_string_to_date(string)
+        if string =~ ConnectionAdapters::Column::Format::ISO_DATE
+          new_date $1.to_i, $2.to_i, $3.to_i
+        end
+      end
+
+      def fallback_string_to_date(string)
+        new_date(*::Date._parse(string, false).values_at(:year, :mon, :mday))
+      end
+
+      def new_date(year, mon, mday)
+        if year && year != 0
+          ::Date.new(year, mon, mday) rescue nil
+        end
+      end
+    end
+  end
+end

data/lib/active_record/type/date_time.rb

@@ -0,0 +1,43 @@
+module ActiveRecord
+  module Type
+    class DateTime < Value # :nodoc:
+      include TimeValue
+
+      def type
+        :datetime
+      end
+
+      def type_cast_for_database(value)
+        zone_conversion_method = ActiveRecord::Base.default_timezone == :utc ? :getutc : :getlocal
+
+        if value.acts_like?(:time)
+          value.send(zone_conversion_method)
+        else
+          super
+        end
+      end
+
+      private
+
+      def cast_value(string)
+        return string unless string.is_a?(::String)
+        return if string.empty?
+
+        fast_string_to_time(string) || fallback_string_to_time(string)
+      end
+
+      # '0.123456' -> 123456
+      # '1.123456' -> 123456
+      def microseconds(time)
+        time[:sec_fraction] ? (time[:sec_fraction] * 1_000_000).to_i : 0
+      end
+
+      def fallback_string_to_time(string)
+        time_hash = ::Date._parse(string)
+        time_hash[:sec_fraction] = microseconds(time_hash)
+
+        new_time(*time_hash.values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction, :offset))
+      end
+    end
+  end
+end

data/lib/active_record/type/decimal.rb

@@ -0,0 +1,40 @@
+module ActiveRecord
+  module Type
+    class Decimal < Value # :nodoc:
+      include Numeric
+
+      def type
+        :decimal
+      end
+
+      def type_cast_for_schema(value)
+        value.to_s
+      end
+
+      private
+
+      def cast_value(value)
+        case value
+        when ::Float
+          BigDecimal(value, float_precision)
+        when ::Numeric, ::String
+          BigDecimal(value, precision.to_i)
+        else
+          if value.respond_to?(:to_d)
+            value.to_d
+          else
+            cast_value(value.to_s)
+          end
+        end
+      end
+
+      def float_precision
+        if precision.to_i > ::Float::DIG + 1
+          ::Float::DIG + 1
+        else
+          precision.to_i
+        end
+      end
+    end
+  end
+end

data/lib/active_record/type/decimal_without_scale.rb

@@ -0,0 +1,11 @@
+require 'active_record/type/big_integer'
+
+module ActiveRecord
+  module Type
+    class DecimalWithoutScale < BigInteger # :nodoc:
+      def type
+        :decimal
+      end
+    end
+  end
+end

data/lib/active_record/type/decorator.rb

@@ -0,0 +1,14 @@
+module ActiveRecord
+  module Type
+    module Decorator # :nodoc:
+      def init_with(coder)
+        @subtype = coder['subtype']
+        __setobj__(@subtype)
+      end
+
+      def encode_with(coder)
+        coder['subtype'] = __getobj__
+      end
+    end
+  end
+end

data/lib/active_record/type/float.rb

@@ -0,0 +1,19 @@
+module ActiveRecord
+  module Type
+    class Float < Value # :nodoc:
+      include Numeric
+
+      def type
+        :float
+      end
+
+      alias type_cast_for_database type_cast
+
+      private
+
+      def cast_value(value)
+        value.to_f
+      end
+    end
+  end
+end

data/lib/active_record/type/hash_lookup_type_map.rb

@@ -0,0 +1,17 @@
+module ActiveRecord
+  module Type
+    class HashLookupTypeMap < TypeMap # :nodoc:
+      delegate :key?, to: :@mapping
+
+      def alias_type(type, alias_type)
+        register_type(type) { |_, *args| lookup(alias_type, *args) }
+      end
+
+      private
+
+      def perform_fetch(type, *args, &block)
+        @mapping.fetch(type, block).call(type, *args)
+      end
+    end
+  end
+end

data/lib/active_record/type/integer.rb

@@ -0,0 +1,55 @@
+module ActiveRecord
+  module Type
+    class Integer < Value # :nodoc:
+      include Numeric
+
+      def initialize(*)
+        super
+        @range = min_value...max_value
+      end
+
+      def type
+        :integer
+      end
+
+      alias type_cast_for_database type_cast
+
+      def type_cast_from_database(value)
+        return if value.nil?
+        value.to_i
+      end
+
+      protected
+
+      attr_reader :range
+
+      private
+
+      def cast_value(value)
+        case value
+        when true then 1
+        when false then 0
+        else
+          result = value.to_i rescue nil
+          ensure_in_range(result) if result
+          result
+        end
+      end
+
+      def ensure_in_range(value)
+        unless range.cover?(value)
+          raise RangeError, "#{value} is out of range for #{self.class} with limit #{limit || 4}"
+        end
+      end
+
+      def max_value
+        limit = self.limit || 4
+        1 << (limit * 8 - 1) # 8 bits per byte with one bit for sign
+      end
+
+      def min_value
+        -max_value
+      end
+    end
+  end
+end

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