radiant 0.8.0 → 0.8.1

data/vendor/rails/activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb

@@ -1,3 +1,4 @@
+# encoding: binary
 require 'active_record/connection_adapters/abstract_adapter'
 
 module ActiveRecord
@@ -15,6 +16,10 @@ module ActiveRecord
           db.results_as_hash  = true if defined? SQLite::Version
           db.type_translation = false
 
+          message = "Support for SQLite2Adapter and DeprecatedSQLiteAdapter has been removed from Rails 3. "
+          message << "You should migrate to SQLite 3+ or use the plugin from git://github.com/rails/sqlite2_adapter.git with Rails 3."
+          ActiveSupport::Deprecation.warn(message)
+
           # "Downgrade" deprecated sqlite API
           if SQLite.const_defined?(:Version)
             ConnectionAdapters::SQLite2Adapter.new(db, logger, config)
@@ -26,6 +31,10 @@ module ActiveRecord
 
       private
         def parse_sqlite_config!(config)
+          if config.include?(:dbfile)
+            ActiveSupport::Deprecation.warn "Please update config/database.yml to use 'database' instead of 'dbfile'"
+          end
+
           config[:database] ||= config[:dbfile]
           # Require database.
           unless config[:database]
@@ -46,6 +55,7 @@ module ActiveRecord
     class SQLiteColumn < Column #:nodoc:
       class <<  self
         def string_to_binary(value)
+          value = value.dup.force_encoding(Encoding::BINARY) if value.respond_to?(:force_encoding)
           value.gsub(/\0|\%/n) do |b|
             case b
               when "\0" then "%00"
@@ -55,6 +65,7 @@ module ActiveRecord
         end
 
         def binary_to_string(value)
+          value = value.dup.force_encoding(Encoding::BINARY) if value.respond_to?(:force_encoding)
           value.gsub(/%00|%25/n) do |b|
             case b
               when "%00" then "\0"
@@ -101,6 +112,10 @@ module ActiveRecord
         true
       end
 
+      def supports_primary_key? #:nodoc:
+        true
+      end
+
       def requires_reloading?
         true
       end

data/vendor/rails/activerecord/lib/active_record/dirty.rb

@@ -143,7 +143,7 @@ module ActiveRecord
         if partial_updates?
           # Serialized attributes should always be written in case they've been
           # changed in place.
-          update_without_dirty(changed | self.class.serialized_attributes.keys)
+          update_without_dirty(changed | (attributes.keys & self.class.serialized_attributes.keys))
         else
           update_without_dirty
         end

data/vendor/rails/activerecord/lib/active_record/fixtures.rb

@@ -1,6 +1,7 @@
 require 'erb'
 require 'yaml'
 require 'csv'
+require 'zlib'
 require 'active_support/dependencies'
 require 'active_support/test_case'
 
@@ -433,6 +434,7 @@ end
 # Any fixture labeled "DEFAULTS" is safely ignored.
 
 class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
+  MAX_ID = 2 ** 31 - 1
   DEFAULT_FILTER_RE = /\.ya?ml$/
 
   @@all_cached_fixtures = {}
@@ -524,11 +526,10 @@ class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
     cached_fixtures(connection, table_names)
   end
 
-  # Returns a consistent identifier for +label+. This will always
-  # be a positive integer, and will always be the same for a given
-  # label, assuming the same OS, platform, and version of Ruby.
+  # Returns a consistent, platform-independent identifier for +label+.
+  # Identifiers are positive integers less than 2^32.
   def self.identify(label)
-    label.to_s.hash.abs
+    Zlib.crc32(label.to_s) % MAX_ID
   end
 
   attr_reader :table_name, :name
@@ -620,7 +621,8 @@ class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
               targets.each do |target|
                 join_fixtures["#{label}_#{target}"] = Fixture.new(
                   { association.primary_key_name => row[primary_key_name],
-                    association.association_foreign_key => Fixtures.identify(target) }, nil)
+                    association.association_foreign_key => Fixtures.identify(target) },
+                  nil, @connection)
               end
             end
           end
@@ -704,12 +706,12 @@ class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
 
         yaml_value.each do |fixture|
           raise Fixture::FormatError, "Bad data for #{@class_name} fixture named #{fixture}" unless fixture.respond_to?(:each)
