instructure-active_model-better_errors 1.6.3.rails2.5 → 1.6.5.rails2.1

data/lib/active_model/better_errors.rb

@@ -1,17 +1,81 @@
+# encoding: utf-8
+
 require 'forwardable'
 
 require 'active_support/core_ext'
 
-require 'active_model/error_collecting'
-
 require 'active_record'
 require 'active_record/base'
 require 'active_record/validations'
 
+require 'active_model/better_errors/error_message'
+require 'active_model/better_errors/error_message_set'
+require 'active_model/better_errors/error_collection'
+
+require 'active_model/better_errors/formatter'
+require 'active_model/better_errors/human_message_formatter'
+
+require 'active_model/better_errors/reporter'
+require 'active_model/better_errors/message_reporter'
+require 'active_model/better_errors/hash_reporter'
+require 'active_model/better_errors/array_reporter'
+
+require 'active_model/better_errors/human_message_reporter'
+require 'active_model/better_errors/human_hash_reporter'
+require 'active_model/better_errors/human_array_reporter'
+
+require 'active_model/better_errors/machine_hash_reporter'
+require 'active_model/better_errors/machine_array_reporter'
+
+require 'active_model/better_errors/emulation'
+require 'active_model/better_errors/errors'
+
+module ActiveModel
+  #
+  # BetterErrors
+  #
+  module BetterErrors
+    class << self
+      attr_accessor :formatter
+
+      def set_reporter(name, reporter)
+        name = name.to_s
+        @reporter_maps ||= {}
+        return @reporter_maps.delete(name) unless reporter
+        @reporter_maps[name] = get_reporter_class(name, reporter)
+      end
+
+      def reporters
+        @reporter_maps ||= {}
+        @reporter_maps.clone
+      end
+
+      def get_reporter_class(name, reporter)
+        return reporter if reporter.is_a? Class
+        class_name = "#{reporter}_#{name}_reporter"
+        "active_model/better_errors/#{class_name}".classify.constantize
+      end
+
+      def format_message(base, message)
+        formatter.new(base, message).format_message
+      end
+    end
+
+    set_reporter :message,  :human
+    set_reporter :array,    :human
+    set_reporter :hash,     :human
+
+    self.formatter = HumanMessageFormatter
+  end
+end
+
 module ActiveRecord
+  #
+  # ActiveModel::Validations.errors override
+  #
   module Validations
     def errors
-      @errors ||= ActiveModel::ErrorCollecting::Errors.new(self)
+      @errors ||= ::ActiveModel::BetterErrors::Errors.new(self)
     end
   end
 end

data/spec/spec_helper.rb

@@ -1,13 +1,24 @@
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-require 'rspec'
-require 'pry'
+# encoding: utf-8
 
-require 'active_model/better_errors'
+# SimpleCov MUST be started before require 'rom-relation'
+#
+if ENV['COVERAGE'] == 'true'
+  require 'simplecov'
+  require 'coveralls'
+
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
 
-# Requires supporting files with custom matchers and macros, etc,
-# in ./support/ and its subdirectories.
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+  SimpleCov.start do
+    command_name 'spec:unit'
+
+    add_filter 'config'
+    add_filter 'lib/rom/support'
+    add_filter 'spec'
+  end
+end
 
 def migrate_test_db
   ActiveRecord::Base.connection.create_table(:users) do |t|
@@ -29,9 +40,5 @@ RSpec.configure do |config|
   end
 end
 
-class String
-  def ==(other)
-    return super other.to_s if other.is_a? ActiveModel::ErrorCollecting::ErrorMessage
-    super
-  end
-end
+require 'active_model/better_errors'
+require 'devtools/spec_helper'

data/spec/support/string_ext.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+
+#
+# String
+#
+class String
+  def ==(other)
+    if other.is_a? ActiveModel::BetterErrors::ErrorMessage
+      return super other.to_s
+    else
+      super
+    end
+  end
+end

data/spec/{lib/active_model/error_collecting → unit/lib/active_model/better_errors}/emulation_spec.rb

@@ -1,7 +1,9 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-shared_examples_for "a delegated method" do
-  let(:target_instance) { mock() }
+shared_examples_for 'a delegated method' do
+  let(:target_instance) { double }
   before do
     target_instance.should_receive method
     instance.stub(target).and_return(target_instance)
@@ -10,9 +12,9 @@ shared_examples_for "a delegated method" do
   specify { instance.send method }
 end
 
