active_model-better_errors 1.6.0

data/lib/active_model/error_collecting/human_message_reporter.rb

@@ -0,0 +1,32 @@
+module ActiveModel
+  module ErrorCollecting
+    class HumanMessageReporter < MessageReporter
+      def full_messages
+        @collection.map do |attribute, error_message|
+          formatter = HumanMessageFormatter.new(base, error_message)
+          message   = formatter.format_message
+          full_message attribute, message
+        end
+      end
+
+      def full_message(attribute, message)
+        return message if attribute == :base
+        attr_name = attribute.to_s.gsub('.', '_').humanize
+        attr_name = base.class.human_attribute_name(attribute, :default => attr_name)
+        I18n.t(:"errors.format", {
+          :default   => "%{attribute} %{message}",
+          :attribute => attr_name,
+          :message   => message
+        })
+      end
+
+      # This method is not used internally.
+      # This is for API Compatibility with ActiveModel::Errors only
+      def generate_message(attribute, type = :invalid, options = {})
+        error_message = ErrorMessage.build(base, attribute, type, options)
+        formatter     = HumanMessageFormatter.new(base, error_message)
+        formatter.format_message
+      end
+    end
+  end
+end

data/lib/active_model/error_collecting/machine_array_reporter.rb

@@ -0,0 +1,19 @@
+module ActiveModel
+  module ErrorCollecting
+    class MachineArrayReporter < ArrayReporter
+      def to_a
+        collection.to_a.map do |error_message|
+          format_error_message error_message
+        end
+      end
+
+      def format_error_message(error_message)
+        result = {}
+        result[:attribute] = error_message.attribute.to_s
+        result[:type] = error_message.type || :invalid
+        result[:options] = error_message.options unless error_message.options.blank?
+        result
+      end
+    end
+  end
+end

data/lib/active_model/error_collecting/machine_hash_reporter.rb

@@ -0,0 +1,22 @@
+module ActiveModel
+  module ErrorCollecting
+    class MachineHashReporter < HashReporter
+      def to_hash
+        collection.to_hash.inject({}) do |hash, kv|
+          attribute, error_message_set = kv
+          hash[attribute] = error_message_set.map do |error_message|
+            format_error_message(error_message)
+          end
+          hash
+        end
+      end
+
+      def format_error_message(error_message)
+        result = {}
+        result[:type] = error_message.type || :invalid
+        result[:options] = error_message.options unless error_message.options.blank?
+        result
+      end
+    end
+  end
+end

data/lib/active_model/error_collecting/message_reporter.rb

@@ -0,0 +1,17 @@
+module ActiveModel
+  module ErrorCollecting
+    class MessageReporter < Reporter
+      def full_messages
+        raise "abstract method"
+      end
+
+      def full_message(attribute, message)
+        raise "abstract method"
+      end
+
+      def generate_message(attribute, type = :invalid, options = {})
+        raise "abstract method"
+      end
+    end
+  end
+end

data/lib/active_model/error_collecting/reporter.rb

@@ -0,0 +1,14 @@
+module ActiveModel
+  module ErrorCollecting
+    class Reporter
+      attr_reader :collection
+      def initialize(collection)
+        @collection = collection
+      end
+
+      def base
+        @collection.base
+      end
+    end
+  end
+end

data/spec/lib/active_model/better_errors_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe "ActiveModel Better Errors" do
+  it "overrides ActiveModel Validations" do
+    User.new.errors.should be_a ActiveModel::ErrorCollecting::Errors
+  end
+end

data/spec/lib/active_model/error_collecting/emulation_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+shared_examples_for "a delegated method" do
+  let(:target_instance) { mock() }
+  before do
+    target_instance.should_receive method
+    instance.stub(target).and_return(target_instance)
+  end
+
+  specify { instance.send method }
+end
+
+describe ActiveModel::ErrorCollecting::Emulation do
+  subject(:instance) { klass.new }
+  let(:klass) { Class.new { include ActiveModel::ErrorCollecting::Emulation } }
+
+  delegation_map = {
+    error_collection: [
+      :clear, :include?, :get, :set, :delete, :[], :[]=, :each, :size,
+      :values, :keys, :count, :empty?, :added?, :any?, :entries
+    ],
+
+    message_reporter: [
+      :full_messages, :full_message, :generate_message
+    ],
+
+    hash_reporter: [
+      :to_hash
+    ],
+
+    hash_reporter: [
+      :to_hash
+    ]
+  }
+
+  delegation_map.each do |target, methods|
+    methods.each do |method|
+      describe "delegating ##{method} to  ##{target}" do
+        let(:target) { target }
+        let(:method) { method }
+        it_should_behave_like "a delegated method"
+      end
+    end
+  end
+end