-	  fixture.each do |name, data|
+          fixture.each do |name, data|
             unless data
               raise Fixture::FormatError, "Bad data for #{@class_name} fixture named #{name} (nil)"
             end
 
-            self[name] = Fixture.new(data, model_class)
+            self[name] = Fixture.new(data, model_class, @connection)
           end
         end
       end
@@ -722,7 +724,7 @@ class Fixtures < (RUBY_VERSION < '1.9' ? YAML::Omap : Hash)
       reader.each do |row|
         data = {}
         row.each_with_index { |cell, j| data[header[j].to_s.strip] = cell.to_s.strip }
-        self["#{@class_name.to_s.underscore}_#{i+=1}"] = Fixture.new(data, model_class)
+        self["#{@class_name.to_s.underscore}_#{i+=1}"] = Fixture.new(data, model_class, @connection)
       end
     end
 
@@ -760,7 +762,8 @@ class Fixture #:nodoc:
 
   attr_reader :model_class
 
-  def initialize(fixture, model_class)
+  def initialize(fixture, model_class, connection = ActiveRecord::Base.connection)
+    @connection = connection
     @fixture = fixture
     @model_class = model_class.is_a?(Class) ? model_class : model_class.constantize rescue nil
   end
@@ -782,14 +785,14 @@ class Fixture #:nodoc:
   end
 
   def key_list
-    columns = @fixture.keys.collect{ |column_name| ActiveRecord::Base.connection.quote_column_name(column_name) }
+    columns = @fixture.keys.collect{ |column_name| @connection.quote_column_name(column_name) }
     columns.join(", ")
   end
 
   def value_list
     list = @fixture.inject([]) do |fixtures, (key, value)|
       col = model_class.columns_hash[key] if model_class.respond_to?(:ancestors) && model_class.ancestors.include?(ActiveRecord::Base)
-      fixtures << ActiveRecord::Base.connection.quote(value, col).gsub('[^\]\\n', "\n").gsub('[^\]\\r', "\r")
+      fixtures << @connection.quote(value, col).gsub('[^\]\\n', "\n").gsub('[^\]\\r', "\r")
     end
     list * ', '
   end

data/vendor/rails/activerecord/lib/active_record/i18n_interpolation_deprecation.rb

@@ -10,7 +10,7 @@ module I18n
 
       protected
         def interpolate_with_deprecated_syntax(locale, string, values = {})
-          return string unless string.is_a?(String)
+          return string unless string.is_a?(String) && !values.empty?
 
           string = string.gsub(/%d|%s/) do |s|
             instead = DEPRECATED_INTERPOLATORS[s]

data/vendor/rails/activerecord/lib/active_record/locale/en.yml

@@ -23,8 +23,12 @@ en:
         less_than_or_equal_to: "must be less than or equal to {{count}}"
         odd: "must be odd"
         even: "must be even"
+        record_invalid: "Validation failed: {{errors}}"
         # Append your own errors here or at the model/attributes scope.
 
+      full_messages:
+        format: "{{attribute}} {{message}}"
+
       # You can define own errors for models or model attributes.
       # The values :model, :attribute and :value are always available for interpolation.
       #

data/vendor/rails/activerecord/lib/active_record/named_scope.rb

@@ -89,12 +89,7 @@ module ActiveRecord
             when Hash
               options
             when Proc
-              case parent_scope
-              when Scope
-                with_scope(:find => parent_scope.proxy_options) { options.call(*args) }
-              else
-                options.call(*args)
-              end
+              options.call(*args)
           end, &block)
         end
         (class << self; self end).instance_eval do
@@ -114,7 +109,7 @@ module ActiveRecord
         end
       end
 
-      delegate :scopes, :with_scope, :to => :proxy_scope
+      delegate :scopes, :with_scope, :scoped_methods, :to => :proxy_scope
 
       def initialize(proxy_scope, options, &block)
         options ||= {}
@@ -178,7 +173,7 @@ module ActiveRecord
         else
           with_scope({:find => proxy_options, :create => proxy_options[:conditions].is_a?(Hash) ?  proxy_options[:conditions] : {}}, :reverse_merge) do
             method = :new if method == :build
