activemodel-error 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Sven Fuchs & Mateo Murphy
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,87 @@
+h1. Proposal: validation error messages in ActiveModel
+
+(requires I18n current master)
+
+This stuff is a very rough draft of how I propose to deal with validation
+error messages (and potentially other usecases that need I18n support, such as
+form labels).
+
+It might go into Rails or end up in some plugin or gem.
+
+I'm not looking so much at the actual integration to ActiveModel, yet. So far
+I'm just trying to sketch out the underlying stuff so that it covers all
+requirements in a consistent way.
+
+I want this stuff to be re-usable in other places where similar patterns occur
+when it comes to I18n, such as form labels and potentially other stuff.
+
+h2. Problems solved
+
+* Messages in class method calls are treated as plain text by default
+  (users might optionally want to treat them as translation keys for
+  gettext-style class method calls).
+* Symbols in class method calls are treated as translation keys.
+* Use messages from class method calls consistently with translation keys that
+  are implicitly used for a particular validation.
+* Different translation variants (such as :full_message) for the same message
+  must be possible.
+* Translation calls should optionally be able to cascade over scopes.
+* Support format strings, e.g. "{{attribute}} {{message}}", transparently
+
+h2. Classes
+
+The Error class is the meant to work as a default Error class in ActiveModel.
+
+I18n::Message is the main base class and is supposed to work situations such as 
+error messages, form labels etc.
+
+The Format class is used internally to format other strings (see below).
+
+h2. Features
+
+The Message class comes with six modules that each provide a single feature.
+This way everything's completely optional and pluggable (thus extensible and
+easy to customize) even though we might choose to not impose this complexity
+on the enduser (and maybe pick a default configuration/provide a configuration
+dsl instead).
+
+h3. I18n::Message::Base
+
+This module just takes a Message OR translation key (Symbol) and interpolation 
+values. Calling #to_s will use the string or translate the key and interpolate
+the values. The module is organized in a way so that other modules can hook in 
+easily.
+
+h3. I18n::Message::Gettext
+
+This module will also translate Messages. This behavior is frequently asked for 
+by people who want to use Gettext-style translation keys in class-level calls
+as in validates_presence_of :foo, :message => 'The message'
+
+h3. I18n::Message::Variants
+
+This module adds the ability to specify Hashes as strings both at class-level
+and in translation data. E.g.:
+
+  validates_presence_of :foo, :message => { :short => 'Short!', :full => 'The full message!' }
+
+Calling #to_s on the I18n::Message instance will take a variant key and try to
+find and use the variant. It defaults to the :short variant.
+
+h3. I18n::Message::Formatted
+
+This module adds the ability to specify format strings both at class-level and
+in translation data. E.g.:
+
+  validates_presence_of :foo, :format => 'The formatted {{message}}.'
+
+This module also works in combination with the Variants module in the way one
+would expect:
+
+  validates_presence_of :foo, :message => { :short => 'foo', :full => 'FOO' }
+                              :format  => { :full => 'The formatted {{message}}.' }
+
+message.to_s(:full) would then wrap the :full variant 'FOO' into the :full
+format string and yield 'The formatted FOO'. message.to_s (defaults to :short)
+would just yield 'foo' as expected.
+

data/RakeFile

