active_model-better_errors 1.6.0

data/lib/active_model/error_collecting/array_reporter.rb

@@ -0,0 +1,9 @@
+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

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

@@ -0,0 +1,65 @@
+#
+# Allows included class to emulate ActiveModel::Errors class
+# by defining a set of methods to delegate to facilities
+# in this gem.
+#
+module ActiveModel
+  module ErrorCollecting
+    module Emulation
+      MODEL_METHODS = [
+        :clear, :include?, :get, :set, :delete, :[], :[]=,
+        :each, :size, :values, :keys, :count, :empty?, :any?,
+        :added?, :entries
+      ]
+
+      MESSAGE_REPORTER_METHODS = [
+        :full_messages, :full_message, :generate_message
+      ]
+
+      def self.included(base)
+        base.class_eval do
+          extend Forwardable
+          def_delegators :error_collection, *MODEL_METHODS
+          def_delegators :message_reporter, *MESSAGE_REPORTER_METHODS
+          def_delegators :hash_reporter,    :to_hash
+          def_delegators :array_reporter,   :to_a
+
+          alias_method :blank?, :empty?
+          alias_method :has_key?, :include?
+        end
+      end
+
+      def add_on_empty(attributes, options = {})
+        [attributes].flatten.each do |attribute|
+          value = @base.send(:read_attribute_for_validation, attribute)
+          is_empty = value.respond_to?(:empty?) ? value.empty? : false
+          add(attribute, :empty, options) if value.nil? || is_empty
+        end
+      end
+
+      def add_on_blank(attributes, options = {})
+        [attributes].flatten.each do |attribute|
+          value = @base.send(:read_attribute_for_validation, attribute)
+          add(attribute, :blank, options) if value.blank?
+        end
+      end
+
+      def add(attribute, message, options = {})
+        if options[:strict]
+          error   = ErrorMessage.build(attribute, message, options)
+          message = HumanMessageFormatter.new(@base, error).format_message
+          raise ActiveModel::StrictValidationFailed, full_message(attribute, message)
+        end
+        error_collection.add attribute, message, options
+      end
+
+      def to_xml(options={})
+        to_a.to_xml options.reverse_merge(:root => "errors", :skip_types => true)
+      end
+
+      def as_json(options=nil)
+        to_hash
+      end
+    end
+  end
+end

data/lib/active_model/error_collecting/error_collection.rb

@@ -0,0 +1,86 @@
+module ActiveModel
+  module ErrorCollecting
+    class ErrorCollection
+      include Enumerable
+
+      attr_reader :base
+      def initialize(base)
+        @base = base
+        @collection = {}
+      end
+
+      def clear
+        @collection.clear
+      end
+
+      def include?(attribute)
+        ( v = @collection[attribute] ) && v.any?
+      end
+
+      def get(attribute)
+        @collection[attribute]
+      end
+
+      def set(attribute, errors)
+        return delete attribute if errors.nil?
+        @collection[attribute] = ErrorMessageSet.new(base, attribute, errors)
+      end
+
+      def delete(attribute)
+        @collection.delete attribute
+      end
+
+      def [](attribute)
+        get(attribute.to_sym) || set(attribute.to_sym, [])
+      end
+
+      def []=(attribute, error)
+        self[attribute] << error
+      end
+
+      def each
+        @collection.each_key do |attribute|
+          self[attribute].each { |error_message| yield attribute, error_message }
+        end
+      end
+
+      def size
+        values.inject(0){ |sum, set| sum += set.size }
+      end
+      alias_method :count, :size
+
+      def values
+        @collection.values
+      end
+
+      def keys
+        @collection.keys
+      end
+
+      def to_a
+        array = []
+        @collection.each_key do |attribute|
+          self[attribute].each { |error_message| array << error_message }
+        end
+
+        array
+      end
+
+      def to_hash
+        @collection.dup
+      end
+
+      def empty?
+        size == 0
+      end
+
+      def add(attribute, message, options = {})
+        self[attribute] << [ message, options ]
+      end
+
+      def added?(attribute, message = nil, options = {})
+        self[attribute].include? ErrorMessage.build(base, attribute, message, options)
+      end
+    end
+  end
+end

data/lib/active_model/error_collecting/error_message.rb

@@ -0,0 +1,88 @@
+module ActiveModel
+  module ErrorCollecting
+    class ErrorMessage
+      include Comparable
+      CALLBACKS_OPTIONS = [:if, :unless, :on, :allow_nil, :allow_blank, :strict]
+
+      # return the message either as nil, symbol, or string
+      def self.normalize(message)
+        case message
+        when nil
+          nil
+        when Symbol
+          message
+        when Proc
+          message.call
+        else
+          message.to_s
+        end
+      end
+
+      def self.identify(message, override)
+        symbol = string = nil
+
+        message   = normalize message
+        override  = normalize override
+
+        symbol = message if message.is_a?(Symbol)
+        symbol = override if override.is_a?(Symbol)
+
+        string = message if message.is_a?(String)
+        string = override if override.is_a?(String)
+
+        string = nil if string.blank?
+
+        [symbol, string]
+      end
+
+      def self.build(base, attribute, message, options=nil)
+        options   = options ? options : {}
+        options   = options.except(*CALLBACKS_OPTIONS)
+
+        symbol, string = identify message, options.delete(:message)
+
+        new(base, attribute, symbol, string, options)
+      end
+
+      attr_reader :base, :attribute, :type, :message, :options
+
+      def initialize(base, attribute, type, message, options = {})
+        @base       = base
+        @attribute  = attribute
+        @type       = type
+        @message    = message
+        @options    = options
+      end
+
+      def <=> (other)
+        to_hash <=> other.to_hash
+      end
+
+      def to_hash
+        {
+          attribute: attribute,
+          type:      type,
+          message:   message,
+          options:   options
+        }
+      end
+
+      def hash
+        to_hash.hash
+      end
+
+      def to_s
+        HumanMessageFormatter.new(base, self).format_message
+      end
+
+      def inspect
+        to_s.inspect
+      end
+
+      def ==(other)
+        return type == other if other.is_a?(Symbol)
+        to_s == other.to_s
+      end
+    end
+  end
+end

data/lib/active_model/error_collecting/error_message_set.rb

@@ -0,0 +1,35 @@
+require 'pry'
+
+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,60 @@
+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
+      end
+
+      def format_message
+        return message if message && type.nil?
+
+        type = self.type || :invalid
+
+        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