-            if current_scoped_methods_when_defined
+            if current_scoped_methods_when_defined && !scoped_methods.include?(current_scoped_methods_when_defined)
               with_scope current_scoped_methods_when_defined do
                 proxy_scope.send(method, *args, &block)
               end

data/vendor/rails/activerecord/lib/active_record/reflection.rb

@@ -297,7 +297,7 @@ module ActiveRecord
           raise HasManyThroughAssociationPolymorphicError.new(active_record.name, self, source_reflection)
         end
 
-        unless [:belongs_to, :has_many].include?(source_reflection.macro) && source_reflection.options[:through].nil?
+        unless [:belongs_to, :has_many, :has_one].include?(source_reflection.macro) && source_reflection.options[:through].nil?
           raise HasManyThroughSourceAssociationMacroError.new(self)
         end
       end

data/vendor/rails/activerecord/lib/active_record/schema_dumper.rb

@@ -78,11 +78,13 @@ HEADER
         begin
           tbl = StringIO.new
 
+          # first dump primary key column
           if @connection.respond_to?(:pk_and_sequence_for)
             pk, pk_seq = @connection.pk_and_sequence_for(table)
+          elsif @connection.respond_to?(:primary_key)
+            pk = @connection.primary_key(table)
           end
-          pk ||= 'id'
-
+          
           tbl.print "  create_table #{table.inspect}"
           if columns.detect { |c| c.name == pk }
             if pk != 'id'
@@ -94,6 +96,7 @@ HEADER
           tbl.print ", :force => true"
           tbl.puts " do |t|"
 
+          # then dump all non-primary key columns
           column_specs = columns.map do |column|
             raise StandardError, "Unknown type '#{column.sql_type}' for column '#{column.name}'" if @types[column.type].nil?
             next if column.name == pk
@@ -176,4 +179,4 @@ HEADER
         end
       end
   end
-end
+end

data/vendor/rails/activerecord/lib/active_record/serialization.rb

@@ -5,8 +5,9 @@ module ActiveRecord #:nodoc:
     class Serializer #:nodoc:
       attr_reader :options
 
-      def initialize(record, options = {})
-        @record, @options = record, options.dup
+      def initialize(record, options = nil)
+        @record = record
+        @options = options ? options.dup : {}
       end
 
       # To replicate the behavior in ActiveRecord#attributes,

data/vendor/rails/activerecord/lib/active_record/serializers/json_serializer.rb

@@ -1,8 +1,10 @@
+require 'active_support/json'
+require 'active_support/core_ext/module/model_naming'
+
 module ActiveRecord #:nodoc:
   module Serialization
     def self.included(base)
       base.cattr_accessor :include_root_in_json, :instance_writer => false
-      base.extend ClassMethods
     end
 
     # Returns a JSON string representing the model. Some configuration is
@@ -72,28 +74,18 @@ module ActiveRecord #:nodoc:
     #                   {"comments": [{"body": "Don't think too hard"}],
     #                    "title": "So I was thinking"}]}
     def to_json(options = {})
-      if include_root_in_json
-        "{#{self.class.json_class_name}: #{JsonSerializer.new(self, options).to_s}}"
-      else
-        JsonSerializer.new(self, options).to_s
-      end
+      super
+    end
+
+    def as_json(options = nil) #:nodoc:
+      hash = Serializer.new(self, options).serializable_record
+      hash = { self.class.model_name.element => hash } if include_root_in_json
+      hash
     end
 
     def from_json(json)
       self.attributes = ActiveSupport::JSON.decode(json)
       self
     end
-
-    class JsonSerializer < ActiveRecord::Serialization::Serializer #:nodoc:
-      def serialize
-        serializable_record.to_json
-      end
-    end
-
-    module ClassMethods
-      def json_class_name
-        @json_class_name ||= name.demodulize.underscore.inspect
-      end
-    end
   end
 end

data/vendor/rails/activerecord/lib/active_record/serializers/xml_serializer.rb

@@ -178,7 +178,7 @@ module ActiveRecord #:nodoc:
     end
 
     def root
-      root = (options[:root] || @record.class.to_s.underscore).to_s
+      root = (options[:root] || @record.class.model_name.singular).to_s
       reformat_name(root)
     end
 
