activerecord 4.2.0

data/lib/active_record/type/serialized.rb

@@ -0,0 +1,56 @@
+module ActiveRecord
+  module Type
+    class Serialized < DelegateClass(Type::Value) # :nodoc:
+      include Mutable
+      include Decorator
+
+      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 changed_in_place?(raw_old_value, value)
+        return false if value.nil?
+        subtype.changed_in_place?(raw_old_value, coder.dump(value))
+      end
+
+      def accessor
+        ActiveRecord::Store::IndifferentHashAccessor
+      end
+
+      def init_with(coder)
+        @coder = coder['coder']
+        super
+      end
+
+      def encode_with(coder)
+        coder['coder'] = @coder
+        super
+      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 "t"
+        when false then "f"
+        else super
+        end
+      end
+
+      private
+
+      def cast_value(value)
+        case value
+        when true then "t"
+        when false then "f"
+        # 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,64 @@
+require 'thread_safe'
+
+module ActiveRecord
+  module Type
+    class TypeMap # :nodoc:
+      def initialize
+        @mapping = {}
+        @cache = ThreadSafe::Cache.new do |h, key|
+          h.fetch_or_store(key, ThreadSafe::Cache.new)
+        end
+      end
+
+      def lookup(lookup_key, *args)
+        fetch(lookup_key, *args) { default_value }
+      end
+
+      def fetch(lookup_key, *args, &block)
+        @cache[lookup_key].fetch_or_store(args) do
+          perform_fetch(lookup_key, *args, &block)
+        end
+      end
+
+      def register_type(key, value = nil, &block)
+        raise ::ArgumentError unless value || block
+        @cache.clear
+
+        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 perform_fetch(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
+          yield lookup_key, *args
+        end
+      end
+
+      def default_value
+        @default_value ||= Value.new
+      end
+    end
+  end
+end

data/lib/active_record/type/unsigned_integer.rb

@@ -0,0 +1,15 @@
+module ActiveRecord
+  module Type
+    class UnsignedInteger < Integer # :nodoc:
+      private
+
+      def max_value
+        super * 2
+      end
+
+      def min_value
+        0
+      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

@@ -0,0 +1,90 @@
+module ActiveRecord
+  # = Active Record RecordInvalid
+  #
+  # Raised by <tt>save!</tt> and <tt>create!</tt> when the record is invalid. Use the
+  # +record+ method to retrieve the record which did not validate.
+  #
+  #   begin
+  #     complex_operation_that_internally_calls_save!
+  #   rescue ActiveRecord::RecordInvalid => invalid
+  #     puts invalid.record.errors
+  #   end
+  class RecordInvalid < ActiveRecordError
+    attr_reader :record
+
+    def initialize(record)
+      @record = record
+      errors = @record.errors.full_messages.join(", ")
+      super(I18n.t(:"#{@record.class.i18n_scope}.errors.messages.record_invalid", :errors => errors, :default => :"errors.messages.record_invalid"))
+    end
+  end
+
+  # = Active Record Validations
+  #
+  # Active Record includes the majority of its validations from <tt>ActiveModel::Validations</tt>
+  # all of which accept the <tt>:on</tt> argument to define the context where the
+  # validations are active. Active Record will always supply either the context of
+  # <tt>:create</tt> or <tt>:update</tt> dependent on whether the model is a
+  # <tt>new_record?</tt>.
+  module Validations
+    extend ActiveSupport::Concern
+    include ActiveModel::Validations
+
+    # 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.
+    def save(options={})
+      perform_validations(options) ? super : false
+    end
+
+    # 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_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.
+    #
+    # 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 valid?(context = nil)
+      context ||= (new_record? ? :create : :update)
+      output = super(context)
+      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
+  end
+end
+
+require "active_record/validations/associated"
+require "active_record/validations/uniqueness"
+require "active_record/validations/presence"