active_model-better_errors 1.6.3 → 1.6.5

data/.document

@@ -1,5 +0,0 @@
-lib/**/*.rb
-bin/*
-- 
-features/**/*.feature
-LICENSE.txt

data/VERSION

@@ -1 +0,0 @@
-1.6.3

data/lib/active_model/error_collecting.rb

@@ -1,49 +0,0 @@
-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/lib/active_model/error_collecting/array_reporter.rb

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

data/lib/active_model/error_collecting/core_ext.rb

@@ -1,6 +0,0 @@
-class String
-  def ==(other)
-    return super other.to_s if other.is_a? ActiveModel::ErrorCollecting::ErrorMessage
-    super
-  end
-end

data/lib/active_model/error_collecting/hash_reporter.rb

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

data/lib/active_model/error_collecting/human_message_formatter.rb

@@ -1,58 +0,0 @@
-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
-
-        value = (attribute != :base ? base.send(:read_attribute_for_validation, attribute) : nil)
-
-        options = {
-          :default => keys,
-          :model => base.class.model_name.human,
-          :attribute => base.class.human_attribute_name(attribute),
-          :value => value
-        }.merge(self.options)
-
-        I18n.translate key, options
-      end
-
-      private
-
-      def i18n_keys
-        if base.class.respond_to?(:i18n_scope)
-          keys = base.class.lookup_ancestors.map do |klass|
-            [ :"#{base.class.i18n_scope}.errors.models.#{klass.model_name.i18n_key}.attributes.#{attribute}.#{type}",
-              :"#{base.class.i18n_scope}.errors.models.#{klass.model_name.i18n_key}.#{type}" ]
-          end
-        else
-          keys = []
-        end
-        keys << message
-        keys << :"#{base.class.i18n_scope}.errors.messages.#{type}" if base.class.respond_to?(:i18n_scope)
-        keys << :"errors.attributes.#{attribute}.#{type}"
-        keys << :"errors.messages.#{type}"
-
-        keys.compact!
-        keys.flatten!
-        keys
-      end
-    end
-  end
-end

data/spec/lib/active_model/better_errors_spec.rb

@@ -1,7 +0,0 @@
-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/error_message_spec.rb