@@ -320,7 +320,11 @@ module ActiveRecord #:nodoc:
 
       protected
         def compute_type
-          type = @record.class.serialized_attributes.has_key?(name) ? :yaml : @record.class.columns_hash[name].type
+          type = if @record.class.serialized_attributes.has_key?(name)
+                   :yaml
+                 else
+                   @record.class.columns_hash[name].try(:type)
+                 end
 
           case type
             when :text

data/vendor/rails/activerecord/lib/active_record/session_store.rb

@@ -295,7 +295,7 @@ module ActiveRecord
 
       def set_session(env, sid, session_data)
         Base.silence do
-          record = env[SESSION_RECORD_KEY] ||= find_session(sid)
+          record = get_session_model(env, sid)
           record.data = session_data
           return false unless record.save
 
@@ -309,6 +309,14 @@ module ActiveRecord
 
         return true
       end
+      
+      def get_session_model(env, sid)
+        if env[ENV_SESSION_OPTIONS_KEY][:id].nil?
+          env[SESSION_RECORD_KEY] = find_session(sid)
+        else
+          env[SESSION_RECORD_KEY] ||= find_session(sid)
+        end
+      end
 
       def find_session(id)
         @@session_class.find_by_session_id(id) ||

data/vendor/rails/activerecord/lib/active_record/timestamp.rb

@@ -15,27 +15,57 @@ module ActiveRecord
       base.class_inheritable_accessor :record_timestamps, :instance_writer => false
       base.record_timestamps = true
     end
+    
+    # Saves the record with the updated_at/on attributes set to the current time.
+    # If the save fails because of validation errors, an ActiveRecord::RecordInvalid exception is raised.
+    # If an attribute name is passed, that attribute is used for the touch instead of the updated_at/on attributes.
+    #
+    # Examples:
+    #
+    #   product.touch               # updates updated_at
+    #   product.touch(:designed_at) # updates the designed_at attribute
+    def touch(attribute = nil)
+      current_time = current_time_from_proper_timezone
+
+      if attribute
+        write_attribute(attribute, current_time)
+      else
+        write_attribute('updated_at', current_time) if respond_to?(:updated_at)
+        write_attribute('updated_on', current_time) if respond_to?(:updated_on)
+      end
+
+      save!
+    end
+
 
     private
       def create_with_timestamps #:nodoc:
         if record_timestamps
-          t = self.class.default_timezone == :utc ? Time.now.utc : Time.now
-          write_attribute('created_at', t) if respond_to?(:created_at) && created_at.nil?
-          write_attribute('created_on', t) if respond_to?(:created_on) && created_on.nil?
+          current_time = current_time_from_proper_timezone
 
-          write_attribute('updated_at', t) if respond_to?(:updated_at) && updated_at.nil?
-          write_attribute('updated_on', t) if respond_to?(:updated_on) && updated_on.nil?
+          write_attribute('created_at', current_time) if respond_to?(:created_at) && created_at.nil?
+          write_attribute('created_on', current_time) if respond_to?(:created_on) && created_on.nil?
+
+          write_attribute('updated_at', current_time) if respond_to?(:updated_at) && updated_at.nil?
+          write_attribute('updated_on', current_time) if respond_to?(:updated_on) && updated_on.nil?
         end
+
         create_without_timestamps
       end
 
       def update_with_timestamps(*args) #:nodoc:
         if record_timestamps && (!partial_updates? || changed?)
-          t = self.class.default_timezone == :utc ? Time.now.utc : Time.now
-          write_attribute('updated_at', t) if respond_to?(:updated_at)
-          write_attribute('updated_on', t) if respond_to?(:updated_on)
+          current_time = current_time_from_proper_timezone
+
+          write_attribute('updated_at', current_time) if respond_to?(:updated_at)
+          write_attribute('updated_on', current_time) if respond_to?(:updated_on)
         end
+
         update_without_timestamps(*args)
       end
+      
+      def current_time_from_proper_timezone
+        self.class.default_timezone == :utc ? Time.now.utc : Time.now
+      end
   end
-end
+end

data/vendor/rails/activerecord/lib/active_record/validations.rb