@@ -0,0 +1,27 @@
+require 'rake/testtask'
+
+task :default => [:test]
+
+Rake::TestTask.new(:test) do |t|
+  t.pattern = "#{File.dirname(__FILE__)}/test/all.rb"
+  t.verbose = true
+end
+Rake::Task['test'].comment = "Run all tests"
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name         = "activemodel-error"
+    s.summary      = "I18n for validation error messages in ActiveModel"
+    s.description  = %(Provides I18n support for validation error messages in ActiveModel.
+                      With Rails 3 ActiveModel validation error messages are not backwards
+                      compatible with ActiveRecord 2.3.x. This Gem aims to restore this 
+                      backwards compatiblity and provide a richer feature set and better
+                      implementation compared to ActiveRecord 2.3.x.)
+    s.homepage     = "http://github.com/svenfuchs/activemodel-error"
+    s.authors      = ["Sven Fuchs", "Mateo Murphy"]
+    s.files        =  FileList["[A-Z]*", "{lib,test}/**/*"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/active_model/attribute_errors.rb

@@ -0,0 +1,44 @@
+module ActiveModel
+  class AttributeErrors
+    include Enumerable
+
+    attr_accessor :attribute, :errors
+    delegate :size, :empty?, :first, :second, :last, :to => :errors
+
+    def initialize(base, attribute)
+      @base = base
+      @attribute = attribute
+      @errors = []
+    end
+
+    def add(message = nil, options = {})
+      message = generate_message(message, options) if message.is_a?(Symbol)
+      @errors << message
+    end
+
+    alias :<< :add
+
+    def each
+      @errors.each { |error| yield error }
+    end
+
+    def include?(message)
+      case message
+      when Symbol
+        @errors.any? { |error| error.subject == message }
+      when String
+        @errors.any? { |error| error.to_s == message }
+      else
+        @errors.include?(message)
+      end
+    end
+
+    def generate_message(type = :invalid, options = {})
+      @base.generate_message(attribute, type, options)
+    end
+
+    def to_a
+      @errors
+    end
+  end
+end

data/lib/active_model/error.rb

@@ -0,0 +1,13 @@
+require 'i18n/message'
+
+module ActiveModel
+  class Error < I18n::Message
+    autoload :Base,   'active_model/error/base'
+    autoload :Format, 'active_model/error/format'
+    autoload :Legacy, 'active_model/error/legacy'
+
+    include Base, Formatted, Variants, Legacy
+
+    self.format_class = ActiveModel::Error::Format
+  end
+end

data/lib/active_model/error/base.rb

@@ -0,0 +1,13 @@
+module ActiveModel
+  class Error < I18n::Message
+    module Base
+      attr_reader :base, :attribute, :value
+
+      def initialize(subject = nil, options = {})
+        @base, @attribute, @value = options.values_at(:model, :attribute, :value)
+        @attribute = attribute
+        super(subject, options)
+      end
+    end
+  end
+end

data/lib/active_model/error/format.rb

@@ -0,0 +1,11 @@
+module ActiveModel
+  class Error
+    class Format < I18n::Message::Format
+      protected
+
+        def scope
+          :"errors.#{super}"
+        end
+    end
+  end
+end

data/lib/active_model/error/legacy.rb

@@ -0,0 +1,30 @@
+module ActiveModel
+  class Error < I18n::Message
+    module Legacy
+    protected
+
+      def translate(subject, options = {})
+        options = translate_options(subject)
+        super(options[:default].shift, options)
+      end
+
+      def translate_options(subject)
+        defaults = base.class.lookup_ancestors.map do |klass|
+          [ :"models.#{klass.name.underscore}.attributes.#{attribute}.#{subject}",
+            :"models.#{klass.name.underscore}.#{subject}" ]
+        end.flatten
+
+        defaults << :"messages.#{subject}"
+
+        options = @options.merge(
+          :scope     => :errors,
+          :default   => defaults,
+          :model     => base.class.model_name.human,
+          :attribute => base.class.human_attribute_name(attribute),
+          :value     => value,
+          :raise     => true
+        )
+      end
+    end
+  end
+end

data/lib/active_model/errors_ext.rb

@@ -0,0 +1,30 @@
+require 'active_support/core_ext/class/attribute_accessors'
+require 'active_support/core_ext/module/delegation'
+require 'active_model'
+
+module ActiveModel
+  autoload :Error, 'active_model/error'
+  autoload :AttributeErrors, 'active_model/attribute_errors'
+
+  class Errors
+    cattr_accessor :error_class
+    @@error_class = ActiveModel::Error
+
+    def [](attribute)
+      if errors = get(attribute.to_sym)
+        errors
+      else
+        set(attribute.to_sym, AttributeErrors.new(self, attribute.to_sym))
+      end
+    end
+
+    def add(attribute, message = nil, options = {})
+      self[attribute].add(message, options)
+    end
+
+    def generate_message(attribute, type = :invalid, options = {})
+      options.update(:model => @base, :attribute => attribute)
+      error_class.new(options.delete(:default) || type, options)
+    end
+  end
+end

data/lib/activemodel_error.rb

@@ -0,0 +1 @@
+require 'active_model/errors_ext'

data/lib/core_ext/error_comparsion.rb

@@ -0,0 +1,25 @@
+class Array
+  def equals_with_active_model_errors(other)
+    other = other.map { |e| e.to_s } if ActiveModel::AttributeErrors === other
+    equals_without_active_model_errors(other)
+  end
+  alias equals_without_active_model_errors ==
+  alias == equals_with_active_model_errors
+end
+
+class Message
+  def equals_with_active_model_error(other)
+    other = other.to_s if ActiveModel::Error === other
+    equals_without_active_model_error(other)
+  end
+  alias equals_without_active_model_error ==
+  alias == equals_with_active_model_error
+
+  def compare_with_active_model_error(other)
+    other = other.to_s if ActiveModel::Error === other
+    compare_without_active_model_error(other)
+  end
+  alias compare_without_active_model_error <=>
+  alias <=> compare_with_active_model_error
+end
+

data/test/active_model/format_test.rb

@@ -0,0 +1,74 @@
+# encoding: utf-8
+require File.expand_path('../../test_helper', __FILE__)
+
+class ActiveModelApiFormatTest < Test::Unit::TestCase
+  class Model
+    include ActiveModel::Validations
+    attr_reader :foo
+    def self.name; 'Model'; end
+  end
+
+  def setup
+    I18n.backend.send(:init_translations) # i.e. don't overwrite our translations
+  end
+
+  def teardown
+    I18n.backend = nil
+    Model.reset_callbacks(:validate)
+  end
+
+  def error_on(attribute)
+    model = Model.new
+    model.valid?
+    model.errors[attribute].first
+  end
+
+  # FIXME this currently can't be supported because rails does not pass the
+  # format option through
+  #
+  # test "uses a format given at class level to format a message" do
+  #   Model.validates_presence_of :foo, :message => 'message', :format => 'formatted %{message}'
+  #   assert_equal "formatted message", error_on(:foo).to_s
+  # end
+
+  test "uses a format stored as a translation to wrap a message (messages namespace)" do
+    Model.validates_presence_of :foo, :message => 'message'
+    store_translations(:'errors.formats.default' => 'formatted %{message}')
+    assert_equal "formatted message", error_on(:foo).to_s
+  end
+
+  # FIXME currently not supported and probably should be optional
+  #
+  # test "uses a format stored as a translation to wrap a message (models namespace)" do
+  #   Model.validates_presence_of :foo, :message => 'message'
+  #   store_translations(:'errors.formats.models.model.default' => 'formatted %{message}')
+  #   assert_equal "formatted message", error_on(:foo).to_s
+  # end
+  # 
+  # test "uses a format stored as a translation to wrap a message (attributes namespace)" do
+  #   Model.validates_presence_of :foo, :message => 'message'
+  #   store_translations(:'errors.formats.models.model.attributes.foo.default' => 'formatted %{message}')
+  #   assert_equal "formatted message", error_on(:foo).to_s
+  # end
+
+  test "uses a format stored as a translation to wrap a message variant (messages namespace)" do
+    Model.validates_presence_of :foo, :message => 'message'
+    store_translations(:'errors.formats.full' => 'full %{message}')
+    assert_equal "full message", error_on(:foo).to_s(:full)
+  end
+
+  # FIXME currently not supported and probably should be optional
+  #
+  # test "uses a format stored as a translation to wrap a message variant (models namespace)" do
+  #   Model.validates_presence_of :foo, :message => 'message'
+  #   store_translations(:'errors.formats.models.model.default' => 'formatted %{message}')
+  #   assert_equal "formatted message", error_on(:foo).to_s
+  # end
+  # 
+  # test "uses a format stored as a translation to wrap a message variant (attributes namespace)" do
+  #   Model.validates_presence_of :foo, :message => 'message'
+  #   store_translations(:'errors.formats.models.model.attributes.foo.default' => 'formatted %{message}')
+  #   assert_equal "formatted message", error_on(:foo).to_s
+  # end
+
+end

data/test/active_model/interpolation_test.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+require File.expand_path('../../test_helper', __FILE__)
+
+class ActiveModelApiInterpolationTest < Test::Unit::TestCase
+  class Model
+    include ActiveModel::Validations
+    attr_reader :foo
+    def self.name; 'Model'; end
+  end
+
+  def setup
+    I18n.backend.send(:init_translations) # i.e. don't overwrite our translations
+  end
+
+  def teardown
+    I18n.backend = nil
+    Model.reset_callbacks(:validate)
+  end
+
+  def error_on(attribute)
+    model = Model.new
+    model.valid?
+    model.errors[attribute].first
+  end
+
+  test "interpolates validation data to a translation from the messages namespace" do
+    store_translations(:'errors.models.model.too_short' => '%{count}')
+    Model.validates_length_of :foo, :minimum => 1
+    assert_equal '1', error_on(:foo).to_s
+  end
+
+  test "interpolation: given a class level :message Message it interpolates validation data to the Message" do
+    Model.validates_length_of :foo, :minimum => 1, :message => '%{count}'
+    assert_equal '1', error_on(:foo).to_s
+  end
+
+  test "interpolation: given a class level :message Symbol it interpolates validation data to the Symbol's translation" do
+    store_translations(:'errors.messages.broken' => '%{count}')
+    Model.validates_length_of :foo, :minimum => 1, :message => :broken
+    assert_equal '1', error_on(:foo).to_s
+  end
+
+  test "interpolation: given a class level :message Proc returning a Message it interpolates validation data to the Message" do
+    Model.validates_length_of :foo, :minimum => 1, :message => proc { '%{count}' }
+    assert_equal '1', error_on(:foo).to_s
+  end
+
+  test "interpolation: given a class level :message Proc returning a Symbol it interpolates validation data to the Symbol's translation" do
+    store_translations(:'errors.messages.broken' => '%{count}')
+    Model.validates_length_of :foo, :minimum => 1, :message => proc { :broken }
+    assert_equal '1', error_on(:foo).to_s
+  end
+
+end

data/test/active_model/lookup_test.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+require File.expand_path('../../test_helper', __FILE__)
+
+class ActiveModelApiLookupTest < Test::Unit::TestCase
+  class Model
+    include ActiveModel::Validations
+    attr_reader :foo
+    def self.name; 'Model'; end
+  end
+
+  def setup
+    I18n.backend.send(:init_translations) # i.e. don't overwrite our translations
+  end
+
+  def teardown
+    I18n.backend = nil
+    Model.reset_callbacks(:validate)
+  end
+
+  def error_on(attribute)
+    model = Model.new
+    model.valid?
+    model.errors[attribute].first
+  end
+
+  # LOOKUP
+
+  test "lookup: it returns a translation from the messages namespace" do
+    Model.validates_presence_of :foo
+    store_translations(:'errors.messages.blank' => 'message')
+    assert_equal "message", error_on(:foo).to_s
+  end
+
+  test "lookup: it returns a translation from the model namespace" do
+    Model.validates_presence_of :foo
+    store_translations(:'errors.models.model.blank' => 'message')
+    assert_equal "message", error_on(:foo).to_s
+  end
+
+  test "lookup: it returns a translation from the attribute namespace" do
+    Model.validates_presence_of :foo
+    store_translations(:'errors.models.model.attributes.foo.blank' => 'message')
+    assert_equal "message", error_on(:foo).to_s
+  end
+
+  # given a :message Message in class level validation macros
+
+  test "lookup: given a class level :message Message it returns the Message" do
+    Model.validates_presence_of :foo, :message => 'message'
+    assert_equal 'message', error_on(:foo).to_s
+  end
+
+  # given a :message Symbol in class level validation macros
+
+  test "lookup: given a class level :message Symbol it translates the Symbol (message namespace)" do
+    store_translations(:'errors.messages.broken' => 'translated')
+    Model.validates_presence_of :foo, :message => :broken
+    assert_equal 'translated', error_on(:foo).to_s
+  end
+
+  test "lookup: given a class level :message Symbol it translates the Symbol (model namespace)" do
+    store_translations(:'errors.models.model.broken' => 'translated')
+    Model.validates_presence_of :foo, :message => :broken
+    assert_equal 'translated', error_on(:foo).to_s
+  end
+
+  test "lookup: given a class level :message Symbol it translates the Symbol (attribute namespace)" do
+    store_translations(:'errors.models.model.attributes.foo.broken' => 'translated')
+    Model.validates_presence_of :foo, :message => :broken
+    assert_equal 'translated', error_on(:foo).to_s
+  end
+
+  # given a :message Proc returning a Message in class level validation macros
+
+  test "lookup: given a class level :message Proc returning a Message it returns the Message" do
+    Model.validates_presence_of :foo, :message => proc { 'message' }
+    assert_equal 'message', error_on(:foo).to_s
+  end
+
+  # given a :message Proc returning a Symbol in class level validation macros
+
+  test "lookup: given a class level :message Proc returning a Symbol it translates the Symbol (message namespace)" do
+    store_translations(:'errors.messages.broken' => 'translated')
+    Model.validates_presence_of :foo, :message => proc { :broken }
+    assert_equal 'translated', error_on(:foo).to_s
+  end
+
+  test "lookup: given a class level :message Proc returning a Symbol it translates the Symbol (model namespace)" do
+    store_translations(:'errors.models.model.broken' => 'translated')
+    Model.validates_presence_of :foo, :message => proc { :broken }
+    assert_equal 'translated', error_on(:foo).to_s
+  end
+
+  test "lookup: given a class level :message Proc returning a Symbol it translates the Symbol (attribute namespace)" do
+    store_translations(:'errors.models.model.attributes.foo.broken' => 'translated')
+    Model.validates_presence_of :foo, :message => proc { :broken }
+    assert_equal 'translated', error_on(:foo).to_s
+  end
+end

data/test/active_model/variants_test.rb

@@ -0,0 +1,121 @@
+# encoding: utf-8
+require File.expand_path('../../test_helper', __FILE__)
+
+class ActiveModelApiVariantsTest < Test::Unit::TestCase
+  class Model
+    include ActiveModel::Validations
+    attr_reader :foo
+    def self.name; 'Model'; end
+  end
+
+  def setup
+    I18n.backend.send(:init_translations) # i.e. don't overwrite our translations
+  end
+
+  def teardown
+    I18n.backend = nil
+    Model.reset_callbacks(:validate)
+  end
+
+  def error_on(attribute)
+    model = Model.new
+    model.valid?
+    model.errors[attribute].first
+  end
+
+  test "variants: it picks a translation message variant from the messages namespace" do
+    Model.validates_presence_of :foo
+    store_translations(:'errors.messages.blank' => { :short => 'short', :full => 'full' })
+    assert_equal "short", error_on(:foo).to_s
+    assert_equal "short", error_on(:foo).to_s(:short)
+    assert_equal "full",  error_on(:foo).to_s(:full)
+  end
+  
+  test "variants: it picks a translation message variant from the models namespace" do
+    Model.validates_presence_of :foo
+    store_translations(:'errors.models.model.blank' => { :short => 'short', :full => 'full' })
+    assert_equal "short", error_on(:foo).to_s
+    assert_equal "short", error_on(:foo).to_s(:short)
+    assert_equal "full",  error_on(:foo).to_s(:full)
+  end
+  
+  test "variants: it picks a translation message variant from the attributes namespace" do
+    Model.validates_presence_of :foo
+    store_translations(:'errors.models.model.attributes.foo.blank' => { :short => 'short', :full => 'full' })
+    assert_equal "short", error_on(:foo).to_s
+    assert_equal "short", error_on(:foo).to_s(:short)
+    assert_equal "full",  error_on(:foo).to_s(:full)
+  end
+  
+  # given a :message Message in class level validation macros
+
+  test "variants: given a class level :message Hash of Messages it picks a variant" do
+    Model.validates_presence_of :foo, :message => { :short => 'short', :full => 'full' }
+    assert_equal "short", error_on(:foo).to_s
+    assert_equal "short", error_on(:foo).to_s(:short)
+    assert_equal "full",  error_on(:foo).to_s(:full)
+  end
+
+  # given a :message Symbol in class level validation macros
+
+  test "variants: given a class level :message Symbol it translates the Symbol (message namespace) and picks a variant" do
+    store_translations(:'errors.messages.broken' => { :short => 'short', :full => 'full' })
+    Model.validates_presence_of :foo, :message => :broken
+    assert_equal "short", error_on(:foo).to_s
+    assert_equal "short", error_on(:foo).to_s(:short)
+    assert_equal "full",  error_on(:foo).to_s(:full)
+  end
+
+  test "variants: given a class level :message Symbol it translates the Symbol (model namespace) and picks a variant" do
+    store_translations(:'errors.models.model.broken' => { :short => 'short', :full => 'full' })
+    Model.validates_presence_of :foo, :message => :broken
+    assert_equal "short", error_on(:foo).to_s
+    assert_equal "short", error_on(:foo).to_s(:short)
+    assert_equal "full",  error_on(:foo).to_s(:full)
+  end
+
+  test "variants: given a class level :message Symbol it translates the Symbol (attribute namespace) and picks a variant" do
+    store_translations(:'errors.models.model.attributes.foo.broken' => { :short => 'short', :full => 'full' })
+    Model.validates_presence_of :foo, :message => :broken
+    assert_equal "short", error_on(:foo).to_s
+    assert_equal "short", error_on(:foo).to_s(:short)
+    assert_equal "full",  error_on(:foo).to_s(:full)
+  end
+
+  # given a :message Proc returning a Message in class level validation macros
+
+  # FIXME does not pass
+  # 
+  # test "variants: given a class level :message Proc returning a Hash of variant Messages it picks a variant" do
+  #   Model.validates_presence_of :foo, :message => proc { { :short => 'short', :full => 'full' } }
+  #   assert_equal "short", error_on(:foo).to_s
+  #   assert_equal "short", error_on(:foo).to_s(:short)
+  #   assert_equal "full",  error_on(:foo).to_s(:full)
+  # end
+
+  # given a :message Proc returning a Symbol in class level validation macros
+
+  test "variants: given a class level :message Proc returning a Symbol it translates the Symbol (message namespace) and picks a variant" do
+    store_translations(:'errors.messages.broken' => { :short => 'short', :full => 'full' })
+    Model.validates_presence_of :foo, :message => proc { :broken }
+    assert_equal "short", error_on(:foo).to_s
+    assert_equal "short", error_on(:foo).to_s(:short)
+    assert_equal "full",  error_on(:foo).to_s(:full)
+  end
+
+  test "variants: given a class level :message Proc returning a Symbol it translates the Symbol (model namespace) and picks a variant" do
+    store_translations(:'errors.models.model.broken' => { :short => 'short', :full => 'full' })
+    Model.validates_presence_of :foo, :message => proc { :broken }
+    assert_equal "short", error_on(:foo).to_s
+    assert_equal "short", error_on(:foo).to_s(:short)
+    assert_equal "full",  error_on(:foo).to_s(:full)
+  end
+  
+  test "variants: given a class level :message Proc returning a Symbol it translates the Symbol (attribute namespace) and picks a variant" do
+    store_translations(:'errors.models.model.attributes.foo.broken' => { :short => 'short', :full => 'full' })
+    Model.validates_presence_of :foo, :message => proc { :broken }
+    assert_equal "short", error_on(:foo).to_s
+    assert_equal "short", error_on(:foo).to_s(:short)
+    assert_equal "full",  error_on(:foo).to_s(:full)
+  end
+end

data/test/active_model_test.rb

@@ -0,0 +1,175 @@
+# encoding: utf-8
+require File.expand_path(File.dirname(__FILE__)) + '/test_helper'
+
+$:.unshift('~/Development/shared/rails/rails-master/activemodel/lib')
+$:.unshift('~/Development/shared/rails/rails-master/activesupport/lib')
+$:.unshift('~/Projects/Ruby/rails/activemodel/lib')
+$:.unshift('~/Projects/Ruby/rails/activesupport/lib')
+
+require 'active_model/errors_ext'
+
+class Model
+  include ActiveModel::Validations
+  attr_reader :foo
+end
+
+module ActiveModelValidationMessageTestSetup
+
+  def setup
+    I18n.backend = CascadingBackend.new
+    I18n.backend.send(:init_translations) # so our translations won't be overwritten by Rails
+  end
+
+  def teardown
+    I18n.backend  = nil
+    Model.reset_callbacks(:validate)
+
+  end
+
+  def model
+    model = Model.new
+    model.valid?
+    model
+  end
+
+end
+
+class LegacyActiveModelValidationMessageTest < Test::Unit::TestCase
+  include ActiveModelValidationMessageTestSetup
+
+  class Error < ActiveModel::Error
+    include Legacy
+  end
+
+  def setup
+    super
+    ActiveModel::Errors.error_class = Error
+  end
+
+  test "uses a translation from the messages namespace" do
+    Model.validates_presence_of :foo
+    store_translations(:'errors.messages.blank' => 'message')
+    assert_equal "message", model.errors[:foo].first.to_s
+  end
+
+  test "uses a translation from the messages namespace with a Proc" do
+    Model.validates_presence_of :foo, :message => proc { :foo }
+    store_translations(:'errors.messages.foo' => 'message')
+    assert_equal "message", model.errors[:foo].first.to_s
+  end
+
+  test "uses a translation from a model namespace" do
+    Model.validates_presence_of :foo
+    store_translations(:'errors.models.model.blank' => 'message')
+    assert_equal "message", model.errors[:foo].first.to_s
+  end
+
+  test "uses a translation from an attribute namespace" do
+    Model.validates_presence_of :foo
+    store_translations(:'errors.models.model.attributes.foo.blank' => 'message')
+    assert_equal "message", model.errors[:foo].first.to_s
+  end
+
+  test "interpolates validation data to a default message" do
+    Model.validates_length_of :foo, :minimum => 1
+    assert_equal "is too short (minimum is 1 characters)", model.errors[:foo].first.to_s
+  end
+
+  test "AttributeErrors supports common methods" do
+    store_translations(:'errors.messages.blank' => 'message')
+
+    errors = model.errors[:foo]
+    assert errors.empty?
+    assert !errors.any?
+
+    errors << :blank
+    assert !errors.empty?
+    assert errors.any?
+    assert errors.include?(:blank)
+    assert errors.include?("message")
+    assert_equal "message", errors.first.to_s
+  end
+
+  test "errors added directly to AttributeErrors are accesible via Errors" do
+    foo = model
+    foo.errors[:bar] << :blank
+
+    assert_equal 1, foo.errors.size
+    assert_equal ['Bar can\'t be blank'], foo.errors.to_a
+  end
+
+
+=begin
+  test "uses translation message formats from a model namespace" do
+    Model.validates_presence_of :foo
+    store_translations(:'errors.models.model.blank' => { :short => 'short', :full => 'full' })
+    assert_equal "short", model.errors[:foo].first.to_s
+    assert_equal "short", model.errors[:foo].first.to_s(:short)
+    assert_equal "full", model.errors[:foo].first.to_s(:full)
+  end
+
+
+  test "uses translation message formats from an attribute namespace" do
+    Model.validates_presence_of :foo
+    store_translations(:'errors.models.model.attributes.foo.blank' => { :short => 'short', :full => 'full' })
+    assert_equal "short", model.errors[:foo].first.to_s
+    assert_equal "short", model.errors[:foo].first.to_s(:short)
+    assert_equal "full", model.errors[:foo].first.to_s(:full)
+  end
+=end
+
+end
+
+class ActiveModelValidationMessageTest < Test::Unit::TestCase
+
+  include ActiveModelValidationMessageTestSetup
+
+  class Error < ActiveModel::Error
+    include Cascade, Variants, Formatted
+
+    self.cascade_options = { :step => 2, :skip_root => false, :scopes => [:model, :attribute] }
+  end
+
+  def setup
+    super
+    ActiveModel::Errors.error_class = Error
+  end
+
+  test "uses a class level Message message" do
+    Model.validates_presence_of :foo, :message => 'message'
+    assert_equal "message", model.errors[:foo].first.to_s
+  end
+
+  test "uses a class level Proc message" do
+    Model.validates_presence_of :foo, :message => proc {'message'}
+    assert_equal "message", model.errors[:foo].first.to_s
+  end
+
+  test "uses class level Message message formats" do
+    Model.validates_presence_of :foo, :message => { :short => 'short', :full => 'full'}
+    assert_equal "short", model.errors[:foo].first.to_s
+    assert_equal "short", model.errors[:foo].first.to_s(:short)
+    assert_equal "full",  model.errors[:foo].first.to_s(:full)
+  end
+
+=begin
+  test "uses translation message formats the messages namespace" do
+    Model.validates_presence_of :foo
+    store_translations(:'errors.messages.blank' => { :short => 'short', :full => 'full' })
+    assert_equal "short", model.errors[:foo].first.to_s
+    assert_equal "short", model.errors[:foo].first.to_s(:short)
+    assert_equal "full", model.errors[:foo].first.to_s(:full)
+  end
+=end
+
+  test "interpolates validation data to a class level Message message" do
+    Model.validates_length_of :foo, :minimum => 1, :message => '%{count}'
+    assert_equal "1", model.errors[:foo].first.to_s
+  end
+
+  test "returns an instance of AttributeErrors" do
+    Model.validates_presence_of :foo
+    assert model.errors[:foo].is_a?(ActiveModel::AttributeErrors)
+  end
+
+end

data/test/all.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+
+dir = File.dirname(__FILE__)
+$LOAD_PATH.unshift(dir)
+
+Dir["#{dir}/**/*_test.rb"].sort.each do |file|
+  require file.sub(/^#{dir}\/(.*)\.rb$/, '\1')
+end

data/test/run_active_model_tests.rb

@@ -0,0 +1,32 @@
+# setup:
+#
+#   git clone rails
+#   gem install bundler
+#   gem bundle  (i had to comment out gem "pg", ">= 0.8.0" from rails/Gemfile)
+#   cd activemodel
+#   rake
+#   => should run the activemodel tests (outputs a ton of warnings for me)
+#
+#   update line the following line, then running this file should run validations tests
+
+dirs = %w(
+  ~/Development/shared/rails/rails-master/activemodel
+  ~/Projects/Ruby/rails/activemodel/
+).map { |dir| File.expand_path(dir) }
+
+dirs.each { |dir| $:.unshift "#{dir}/lib", "#{dir}/test" }
+$:.unshift('~/Projects/Ruby/rails/activesupport/lib')
+
+require File.expand_path('../test_helper', __FILE__)
+require 'active_model/errors_ext'
+require 'core_ext/error_comparsion'
+
+class ActiveModel::Error
+  include Legacy
+end
+
+tests = dirs.map { |dir| Dir["#{dir}/test/cases/validations{/**/*,}_test.rb"] }.flatten
+# tests = Dir["#{dir}/test/cases/validations_test.rb"]
+# tests.reject! { |test| test.include?('i18n_validation_test.rb') }
+tests.each { |test| require test }
+

data/test/test_case_declarative.rb

@@ -0,0 +1,23 @@
+module Declarative
+  def self.included(base)
+    base.class_eval do
+      def test(name, &block)
+        name    = "test_#{name.gsub(/\s+/,'_')}".to_sym
+        block ||= lambda { flunk "No implementation provided for #{name}" }
+
+        defined = instance_method(name) rescue false
+        raise("#{name} is already defined in #{self}") if defined
+
+        define_method(name, &block)
+      end
+    end
+  end
+end
+
+class Test::Unit::TestCase
+  include Declarative
+end
+
+class Module
+  include Declarative
+end

data/test/test_helper.rb

@@ -0,0 +1,29 @@
+# FIXME personal load paths
+$:.unshift('~/Development/shared/rails/rails-master/activemodel/lib')
+$:.unshift('~/Development/shared/rails/rails-master/activesupport/lib')
+$:.unshift('~/Projects/Ruby/rails/activemodel/lib')
+$:.unshift('~/Projects/Ruby/rails/activesupport/lib')
+
+
+$:.unshift File.expand_path("../lib", File.dirname(__FILE__))
+$:.unshift(File.expand_path(File.dirname(__FILE__)))
+
+require 'rubygems'
+require 'test/unit'
+require 'test_case_declarative'
+
+require 'activemodel_error'
+
+class Test::Unit::TestCase
+  def teardown
+    I18n.backend  = nil
+  end
+
+  def store_translations(data)
+    I18n.backend.store_translations(:en, data)
+  end
+end
+
+class CascadingBackend < I18n::Backend::Simple
+  include I18n::Backend::Cascade
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: activemodel-error
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Sven Fuchs
+- Mateo Murphy
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-25 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: |-
+  Provides I18n support for validation error messages in ActiveModel.
+                        With Rails 3 ActiveModel validation error messages are not backwards
+                        compatible with ActiveRecord 2.3.x. This Gem aims to restore this 
+                        backwards compatiblity and provide a richer feature set and better
+                        implementation compared to ActiveRecord 2.3.x.
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.textile
+files: 
+- MIT-LICENSE
+- README.textile
+- RakeFile
+- VERSION
+- lib/active_model/attribute_errors.rb
+- lib/active_model/error.rb
+- lib/active_model/error/base.rb
+- lib/active_model/error/format.rb
+- lib/active_model/error/legacy.rb
+- lib/active_model/errors_ext.rb
+- lib/activemodel_error.rb
+- lib/core_ext/error_comparsion.rb
+- test/active_model/format_test.rb
+- test/active_model/interpolation_test.rb
+- test/active_model/lookup_test.rb
+- test/active_model/variants_test.rb
+- test/active_model_test.rb
+- test/all.rb
+- test/run_active_model_tests.rb
+- test/test_case_declarative.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/svenfuchs/activemodel-error
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: I18n for validation error messages in ActiveModel
+test_files: 
+- test/active_model/format_test.rb
+- test/active_model/interpolation_test.rb
+- test/active_model/lookup_test.rb
+- test/active_model/variants_test.rb
+- test/active_model_test.rb
+- test/all.rb
+- test/run_active_model_tests.rb
+- test/test_case_declarative.rb
+- test/test_helper.rb