@@ -1,293 +0,0 @@
-require 'spec_helper'
-
-describe ActiveModel::ErrorCollecting::ErrorMessage do
-  let(:klass)     { ActiveModel::ErrorCollecting::ErrorMessage }
-  let(:attribute) { :name }
-  let(:base)      { User.new }
-  subject(:error_message) { klass.build(base, attribute, message, options) }
-
-  describe ".normalize" do
-    subject { klass.normalize message }
-    context "when message is a symbol" do
-      let(:message) { :invalid }
-      it { should == message }
-    end
-
-    context "when message is nil" do
-      let(:message) { nil }
-      it { should be nil }
-    end
-
-    context "when message is a string" do
-      let(:message) { 'bad' }
-      it { should == message }
-    end
-
-    context "when message is a proc" do
-      let(:message) { proc { 'bad' } }
-      it { should == 'bad' }
-    end
-  end
-
-  describe ".identify" do
-    subject { klass.identify message, override }
-    context "when message is a symbol and" do
-      let(:message) { :invalid }
-
-      context "when override is a symbol" do
-        let(:override) { :not_good }
-        it { should == [:not_good, nil] }
-      end
-
-      context "when override is nil" do
-        let(:override) { nil }
-        it { should == [:invalid, nil] }
-      end
-
-      context "when override is a string" do
-        let(:override) { "invalid" }
-        it { should == [:invalid, "invalid"] }
-      end
-
-      context "when override is a proc" do
-        let(:override) { proc { "Not good" } }
-        it { should == [:invalid, "Not good"] }
-      end
-    end
-
-    context "when message is a string and" do
-      let(:message) { "Invalid" }
-
-      context "when override is a symbol" do
-        let(:override) { :not_good }
-        it { should == [:not_good, "Invalid"] }
-      end
-
-      context "when override is nil" do
-        let(:override) { nil }
-        it { should == [nil, "Invalid"] }
-      end
-
-      context "when override is a string" do
-        let(:override) { "not good" }
-        it { should == [nil, "not good"] }
-      end
-
-      context "when override is a proc" do
-        let(:override) { proc { "Not Good" } }
-        it { should == [nil, "Not Good"] }
-      end
-    end
-
-    context "when message is nil and" do
-      let(:message) { nil }
-
-      context "when override is a symbol" do
-        let(:override) { :not_good }
-        it { should == [:not_good, nil] }
-      end
-
-      context "when override is nil" do
-        let(:override) { nil }
-        it { should == [nil, nil] }
-      end
-
-      context "when override is a string" do
-        let(:override) { "not good" }
-        it { should == [nil, "not good"] }
-      end
-
-      context "when override is a proc" do
-        let(:override) { proc { "Not Good" } }
-        it { should == [nil, "Not Good"] }
-      end
-    end
-
-    context "when message is a proc and" do
-      let(:message) { proc {"invalid"} }
-
-      context "when override is a symbol" do
-        let(:override) { :not_good }
-        it { should == [:not_good, "invalid"] }
-      end
-
-      context "when override is nil" do
-        let(:override) { nil }
-        it { should == [nil, "invalid"] }
-      end
-
-      context "when override is a string" do
-        let(:override) { "not good" }
-        it { should == [nil, "not good"] }
-      end
-
-      context "when override is a proc" do
-        let(:override) { proc { "Not Good" } }
-        it { should == [nil, "Not Good"] }
-      end
-    end
-  end
-
-
-  describe ".build" do
-    context "when message is a symbol and" do
-      let(:message) { :invalid }
-
-      context "when options[:message] is a string" do
-        let(:options) { { message: "Not Really Valid!" } }
-        its(:type)    { should == message }
-        its(:message) { should == options[:message] }
-      end
-
-      context "when options[:message] is a symbol" do
-        let(:options) { { message: :not_really_valid } }
-        its(:type)    { should == options[:message] }
-        its(:message) { should == nil }
-      end
-
-      context "when options[:message] is nil" do
-        let(:options) { { message: nil } }
-        its(:type)    { should == message }
-        its(:message) { should == nil }
-      end
-
-      context "when options[:message] is proc" do
-        let(:options) { { message: proc { "Not Really Valid!" } } }
-        its(:type)    { should == message }
-        its(:message) { should == options[:message].call }
-      end
-    end
-
-    context "when message is a string and" do
-      let(:message) { 'Invalid!' }
-
-      context "when options[:message] is a string" do
-        let(:options) { { message: "Not Really Valid!" } }
-        its(:type)    { should == nil }
-        its(:message) { should == options[:message] }
-      end
-
-      context "when options[:message] is a symbol" do
-        let(:options) { { message: :not_really_valid } }
-        its(:type)    { should == options[:message] }
-        its(:message) { should == message }
-      end
-
-      context "when options[:message] is nil" do
-        let(:options) { { } }
-        its(:type)    { should == nil }
-        its(:message) { should == message }
-      end
-
-      context "when options[:message] is proc" do
-        let(:options) { { message: proc { "Not Really Valid!" } } }
-        its(:type)    { should == nil }
-        its(:message) { should == options[:message].call }
-      end
-    end
-
-    context "when message is a proc and" do
-      let(:message) { proc{ 'Invalid!' } }
-
-      context "when options[:message] is a string" do
-        let(:options) { { message: "Not Really Valid!" } }
-        its(:type)    { should == nil }
-        its(:message) { should == options[:message] }
-      end
-
-      context "when options[:message] is a symbol" do
-        let(:options) { { message: :not_really_valid } }
-        its(:type)    { should == options[:message] }
-        its(:message) { should == message.call }
-      end
-
-      context "when options[:message] is nil" do
-        let(:options) { { } }
-        its(:type)    { should == nil }
-        its(:message) { should == message.call }
-      end
-
-      context "when options[:message] is proc" do
-        let(:options) { { message: proc { "Not Really Valid!" } } }
-        its(:type)    { should == nil }
-        its(:message) { should == options[:message].call }
-      end
-    end
-
-
-    context "when message is nil and" do
-      let(:message) { nil }
-
-      context "when options[:message] is a string" do
-        let(:options) { { message: "Not Really Valid!" } }
-        its(:type)    { should == nil }
-        its(:message) { should == options[:message] }
-      end
-
-      context "when options[:message] is a symbol" do
-        let(:options) { { message: :not_really_valid } }
-        its(:type)    { should == options[:message] }
-        its(:message) { should == nil }
-      end
-
-      context "when options[:message] is nil" do
-        let(:options) { { } }
-        its(:type)    { should == nil }
-        its(:message) { should == nil }
-      end
-
-      context "when options[:message] is proc" do
-        let(:options) { { message: proc { "Not Really Valid!" } } }
-        its(:type)    { should == nil }
-        its(:message) { should == options[:message].call }
-      end
-    end
-
-    [
-      :if, :unless, :on, :allow_nil, :allow_blank, :strict, :message
-    ].each do |field|
-      context "when options includes :#{field}" do
-        let(:message) { :invalid }
-        let(:options) { {} }
-        before { options[field] = proc{} }
-        its(:options) { should == {} }
-      end
-    end
-  end
-
-  describe '#initialize' do
-    let(:message) { :invalid }
-    let(:options) { { message: "Invalid!", count: 12 } }
-
-    its(:options)   { should == { count: 12 } }
-    its(:attribute) { should == attribute }
-  end
-
-  describe '#<=>' do
-    subject { e1 <=> e2 }
-
-    context "when attribute is different" do
-      let(:e1) { klass.build base, :name, :invalid }
-      let(:e2) { klass.build base, :name1, :invalid }
-      it {should == nil }
-    end
-
-    context "when type is different" do
-      let(:e1) { klass.build base, :name, :invalid }
-      let(:e2) { klass.build base, :name, :invalid1 }
-      it {should == nil }
-    end
-
-    context "when message is different" do
-      let(:e1) { klass.build base, :name, :invalid, :message => "a" }
-      let(:e2) { klass.build base, :name, :invalid, :message => "b" }
-      it {should == nil }
-    end
-
-    context "when it is the same" do
-      let(:e1) { klass.build base, :name, :invalid }
-      let(:e2) { klass.build base, :name, :invalid }
-      it { should == 0 }
-    end
-  end
-end