@@ -10,15 +10,122 @@ module ActiveRecord
     attr_reader :record
     def initialize(record)
       @record = record
-      super("Validation failed: #{@record.errors.full_messages.join(", ")}")
+      errors = @record.errors.full_messages.join(I18n.t('support.array.words_connector', :default => ', '))
+      super(I18n.t('activerecord.errors.messages.record_invalid', :errors => errors))
     end
   end
 
+  class Error
+    attr_accessor :base, :attribute, :type, :message, :options
+
+    def initialize(base, attribute, type = nil, options = {})
+      self.base      = base
+      self.attribute = attribute
+      self.type      = type || :invalid
+      self.options   = options
+      self.message   = options.delete(:message) || self.type
+    end
+
+    def message
+      generate_message(@message, options.dup)
+    end
+
+    def full_message
+      attribute.to_s == 'base' ? message : generate_full_message(message, options.dup)
+    end
+
+    alias :to_s :message
+
+    def value
+      @base.respond_to?(attribute) ? @base.send(attribute) : nil
+    end
+
+    protected
+
+      # Translates an error message in it's default scope (<tt>activerecord.errrors.messages</tt>).
+      # Error messages are first looked up in <tt>models.MODEL.attributes.ATTRIBUTE.MESSAGE</tt>, if it's not there,
+      # it's looked up in <tt>models.MODEL.MESSAGE</tt> and if that is not there it returns the translation of the
+      # default message (e.g. <tt>activerecord.errors.messages.MESSAGE</tt>). The translated model name,
+      # translated attribute name and the value are available for interpolation.
+      #
+      # When using inheritence in your models, it will check all the inherited models too, but only if the model itself
+      # hasn't been found. Say you have <tt>class Admin < User; end</tt> and you wanted the translation for the <tt>:blank</tt>
+      # error +message+ for the <tt>title</tt> +attribute+, it looks for these translations:
+      #
+      # <ol>
+      # <li><tt>activerecord.errors.models.admin.attributes.title.blank</tt></li>
+      # <li><tt>activerecord.errors.models.admin.blank</tt></li>
+      # <li><tt>activerecord.errors.models.user.attributes.title.blank</tt></li>
+      # <li><tt>activerecord.errors.models.user.blank</tt></li>
+      # <li><tt>activerecord.errors.messages.blank</tt></li>
+      # <li>any default you provided through the +options+ hash (in the activerecord.errors scope)</li>
+      # </ol>
+      def generate_message(message, options = {})
+        keys = @base.class.self_and_descendants_from_active_record.map do |klass|
+          [ :"models.#{klass.name.underscore}.attributes.#{attribute}.#{message}",
+            :"models.#{klass.name.underscore}.#{message}" ]
+        end.flatten
+
+        keys << options.delete(:default)
+        keys << :"messages.#{message}"
+        keys << message if message.is_a?(String)
+        keys << @type unless @type == message
+        keys.compact!
+
+        options.reverse_merge! :default => keys,
+                               :scope => [:activerecord, :errors],
+                               :model => @base.class.human_name,
+                               :attribute => @base.class.human_attribute_name(attribute.to_s),
+                               :value => value
+
+        I18n.translate(keys.shift, options)
+      end
+
+      # Wraps an error message into a full_message format.
+      #
+      # The default full_message format for any locale is <tt>"{{attribute}} {{message}}"</tt>.
+      # One can specify locale specific default full_message format by storing it as a
+      # translation for the key <tt>:"activerecord.errors.full_messages.format"</tt>.
+      #
+      # Additionally one can specify a validation specific error message format by
+      # storing a translation for <tt>:"activerecord.errors.full_messages.[message_key]"</tt>.
+      # E.g. the full_message format for any validation that uses :blank as a message
+      # key (such as validates_presence_of) can be stored to <tt>:"activerecord.errors.full_messages.blank".</tt>
+      #
+      # Because the message key used by a validation can be overwritten on the
+      # <tt>validates_*</tt> class macro level one can customize the full_message format for
+      # any particular validation:
+      #
+      #   # app/models/article.rb
+      #   class Article < ActiveRecord::Base
+      #     validates_presence_of :title, :message => :"title.blank"
+      #   end
+      #
+      #   # config/locales/en.yml
+      #   en:
+      #     activerecord:
+      #       errors:
+      #         full_messages:
+      #           title:
+      #             blank: This title is screwed!
+      def generate_full_message(message, options = {})
+        options.reverse_merge! :message => self.message,
+                               :model => @base.class.human_name,
+                               :attribute => @base.class.human_attribute_name(attribute.to_s),
+                               :value => value
+
+        key = :"full_messages.#{@message}"
+        defaults = [:'full_messages.format', '{{attribute}} {{message}}']
+
+        I18n.t(key, options.merge(:default => defaults, :scope => [:activerecord, :errors]))
+      end
+  end
+
   # Active Record validation is reported to and from this object, which is used by Base#save to
   # determine whether the object is in a valid state to be saved. See usage example in Validations.
   class Errors
     include Enumerable
