instructure-active_model-better_errors 1.6.3.rails2

data/lib/active_model/error_collecting/error_message_set.rb

@@ -0,0 +1,33 @@
+module ActiveModel
+  module ErrorCollecting
+    class ErrorMessageSet < Array
+      def initialize(base, attribute, errors=[])
+        @base      = base
+        @attribute = attribute
+        errors.each do |error|
+          push(*error)
+        end
+      end
+
+      def <<(error)
+        super ErrorMessage.build(@base, @attribute, *error)
+      end
+
+      def push(message, options = {})
+        super ErrorMessage.build(@base, @attribute, message, options)
+      end
+
+      def []=(index, error)
+        super index, ErrorMessage.build(@base, @attribute, *error)
+      end
+
+      def insert(index, error)
+        super index, ErrorMessage.build(@base, @attribute, *error)
+      end
+
+      def to_a
+        dup
+      end
+    end
+  end
+end

data/lib/active_model/error_collecting/errors.rb

@@ -0,0 +1,52 @@
+module ActiveModel
+  module ErrorCollecting
+    class Errors
+      include Emulation
+
+      attr_reader :base
+      def initialize(base)
+        @base = base
+        @reporters = {}
+        @reporter_classes = reporter_classes
+      end
+
+      def error_collection
+        @error_collection ||= ErrorCollection.new(@base)
+      end
+
+      def message_reporter
+        get_reporter(:message)
+      end
+
+      def hash_reporter
+        get_reporter(:hash)
+      end
+
+      def array_reporter
+        get_reporter(:array)
+      end
+
+      def set_reporter(type, reporter)
+        type = type.to_s
+        klass = ::ActiveModel::ErrorCollecting.get_reporter_class(type, reporter)
+        @reporter_classes[type] = klass
+        @reporters.delete type
+      end
+
+      def get_reporter(type)
+        type = type.to_s
+        klass = get_reporter_class(type)
+        @reporters[type] = klass.new(error_collection)
+      end
+
+      def reporter_classes
+        ::ActiveModel::ErrorCollecting.reporters
+      end
+
+      def get_reporter_class(type)
+        type = type.to_s
+        @reporter_classes[type]
+      end
+    end
+  end
+end

data/lib/active_model/error_collecting/hash_reporter.rb

@@ -0,0 +1,9 @@
+module ActiveModel
+  module ErrorCollecting
+    class HashReporter < Reporter
+      def to_hash
+        raise "abstract method"
+      end
+    end
+  end
+end

data/lib/active_model/error_collecting/human_array_reporter.rb

@@ -0,0 +1,9 @@
+module ActiveModel
+  module ErrorCollecting
+    class HumanArrayReporter < ArrayReporter
+      def to_a
+        HumanMessageReporter.new(collection).full_messages
+      end
+    end
+  end
+end

data/lib/active_model/error_collecting/human_hash_reporter.rb

@@ -0,0 +1,15 @@
+module ActiveModel
+  module ErrorCollecting
+    class HumanHashReporter < 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|
+            HumanMessageFormatter.new(base, error_message).format_message
+          end
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/active_model/error_collecting/human_message_formatter.rb

@@ -0,0 +1,72 @@
+module ActiveModel
+  module ErrorCollecting
+    class HumanMessageFormatter
+      extend Forwardable
+
+      def_delegators :@error_message, :attribute, :message, :options
+
+      attr_reader :base, :error_message
+
+      def initialize(base, error_message)
+        @base, @error_message = base, error_message
+      end
+
+      def type
+        @error_message.type || :invalid
+      end
+
+      def format_message
+        return message if message && error_message.type.nil?
+
+        keys = i18n_keys
+        key  = keys.shift
+
+        options = {
+          :default => keys,
+          :model => base.class.human_name,
+          :attribute => base.class.human_attribute_name(attribute),
+          :value => value
+        }.merge(self.options)
+
+        I18n.translate key, options
+      end
+
+      private
+
+      def value
+        return if attribute == :base
+        base.send :read_attribute, attribute
+      end
+
+      def ancestor_keys
+        return [] unless base.class.respond_to?(:i18n_scope)
+        scope = base.class.i18n_scope
+        base.class.lookup_ancestors.map do |klass|
+          model_key = klass.model_name.i18n_key
+          [
+            :"#{scope}.errors.models.#{model_key}.attributes.#{attribute}.#{type}",
+            :"#{scope}.errors.models.#{model_key}.#{type}"
+          ]
+        end
+      end
+
+      def i18n_keys
+        keys = ancestor_keys
+        keys << message
+
+        if base.class.respond_to?(:i18n_scope)
+          keys << :"#{base.class.i18n_scope}.errors.messages.#{type}"
+        end
+
+        keys << :"errors.attributes.#{attribute}.#{type}"
+        keys << :"activerecord.errors.attributes.#{attribute}.#{type}"
+        keys << :"errors.messages.#{type}"
+        keys << :"activerecord.errors.messages.#{type}"
+
+        keys.compact!
+        keys.flatten!
+        keys
+      end
+    end
+  end
+end

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/lib/active_model/error_collecting.rb

@@ -0,0 +1,49 @@
+require 'active_model/error_collecting/error_message'
+require 'active_model/error_collecting/error_message_set'
+require 'active_model/error_collecting/error_collection'
+
+require 'active_model/error_collecting/reporter'
+require 'active_model/error_collecting/message_reporter'
+require 'active_model/error_collecting/hash_reporter'
+require 'active_model/error_collecting/array_reporter'
+
+require 'active_model/error_collecting/human_message_formatter'
+require 'active_model/error_collecting/human_message_reporter'
+require 'active_model/error_collecting/human_hash_reporter'
+require 'active_model/error_collecting/human_array_reporter'
+
+require 'active_model/error_collecting/machine_hash_reporter'
+require 'active_model/error_collecting/machine_array_reporter'
+
+require 'active_model/error_collecting/emulation'
+require 'active_model/error_collecting/errors'
+
+require 'active_model/error_collecting/core_ext'
+
+module ActiveModel
+  module ErrorCollecting
+    class << self
+      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 = "active_model/error_collecting/#{reporter}_#{name}_reporter"
+        class_name.classify.constantize
+      end
+    end
+
+    set_reporter :message,  :human
+    set_reporter :array,    :human
+    set_reporter :hash,     :human
+  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