-describe ActiveModel::ErrorCollecting::Emulation do
+describe ActiveModel::BetterErrors::Emulation do
   subject(:instance) { klass.new }
-  let(:klass) { Class.new { include ActiveModel::ErrorCollecting::Emulation } }
+  let(:klass) { Class.new { include ActiveModel::BetterErrors::Emulation } }
 
   delegation_map = {
     error_collection: [
@@ -38,8 +40,8 @@ describe ActiveModel::ErrorCollecting::Emulation do
       describe "delegating ##{method} to  ##{target}" do
         let(:target) { target }
         let(:method) { method }
-        it_should_behave_like "a delegated method"
+        it_should_behave_like 'a delegated method'
       end
     end
   end
-end
+end

data/spec/{lib/active_model/error_collecting → unit/lib/active_model/better_errors}/error_collection_spec.rb

@@ -1,14 +1,18 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe ActiveModel::ErrorCollecting::ErrorCollection do
+describe ActiveModel::BetterErrors::ErrorCollection do
   subject(:collection) { klass.new(base) }
-  let(:klass) { ActiveModel::ErrorCollecting::ErrorCollection }
+  let(:klass) { ActiveModel::BetterErrors::ErrorCollection }
   let(:base)  { User.new }
-  let(:errors){{
-    :first_name =>  [ [ :too_long, { count: 3 } ] ],
-    'last_name' =>  [ [ :invalid, { message: "Invalid" } ] ],
-    :email  =>  [ :invalid ],
-  }}
+  let(:errors) do
+    {
+      :first_name =>  [[:too_long, { count: 3 }]],
+      'last_name' =>  [[:invalid, { message: 'Invalid' }]],
+      :email  =>  [:invalid],
+    }
+  end
 
   before do
     errors.each do |attribute, error_list|
@@ -18,12 +22,12 @@ describe ActiveModel::ErrorCollecting::ErrorCollection do
     end
   end
 
-  describe "#clear" do
+  describe '#clear' do
     before { collection.clear }
     it { should be_empty }
   end
 
-  describe "#include?" do
+  describe '#include?' do
     it { should be_include :first_name }
     it { should be_include :last_name }
     it { should be_include :email }
@@ -32,82 +36,82 @@ describe ActiveModel::ErrorCollecting::ErrorCollection do
     it { should_not be_include 'email' }
   end
 
-  describe "#get" do
+  describe '#get' do
     subject { collection.get(:first_name) }
-    it { should be_a ActiveModel::ErrorCollecting::ErrorMessageSet }
+    it { should be_a ActiveModel::BetterErrors::ErrorMessageSet }
     its(:length) { should be 1 }
 
-    describe "when value is nil" do
+    describe 'when value is nil' do
       before { collection.delete :first_name }
       it { should be nil }
     end
   end
 
-  describe "#set" do
+  describe '#set' do
     subject { collection.get :first_name }
 
-    describe "when value is array" do
+    describe 'when value is array' do
       before { collection.set(:first_name, []) }
-      it { should be_a ActiveModel::ErrorCollecting::ErrorMessageSet }
+      it { should be_a ActiveModel::BetterErrors::ErrorMessageSet }
       its(:length) { should be 0 }
     end
 
-      describe "when value is nil" do
-        before { collection.set(:first_name, nil) }
-        it { should be_nil }
-      end
+    describe 'when value is nil' do
+      before { collection.set(:first_name, nil) }
+      it { should be_nil }
+    end
   end
 
-  describe "#delete" do
+  describe '#delete' do
     subject { collection.get(:first_name) }
     before { collection.delete(:first_name) }
     it { should be_nil }
   end
 
-  describe "#[]" do
+  describe '#[]' do
     subject { collection[:first_name] }
 
-    describe "when no error messages" do
+    describe 'when no error messages' do
       before { collection.clear }
       it { should be_blank }
       it { should_not be_nil }
-      it { should be_a ActiveModel::ErrorCollecting::ErrorMessageSet }
+      it { should be_a ActiveModel::BetterErrors::ErrorMessageSet }
     end
 
-    describe "when there are error messages" do
+    describe 'when there are error messages' do
       it { should_not be_blank }
       it { should_not be_nil }
-      it { should be_a ActiveModel::ErrorCollecting::ErrorMessageSet }
+      it { should be_a ActiveModel::BetterErrors::ErrorMessageSet }
     end
   end
 
-  describe "#[]=" do
+  describe '#[]=' do
     subject(:error_message_set) { collection.get field }
 
-    describe "when assigning existing attribute" do
+    describe 'when assigning existing attribute' do
       let(:field) { :first_name }
-      it "should append to existing set" do
-        expect {
+      it 'should append to existing set' do
+        expect do
           collection[field] = "I'm invalid."
-        }.to change { error_message_set.length }.by(1)
+        end.to change { error_message_set.length }.by(1)
       end
     end
 
-    describe "when assigning to new attribute" do
+    describe 'when assigning to new attribute' do
       let(:field) { :a_new_attribute }
       before { collection[field] = "I'm invalid" }
       it { should_not be_nil }
-      it { should be_a ActiveModel::ErrorCollecting::ErrorMessageSet }
+      it { should be_a ActiveModel::BetterErrors::ErrorMessageSet }
       its(:length) { should be 1 }
     end
   end
 
-  describe "#each" do
-    it "should loop through each error" do
+  describe '#each' do
+    it 'should loop through each error' do
       count = 0
       collection.each do |attribute, error|
         attribute.should be_a Symbol
-        error.should be_a ActiveModel::ErrorCollecting::ErrorMessage
+        error.should be_a ActiveModel::BetterErrors::ErrorMessage
         count += 1
       end
 
@@ -115,51 +119,51 @@ describe ActiveModel::ErrorCollecting::ErrorCollection do
     end
   end
 
-  describe "#size" do
+  describe '#size' do
     subject { collection.size }
     it { should be 3 }
 
-    describe "when adding one more error" do
-      before { collection[:name] = "Not Valid" }
+    describe 'when adding one more error' do
+      before { collection[:name] = 'Not Valid' }
       it { should be 4 }
     end
   end
 
-  describe "#values" do
+  describe '#values' do
     subject { collection.values }
 
     it { should be_a Array }
     its(:length) { should be 3 }
 
-    it "should contain ErrorMessageSet as elements" do
+    it 'should contain ErrorMessageSet as elements' do
       collection.values.each do |el|
-        el.should be_a ActiveModel::ErrorCollecting::ErrorMessageSet
+        el.should be_a ActiveModel::BetterErrors::ErrorMessageSet
       end
     end
   end
 
-  describe "#keys" do
+  describe '#keys' do
     subject { collection.keys }
     it { should == [:first_name, :last_name, :email] }
   end
 
-  describe "#to_a" do
+  describe '#to_a' do
     subject { collection.to_a }
     its(:size) { should == 3 }
 
-    describe "when adding one more error" do
-      before { collection[:name] = "Not Valid" }
+    describe 'when adding one more error' do
+      before { collection[:name] = 'Not Valid' }
       its(:size) { should == 4 }
     end
 
-    it "should contain ErrorMessage as elements" do
+    it 'should contain ErrorMessage as elements' do
       collection.to_a.each do |error|
-        error.should be_a ActiveModel::ErrorCollecting::ErrorMessage
+        error.should be_a ActiveModel::BetterErrors::ErrorMessage
       end
     end
   end
 
-  describe "#to_hash" do
+  describe '#to_hash' do
     subject { collection.to_hash }
 
     it { should be_a Hash }
@@ -167,38 +171,38 @@ describe ActiveModel::ErrorCollecting::ErrorCollection do
     it { should_not be collection.instance_variable_get(:@collection) }
   end
 
-  describe "#empty?" do
+  describe '#empty?' do
     subject { collection.empty? }
-    it{ should be false }
+    it { should be false }
 
-    describe "after clearing the collection" do
+    describe 'after clearing the collection' do
       before { collection.clear }
 
       it { should be true }
     end
   end
 
-  describe "#add" do
-    it "should add error to collection" do
-      expect {
-        collection.add :name, "Invalid"
-        }.to change { collection[:name].length }.by(1)
+  describe '#add' do
+    it 'should add error to collection' do
+      expect do
+        collection.add(:name, 'Invalid')
+      end.to change { collection[:name].length }.by(1)
     end
   end
 
-  describe "#added?" do
-    describe "when an error message is not added" do
+  describe '#added?' do
+    describe 'when an error message is not added' do
       subject { collection.added? :name, :not_there }
       it { should be false }
     end
 
-    describe "when an error message with the same option is added" do
-      subject { collection.added? :first_name, :too_long, { :count => 3 } }
+    describe 'when an error message with the same option is added' do
+      subject { collection.added? :first_name, :too_long, count: 3 }
       it { should be true }
     end
 
-    describe "when an error message with the different option is added" do
-      subject { collection.added? :first_name, :too_long, { :count => 4 } }
+    describe 'when an error message with the different option is added' do
+      subject { collection.added? :first_name, :too_long, count: 4 }
       it { should be false }
     end
   end

data/spec/{lib/active_model/error_collecting → unit/lib/active_model/better_errors}/error_message_set_spec.rb

@@ -1,66 +1,68 @@
+# encoding: utf-8
+
 require 'spec_helper'
 
-describe ActiveModel::ErrorCollecting::ErrorMessageSet do
+describe ActiveModel::BetterErrors::ErrorMessageSet do
   subject(:set)   { klass.new base, attribute, errors }
-  let(:klass)     { ActiveModel::ErrorCollecting::ErrorMessageSet }
+  let(:klass)     { ActiveModel::BetterErrors::ErrorMessageSet }
   let(:attribute) { :first_name }
   let(:errors)    { [] }
   let(:base)      { User.new }
 
-  describe "#initialize" do
-    context "with no errors" do
+  describe '#initialize' do
+    context 'with no errors' do
       its(:length) { should == 0 }
     end
 
-    context "with one error" do
+    context 'with one error' do
       let(:errors) { [:invalid] }
       its(:length) { should == 1 }
     end
   end
 
-  describe "#push" do
+  describe '#push' do
     before { set.push error, options }
     let(:error)  { :invalid }
     let(:options)   { nil }
     subject { set.first }
 
-    describe "without options" do
-      it { should be_a ActiveModel::ErrorCollecting::ErrorMessage }
-      its(:message)   { should == nil }
+    describe 'without options' do
+      it { should be_a ActiveModel::BetterErrors::ErrorMessage }
+      its(:message)   { should be_nil }
       its(:type)      { should == error }
     end
 
-    describe "with options" do
+    describe 'with options' do
       let(:options)   { { message: 'Invalid' } }
 
-      it { should be_a ActiveModel::ErrorCollecting::ErrorMessage }
+      it { should be_a ActiveModel::BetterErrors::ErrorMessage }
       its(:message)   { should == options[:message] }
       its(:type)      { should == error }
     end
   end
 
-  describe "#<<" do
+  describe '#<<' do
     before  { set << error }
     subject { set.first }
 
-    describe "when accepting error as a symbol" do
+    describe 'when accepting error as a symbol' do
       let(:error)  { :invalid }
 
-      it { should be_a ActiveModel::ErrorCollecting::ErrorMessage }
-      its(:message)   { should == nil }
+      it { should be_a ActiveModel::BetterErrors::ErrorMessage }
+      its(:message)   { should be_nil }
       its(:type)      { should == error }
     end
 
-    describe "when accepting error as a tuple" do
-      let(:error)  { [ :invalid, { message: "OMG!!" } ]}
+    describe 'when accepting error as a tuple' do
+      let(:error)  { [:invalid, { message: 'OMG!!' }] }
 
-      it { should be_a ActiveModel::ErrorCollecting::ErrorMessage }
-      its(:message)   { should == "OMG!!" }
+      it { should be_a ActiveModel::BetterErrors::ErrorMessage }
+      its(:message)   { should == 'OMG!!' }
       its(:type)      { should == :invalid }
     end
   end
 
-  describe "#to_a" do
+  describe '#to_a' do
     let(:errors) { [:invalid, :too_long] }
     subject { set.to_a }
 
@@ -68,23 +70,23 @@ describe ActiveModel::ErrorCollecting::ErrorMessageSet do
     its(:length) { should == 2 }
   end
 
-  describe "#empty?" do
+  describe '#empty?' do
     subject { set.empty? }
 
-    describe "when no error messages" do
+    describe 'when no error messages' do
       it { should be_true }
     end
 
-    describe "when contains error messages" do
+    describe 'when contains error messages' do
       let(:errors) { [:invalid, :too_long] }
       it { should be_false }
     end
   end
 
-  describe "#==" do
+  describe '#==' do
     subject { errors == set }
     let(:errors) { [:invalid] }
-    let(:expected) { ["is invalid"] }
+    let(:expected) { ['is invalid'] }
     specify do
       set.should == expected
     end