-    
+
     class << self
       def default_error_messages
         ActiveSupport::Deprecation.warn("ActiveRecord::Errors.default_error_messages has been deprecated. Please use I18n.translate('activerecord.errors.messages').")
@@ -43,11 +150,19 @@ module ActiveRecord
     # error can be added to the same +attribute+ in which case an array will be returned on a call to <tt>on(attribute)</tt>.
     # If no +messsage+ is supplied, :invalid is assumed.
     # If +message+ is a Symbol, it will be translated, using the appropriate scope (see translate_error).
-    def add(attribute, message = nil, options = {})
-      message ||= :invalid
-      message = generate_message(attribute, message, options) if message.is_a?(Symbol)
+    # def add(attribute, message = nil, options = {})
+    #   message ||= :invalid
+    #   message = generate_message(attribute, message, options)) if message.is_a?(Symbol)
+    #   @errors[attribute.to_s] ||= []
+    #   @errors[attribute.to_s] << message
+    # end
+
+    def add(error_or_attr, message = nil, options = {})
+      error, attribute = error_or_attr.is_a?(Error) ? [error_or_attr, error_or_attr.attribute] : [nil, error_or_attr]
+      options[:message] = options.delete(:default) if options.has_key?(:default)
+
       @errors[attribute.to_s] ||= []
-      @errors[attribute.to_s] << message
+      @errors[attribute.to_s] << (error || Error.new(@base, attribute, message, options))
     end
 
     # Will add an error message to each of the attributes in +attributes+ that is empty.
@@ -66,49 +181,6 @@ module ActiveRecord
         add(attr, :blank, :default => custom_message) if value.blank?
       end
     end
-    
-    # Translates an error message in it's default scope (<tt>activerecord.errrors.messages</tt>).
-    # Error messages are first looked up in <tt>models.MODEL.attributes.ATTRIBUTE.MESSAGE</tt>, if it's not there, 
-    # it's looked up in <tt>models.MODEL.MESSAGE</tt> and if that is not there it returns the translation of the 
-    # default message (e.g. <tt>activerecord.errors.messages.MESSAGE</tt>). The translated model name, 
-    # translated attribute name and the value are available for interpolation.
-    #
-    # When using inheritence in your models, it will check all the inherited models too, but only if the model itself
-    # hasn't been found. Say you have <tt>class Admin < User; end</tt> and you wanted the translation for the <tt>:blank</tt>
-    # error +message+ for the <tt>title</tt> +attribute+, it looks for these translations:
-    # 
-    # <ol>
-    # <li><tt>activerecord.errors.models.admin.attributes.title.blank</tt></li>
-    # <li><tt>activerecord.errors.models.admin.blank</tt></li>
-    # <li><tt>activerecord.errors.models.user.attributes.title.blank</tt></li>
-    # <li><tt>activerecord.errors.models.user.blank</tt></li>
-    # <li><tt>activerecord.errors.messages.blank</tt></li>
-    # <li>any default you provided through the +options+ hash (in the activerecord.errors scope)</li>
-    # </ol>
-    def generate_message(attribute, message = :invalid, options = {})
-
-      message, options[:default] = options[:default], message if options[:default].is_a?(Symbol)
-
-      defaults = @base.class.self_and_descendants_from_active_record.map do |klass|
-        [ :"models.#{klass.name.underscore}.attributes.#{attribute}.#{message}", 
-          :"models.#{klass.name.underscore}.#{message}" ]
-      end
-      
-      defaults << options.delete(:default)
-      defaults = defaults.compact.flatten << :"messages.#{message}"
-
-      key = defaults.shift
-      value = @base.respond_to?(attribute) ? @base.send(attribute) : nil
-
-      options = { :default => defaults,
-        :model => @base.class.human_name,
-        :attribute => @base.class.human_attribute_name(attribute.to_s),
-        :value => value,
-        :scope => [:activerecord, :errors]
-      }.merge(options)
-
-      I18n.translate(key, options)
-    end
 
     # Returns true if the specified +attribute+ has errors associated with it.
     #