data/spec/lib/active_model/error_collecting/error_collection_spec.rb

@@ -0,0 +1,205 @@
+require 'spec_helper'
+
+describe ActiveModel::ErrorCollecting::ErrorCollection do
+  subject(:collection) { klass.new(base) }
+  let(:klass) { ActiveModel::ErrorCollecting::ErrorCollection }
+  let(:base)  { User.new }
+  let(:errors){{
+    :first_name =>  [ [ :too_long, { count: 3 } ] ],
+    'last_name' =>  [ [ :invalid, { message: "Invalid" } ] ],
+    :email  =>  [ :invalid ],
+  }}
+
+  before do
+    errors.each do |attribute, error_list|
+      error_list.each do |error|
+        collection[attribute] = error
+      end
+    end
+  end
+
+  describe "#clear" do
+    before { collection.clear }
+    it { should be_empty }
+  end
+
+  describe "#include?" do
+    it { should be_include :first_name }
+    it { should be_include :last_name }
+    it { should be_include :email }
+    it { should_not be_include 'first_name' }
+    it { should_not be_include 'last_name' }
+    it { should_not be_include 'email' }
+  end
+
+  describe "#get" do
+    subject { collection.get(:first_name) }
+    it { should be_a ActiveModel::ErrorCollecting::ErrorMessageSet }
+    its(:length) { should be 1 }
+
+    describe "when value is nil" do
+      before { collection.delete :first_name }
+      it { should be nil }
+    end
+  end
+
+  describe "#set" do
+    subject { collection.get :first_name }
+
+    describe "when value is array" do
+      before { collection.set(:first_name, []) }
+      it { should be_a ActiveModel::ErrorCollecting::ErrorMessageSet }
+      its(:length) { should be 0 }
+    end
+
+      describe "when value is nil" do
+        before { collection.set(:first_name, nil) }
+        it { should be_nil }
+      end
+  end
+
+  describe "#delete" do
+    subject { collection.get(:first_name) }
+    before { collection.delete(:first_name) }
+    it { should be_nil }
+  end
+
+  describe "#[]" do
+    subject { collection[:first_name] }
+
+    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 }
+    end
+
+    describe "when there are error messages" do
+      it { should_not be_blank }
+      it { should_not be_nil }
+      it { should be_a ActiveModel::ErrorCollecting::ErrorMessageSet }
+    end
+  end
+
+  describe "#[]=" do
+    subject(:error_message_set) { collection.get field }
+
+    describe "when assigning existing attribute" do
+      let(:field) { :first_name }
+      it "should append to existing set" do
+        expect {
+          collection[field] = "I'm invalid."
+        }.to change { error_message_set.length }.by(1)
+      end
+    end
+
+    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 }
+      its(:length) { should be 1 }
+    end
+  end
+
+  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
+        count += 1
+      end
+
+      expect(count).to be collection.size
+    end
+  end
+
+  describe "#size" do
+    subject { collection.size }
+    it { should be 3 }
+
+    describe "when adding one more error" do
+      before { collection[:name] = "Not Valid" }
+      it { should be 4 }
+    end
+  end
+
+  describe "#values" do
+    subject { collection.values }
+
+    it { should be_a Array }
+    its(:length) { should be 3 }
+
+    it "should contain ErrorMessageSet as elements" do
+      collection.values.each do |el|
+        el.should be_a ActiveModel::ErrorCollecting::ErrorMessageSet
+      end
+    end
+  end
+
+  describe "#keys" do
+    subject { collection.keys }
+    it { should == [:first_name, :last_name, :email] }
+  end
+
+  describe "#to_a" do
+    subject { collection.to_a }
+    its(:size) { should == 3 }
+
+    describe "when adding one more error" do
+      before { collection[:name] = "Not Valid" }
+      its(:size) { should == 4 }
+    end
+
+    it "should contain ErrorMessage as elements" do
+      collection.to_a.each do |error|
+        error.should be_a ActiveModel::ErrorCollecting::ErrorMessage
+      end
+    end
+  end
+
+  describe "#to_hash" do
+    subject { collection.to_hash }
+
+    it { should be_a Hash }
+    it { should == collection.instance_variable_get(:@collection) }
+    it { should_not be collection.instance_variable_get(:@collection) }
+  end
+
+  describe "#empty?" do
+    subject { collection.empty? }
+    it{ should be false }
+
+    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)
+    end
+  end
+
+  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 } }
+      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 } }
+      it { should be false }
+    end
+  end
+end

data/spec/lib/active_model/error_collecting/error_message_set_spec.rb

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