@@ -138,8 +210,9 @@ module ActiveRecord
     #   company.errors.on(:email)     # => "can't be blank"
     #   company.errors.on(:address)   # => nil
     def on(attribute)
-      errors = @errors[attribute.to_s]
-      return nil if errors.nil?
+      attribute = attribute.to_s
+      return nil unless @errors.has_key?(attribute)
+      errors = @errors[attribute].map(&:to_s)
       errors.size == 1 ? errors.first : errors
     end
 
@@ -163,7 +236,11 @@ module ActiveRecord
     #   #    name - can't be blank
     #   #    address - can't be blank
     def each
-      @errors.each_key { |attr| @errors[attr].each { |msg| yield attr, msg } }
+      @errors.each_key { |attr| @errors[attr].each { |error| yield attr, error.message } }
+    end
+
+    def each_error
+      @errors.each_key { |attr| @errors[attr].each { |error| yield attr, error } }
     end
 
     # Yields each full error message added. So <tt>Person.errors.add("first_name", "can't be empty")</tt> will be returned
@@ -194,22 +271,10 @@ module ActiveRecord
     #   company.errors.full_messages # =>
     #     ["Name is too short (minimum is 5 characters)", "Name can't be blank", "Address can't be blank"]
     def full_messages(options = {})
-      full_messages = []
-
-      @errors.each_key do |attr|
-        @errors[attr].each do |message|
-          next unless message
-
-          if attr == "base"
-            full_messages << message
-          else
-            attr_name = @base.class.human_attribute_name(attr)
-            full_messages << attr_name + I18n.t('activerecord.errors.format.separator', :default => ' ') + message
-          end
-        end
+      @errors.values.inject([]) do |full_messages, errors|
+        full_messages + errors.map { |error| error.full_message }
       end
-      full_messages
-    end 
+    end
 
     # Returns true if no errors have been added.
     def empty?
@@ -254,7 +319,11 @@ module ActiveRecord
         full_messages.each { |msg| e.error(msg) }
       end
     end
-    
+
+    def generate_message(attribute, message = :invalid, options = {})
+      ActiveSupport::Deprecation.warn("ActiveRecord::Errors#generate_message has been deprecated. Please use ActiveRecord::Error#generate_message.")
+      Error.new(@base, attribute, message, options).to_s
+    end
   end
 
 
@@ -437,7 +506,7 @@ module ActiveRecord
 
         validates_each(attr_names, configuration) do |record, attr_name, value|
           unless record.send("#{attr_name}_confirmation").nil? or value == record.send("#{attr_name}_confirmation")
-            record.errors.add(attr_name, :confirmation, :default => configuration[:message]) 
+            record.errors.add(attr_name, :confirmation, :default => configuration[:message])
           end
         end
       end
@@ -479,7 +548,7 @@ module ActiveRecord
 
         validates_each(attr_names,configuration) do |record, attr_name, value|
           unless value == configuration[:accept]
-            record.errors.add(attr_name, :accepted, :default => configuration[:message]) 
+            record.errors.add(attr_name, :accepted, :default => configuration[:message])
           end
         end
       end
@@ -499,7 +568,7 @@ module ActiveRecord
       #
       # Configuration options:
       # * <tt>message</tt> - A custom error message (default is: "can't be blank").
-      # * <tt>on</tt> - Specifies when this validation is active (default is <tt>:save</tt>, other options <tt>:create</tt>, 
+      # * <tt>on</tt> - Specifies when this validation is active (default is <tt>:save</tt>, other options <tt>:create</tt>,
       #   <tt>:update</tt>).
       # * <tt>if</tt> - Specifies a method, proc or string to call to determine if the validation should
       #   occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>).
@@ -599,7 +668,7 @@ module ActiveRecord
             validates_each(attrs, options) do |record, attr, value|
               value = options[:tokenizer].call(value) if value.kind_of?(String)
               unless !value.nil? and value.size.method(validity_checks[option])[option_value]
-                record.errors.add(attr, key, :default => custom_message, :count => option_value) 
+                record.errors.add(attr, key, :default => custom_message, :count => option_value)
               end
             end
         end
@@ -687,7 +756,7 @@ module ActiveRecord
       #   ActiveRecord::ConnectionAdapters::SchemaStatements#add_index. In the
       #   rare case that a race condition occurs, the database will guarantee
       #   the field's uniqueness.
-      #   
+      #
       #   When the database catches such a duplicate insertion,
       #   ActiveRecord::Base#save will raise an ActiveRecord::StatementInvalid
       #   exception. You can either choose to let this error propagate (which
@@ -696,7 +765,7 @@ module ActiveRecord
       #   that the title already exists, and asking him to re-enter the title).
       #   This technique is also known as optimistic concurrency control:
       #   http://en.wikipedia.org/wiki/Optimistic_concurrency_control
-      #   
+      #
       #   Active Record currently provides no way to distinguish unique
       #   index constraint errors from other types of database errors, so you
       #   will have to parse the (database-specific) exception message to detect
@@ -726,7 +795,7 @@ module ActiveRecord
             comparison_operator = "IS ?"
           elsif column.text?
             comparison_operator = "#{connection.case_sensitive_equality_operator} ?"
-            value = column.limit ? value.to_s[0, column.limit] : value.to_s
+            value = column.limit ? value.to_s.mb_chars[0, column.limit] : value.to_s
           else
             comparison_operator = "= ?"
           end
@@ -794,7 +863,7 @@ module ActiveRecord
 
         validates_each(attr_names, configuration) do |record, attr_name, value|
           unless value.to_s =~ configuration[:with]
-            record.errors.add(attr_name, :invalid, :default => configuration[:message], :value => value) 
+            record.errors.add(attr_name, :invalid, :default => configuration[:message], :value => value)
           end
         end
       end
@@ -802,7 +871,7 @@ module ActiveRecord
       # Validates whether the value of the specified attribute is available in a particular enumerable object.
       #
       #   class Person < ActiveRecord::Base
-      #     validates_inclusion_of :gender, :in => %w( m f ), :message => "woah! what are you then!??!!"
+      #     validates_inclusion_of :gender, :in => %w( m f )
       #     validates_inclusion_of :age, :in => 0..99
       #     validates_inclusion_of :format, :in => %w( jpg gif png ), :message => "extension {{value}} is not included in the list"
       #   end
@@ -828,7 +897,7 @@ module ActiveRecord
 
         validates_each(attr_names, configuration) do |record, attr_name, value|
           unless enum.include?(value)
-            record.errors.add(attr_name, :inclusion, :default => configuration[:message], :value => value) 
+            record.errors.add(attr_name, :inclusion, :default => configuration[:message], :value => value)
           end
         end
       end
@@ -862,7 +931,7 @@ module ActiveRecord
 
         validates_each(attr_names, configuration) do |record, attr_name, value|
           if enum.include?(value)
-            record.errors.add(attr_name, :exclusion, :default => configuration[:message], :value => value) 
+            record.errors.add(attr_name, :exclusion, :default => configuration[:message], :value => value)
           end
         end
       end
@@ -970,7 +1039,7 @@ module ActiveRecord
             case option
               when :odd, :even
                 unless raw_value.to_i.method(ALL_NUMERICALITY_CHECKS[option])[]
-                  record.errors.add(attr_name, option, :value => raw_value, :default => configuration[:message]) 
+                  record.errors.add(attr_name, option, :value => raw_value, :default => configuration[:message])
                 end
               else
                 record.errors.add(attr_name, option, :default => configuration[:message], :value => raw_value, :count => configuration[option]) unless raw_value.method(ALL_NUMERICALITY_CHECKS[option])[configuration[option]]