rest_my_case 1.6.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d82932cb42f7f06eaa0a2ffd09fc866ae7217047
-  data.tar.gz: 35df440b5058dde4f650d7cc20a1f4f116c9c45f
+  metadata.gz: 4fbc100a76e2fe8ef3a5b546121c072662e41864
+  data.tar.gz: 335942040cc881c507bf65a3a437f50f1436c3b0
 SHA512:
-  metadata.gz: 0495e5467c6f6331d5dd19878fc74171903f915ba5de464b3770cfdaa26df83df943b2773f857d23aec381995237ac5e5279ac912a6726bdc56b3b42829486bb
-  data.tar.gz: 5a28d8b8550466280cddb7352c12135b0f3f5d6bf8d90cdc5418eedbfa1908996321cb4a13d1c2d4441c23e143fea495e979354eb807a7222b9405d6123f9514
+  metadata.gz: 2872b4f50c0d422921083b393fda8d3d81010a7e7268985d966bcab5961aa5c398506af5494f2fd6889bcebeb551f2a3ecac4c09e74df57a3d4012914952254c
+  data.tar.gz: b464f45b1152e7916cc847d0b8c34e3e26a57ee0393b6b33896c831ce950e7f3b3ea4d65abba3e1ead99ee3d5c042bc0e341b0532698c147a87eeb0da8ad87df

data/.rubocop.yml

@@ -10,13 +10,6 @@ Style/EmptyLinesAroundModuleBody:
 Style/EmptyLinesAroundClassBody:
   Enabled: false
 
-Style/DotPosition:
-  Enabled: false
-
-Style/Encoding:
-  Enabled: true
-  EnforcedStyle: when_needed
-
 AllCops:
   Exclude:
     - '**/Rakefile'
@@ -25,6 +18,8 @@ AllCops:
     - 'spec/**/*'
     - 'tmp/**/*'
     - 'pkg/**/*'
+    - 'lib/rest_my_case/accusation_attorneys/**/*'
+    - 'lib/rest_my_case/validator/errors.rb'
 
 Documentation:
   Enabled: false

data/lib/rest_my_case.rb

@@ -1,21 +1,31 @@
 require 'ostruct'
 
 require 'rest_my_case/version'
+require 'rest_my_case/helpers'
 require 'rest_my_case/errors'
-
 require 'rest_my_case/config/base'
 require 'rest_my_case/config/general'
-
 require 'rest_my_case/defense_attorney/base'
 require 'rest_my_case/context/base'
 require 'rest_my_case/judge/base'
-
-require 'rest_my_case/trial/defendant'
 require 'rest_my_case/trial/case'
 require 'rest_my_case/trial/court'
 
 require 'rest_my_case/base'
 
+require 'rest_my_case/accusation_attorneys/helper_methods'
+require 'rest_my_case/accusation_attorneys/base'
+require 'rest_my_case/accusation_attorneys/each'
+require 'rest_my_case/accusation_attorneys/custom'
+# require 'rest_my_case/accusation_attorneys/format'
+# require 'rest_my_case/accusation_attorneys/length'
+require 'rest_my_case/accusation_attorneys/presence'
+# require 'rest_my_case/accusation_attorneys/numericality'
+
+require 'rest_my_case/validator/class_methods'
+require 'rest_my_case/validator/errors'
+require 'rest_my_case/validator/base'
+
 module RestMyCase
 
   def self.configure

data/lib/rest_my_case/accusation_attorneys/base.rb

@@ -0,0 +1,23 @@
+module RestMyCase
+  module AccusationAttorneys
+
+    class Base
+
+      attr_accessor :base
+
+      attr_reader :options
+
+      def initialize(options = {})
+        @options = Helpers.except(options, :class).freeze
+      end
+
+      # Override this method in subclasses with validation logic, adding errors
+      # to the records +errors+ array where necessary.
+      def validate(record)
+        fail NotImplementedError, "Subclasses must implement a validate(record) method."
+      end
+
+    end
+
+  end
+end

data/lib/rest_my_case/accusation_attorneys/custom.rb

@@ -0,0 +1,21 @@
+module RestMyCase
+  module AccusationAttorneys
+
+    class Custom < Base
+
+      attr_reader :methods
+
+      def initialize(args)
+        @methods = args
+
+        super Helpers.extract_options!(args)
+      end
+
+      def validate(record)
+        [*methods].map { |method| base.send(method, record) }.all?
+      end
+
+    end
+
+  end
+end

data/lib/rest_my_case/accusation_attorneys/each.rb

@@ -0,0 +1,34 @@
+module RestMyCase
+  module AccusationAttorneys
+
+    class Each < Base
+
+      attr_reader :attributes
+
+      def initialize(options)
+        @attributes = Array(options.delete(:attributes))
+        fail ArgumentError, ":attributes cannot be blank" if @attributes.empty?
+        super
+        check_validity!
+      end
+
+      def validate(record)
+        attributes.each do |attribute|
+          value = record.respond_to?(attribute) ? record.send(attribute) : nil
+          next if (value.nil? && options[:allow_nil]) || (Helpers.blank?(value) && options[:allow_blank])
+          validate_each(record, attribute, value)
+        end
+      end
+
+      # Override this method in subclasses with the validation logic, adding
+      # errors to the records +errors+ array where necessary.
+      def validate_each(record, attribute, value)
+        fail NotImplementedError, "Subclasses must implement a validate_each(record, attribute, value) method"
+      end
+
+      def check_validity!; end
+
+    end
+
+  end
+end

data/lib/rest_my_case/accusation_attorneys/helper_methods.rb

@@ -0,0 +1,16 @@
+module RestMyCase
+  module AccusationAttorneys
+
+    module HelperMethods
+
+      def _merge_attributes(attr_names)
+        options = Helpers.symbolyze_keys(Helpers.extract_options!(attr_names))
+        attr_names.flatten!
+        options[:attributes] = attr_names
+        options
+      end
+
+    end
+
+  end
+end

data/lib/rest_my_case/accusation_attorneys/presence.rb

@@ -0,0 +1,17 @@
+module RestMyCase
+  module AccusationAttorneys
+
+    class Presence < Each
+      def validate_each(record, attr_name, value)
+        record.errors.add(attr_name, :blank, options) if Helpers.blank?(value)
+      end
+    end
+
+    module HelperMethods
+      def validates_presence_of(*attr_names)
+        validates_with Presence, _merge_attributes(attr_names)
+      end
+    end
+
+  end
+end

data/lib/rest_my_case/base.rb

@@ -4,7 +4,10 @@ module RestMyCase
 
     extend Config::Base
 
-    TRIAL_COURT = Trial::Court.new Judge::Base, DefenseAttorney::Base
+    def self.trial_court
+      @trial_court ||= Trial::Court.new \
+        Judge::Base, DefenseAttorney::Base, RestMyCase::Base
+    end
 
     def self.depends(*use_case_classes)
       dependencies.push(*use_case_classes)
@@ -21,7 +24,7 @@ module RestMyCase
         fail ArgumentError, 'Must respond_to method #to_hash'
       end
 
-      TRIAL_COURT.execute([self], attributes.to_hash).context
+      trial_court.execute([self], attributes.to_hash).context
     end
 
     def self.context_accessor(*methods)
@@ -58,11 +61,11 @@ module RestMyCase
     def final; end
 
     def invoke(*use_case_classes)
-      TRIAL_COURT.execute(use_case_classes, context.to_hash).context
+      trial_court.execute(use_case_classes, context.to_hash).context
     end
 
     def invoke!(*use_case_classes)
-      TRIAL_COURT.execute(use_case_classes, context).tap do |trial_case|
+      trial_court.execute(use_case_classes, context).tap do |trial_case|
         abort if trial_case.aborted
       end.context
     end
@@ -93,10 +96,15 @@ module RestMyCase
 
     protected ######################## PROTECTED ###############################
 
+    def trial_court
+      self.class.trial_court
+    end
+
     def silent_abort?
       return false if dependent_use_case.nil?
 
-      RestMyCase.get_config :silence_dependencies_abort, dependent_use_case.class
+      RestMyCase.get_config \
+        :silence_dependencies_abort, dependent_use_case.class
     end
 
   end

data/lib/rest_my_case/config/general.rb

@@ -10,11 +10,25 @@ module RestMyCase
       end
 
       def get(attribute, use_case_class)
-        custom_config = use_case_class.send(attribute)
+        custom_config = use_case_class_config(attribute, use_case_class)
 
         custom_config.nil? ? send(attribute) : custom_config
       end
 
+      protected ######################## PROTECTED #############################
+
+      def use_case_class_config(attribute, use_case_class)
+        return nil unless use_case_class.respond_to? attribute
+
+        custom_config = use_case_class.send(attribute)
+
+        if custom_config.nil?
+          use_case_class_config(attribute, use_case_class.superclass)
+        else
+          custom_config
+        end
+      end
+
     end
 
   end

data/lib/rest_my_case/defense_attorney/base.rb

@@ -9,7 +9,7 @@ module RestMyCase
 
       def build_case_for_the_defendant
         @trial_case.use_cases =
-          @trial_case.defendant.use_case_classes.map do |use_case_class|
+          @trial_case.use_case_classes.map do |use_case_class|
             all_dependencies(use_case_class)
           end.flatten
       end
@@ -17,17 +17,15 @@ module RestMyCase
       protected ######################## PROTECTED #############################
 
       def all_dependencies(use_case_class)
-        return [] unless use_case_class.respond_to? :dependencies
+        return [] if use_case_class == @trial_case.last_ancestor
 
         all_dependencies(use_case_class.superclass) |
-          dependencies_including_itself_last(use_case_class, nil)
+          dependencies_including_itself(use_case_class, @trial_case.defendant)
       end
 
       private ########################### PRIVATE ##############################
 
-      def dependencies_including_itself_last(use_case_class, dependent_use_case)
-        return [] unless use_case_class.superclass.respond_to? :dependencies
-
+      def dependencies_including_itself(use_case_class, dependent_use_case)
         use_case = use_case_class.new(@trial_case.context, dependent_use_case)
 
         dependencies(use_case).push use_case
@@ -35,7 +33,7 @@ module RestMyCase
 
       def dependencies(use_case)
         use_case.class.dependencies.map do |dependency|
-          dependencies_including_itself_last dependency, use_case
+          dependencies_including_itself dependency, use_case
         end
       end
 

data/lib/rest_my_case/helpers.rb

@@ -0,0 +1,63 @@
+module RestMyCase
+
+  module Helpers
+
+    module_function
+
+    def super_method(object, method_name, *args)
+      return nil unless object.superclass.respond_to? method_name
+
+      object.superclass.send method_name, *args
+    end
+
+    def blank?(object)
+      if object.is_a?(String)
+        object !~ /[^[:space:]]/
+      else
+        object.respond_to?(:empty?) ? object.empty? : !object
+      end
+    end
+
+    def marked_for_destruction?(object)
+      return false unless object.respond_to?(:marked_for_destruction?)
+
+      object.marked_for_destruction?
+    end
+
+    def extract_options!(array)
+      if array.last.is_a?(Hash) && array.last.instance_of?(Hash)
+        array.pop
+      else
+        {}
+      end
+    end
+
+    def symbolyze_keys(hash)
+      hash.keys.each_with_object({}) do |key, symbolyzed_hash|
+        symbolyzed_hash[key.to_sym] = hash[key]
+      end
+    end
+
+    def except(hash, *keys)
+      hash = hash.dup
+      keys.each { |key| hash.delete(key) }
+      hash
+    end
+
+    def slice(hash, *keys)
+      keys.each_with_object({}) do |key, sliced_hash|
+        sliced_hash[key] = hash[key]
+      end
+    end
+
+    def call_proc_or_method(base, proc_or_method, object = nil)
+      if proc_or_method.is_a?(Proc)
+        base.instance_exec(object, &proc_or_method)
+      else
+        base.send(proc_or_method, object)
+      end
+    end
+
+  end
+
+end

data/lib/rest_my_case/judge/base.rb

@@ -15,7 +15,7 @@ module RestMyCase
         run_rollback_methods
         run_final_methods
 
-        @trial_case.aborted = !@use_case_that_aborted.nil?
+        @trial_case.should_abort = !@use_case_that_aborted.nil?
       end
 
       protected ######################## PROTECTED #############################

data/lib/rest_my_case/trial/case.rb

@@ -3,15 +3,19 @@ module RestMyCase
 
     class Case
 
-      attr_accessor :use_cases, :aborted
+      attr_accessor :use_cases, :should_abort
 
-      attr_reader :context, :defendant
+      attr_reader :context, :defendant, :last_ancestor, :use_case_classes
 
-      def initialize(use_case_classes, attributes)
-        @aborted   = false
-        @context   = build_context(attributes)
-        @defendant = Defendant.new use_case_classes
-        @use_cases = []
+      def initialize(last_ancestor, use_case_classes, attributes)
+        @context          = build_context attributes
+        @defendant        = build_defendant(last_ancestor, use_case_classes)
+        @last_ancestor    = last_ancestor
+        @use_case_classes = use_case_classes
+      end
+
+      def aborted
+        @should_abort || defendant.options[:should_abort]
       end
 
       protected ######################## PROTECTED #############################
@@ -22,6 +26,12 @@ module RestMyCase
         Context::Base.new attributes
       end
 
+      def build_defendant(defendant_class, use_case_classes)
+        Class.new(defendant_class) do
+          depends(*use_case_classes)
+        end.new(@context)
+      end
+
     end
 
   end

data/lib/rest_my_case/trial/court.rb

@@ -1,10 +1,10 @@
 module RestMyCase
   module Trial
 
-    Court = Struct.new(:judge_class, :defense_attorney_class) do
+    Court = Struct.new(:judge_class, :defense_attorney_class, :last_ancestor) do
 
       def execute(use_case_classes, attributes = {})
-        trial_case = Case.new(use_case_classes, attributes)
+        trial_case = Case.new(last_ancestor, use_case_classes, attributes)
 
         defense_attorney_class.new(trial_case).build_case_for_the_defendant
 

data/lib/rest_my_case/validator/base.rb

@@ -0,0 +1,82 @@
+module RestMyCase
+  module Validator
+
+    class Base < RestMyCase::Base
+
+      extend ClassMethods
+
+      self.silence_dependencies_abort = true
+
+      extend AccusationAttorneys::HelperMethods
+
+      def target_name
+        self.class.target_name
+      end
+
+      def target
+        respond_to?(target_name) ? send(target_name) : context.send(target_name)
+      end
+
+      def perform
+        targets = [*target]
+
+        skip! if targets.empty?
+
+        if target.nil?
+          error('no target to validate!')
+        else
+          error('unprocessable_entity') unless all_validations_green? targets
+        end
+      end
+
+      protected ######################## PROTECTED #############################
+
+      def all_validations_green?(targets)
+        targets.map do |object_to_validate|
+          if Helpers.marked_for_destruction?(object_to_validate)
+            true
+          else
+            extend_errors_and_run_validations(object_to_validate)
+
+            object_to_validate.errors.empty?
+          end
+        end.all?
+      end
+
+      private ########################### PRIVATE ##############################
+
+      def extend_errors_and_run_validations(object_to_validate)
+        extend_errors_if_necessary object_to_validate
+
+        object_to_validate.errors.clear if self.class.clear_errors
+
+        self.class.validators.values.flatten.uniq.each do |validator|
+          next if validator_condition_fails(validator, object_to_validate)
+
+          validator.base = self
+
+          validator.validate object_to_validate
+        end
+      end
+
+      def extend_errors_if_necessary(object_to_validate)
+        return true if object_to_validate.respond_to?(:errors)
+
+        object_to_validate.instance_eval do
+          def errors
+            @errors ||= Errors.new(self)
+          end
+        end
+      end
+
+      def validator_condition_fails(validator, object_to_validate)
+        return false unless validator.options.key?(:if)
+
+        !Helpers.call_proc_or_method \
+          self, validator.options[:if], object_to_validate
+      end
+
+    end
+
+  end
+end

data/lib/rest_my_case/validator/class_methods.rb

@@ -0,0 +1,58 @@
+module RestMyCase
+  module Validator
+
+    module ClassMethods
+
+      attr_reader :validators, :clear_errors
+
+      def trial_court
+        @trial_court ||= Trial::Court.new \
+          Judge::Base, DefenseAttorney::Base, RestMyCase::Validator::Base
+      end
+
+      def target_name
+        @target_name || Helpers.super_method(self, :target_name)
+      end
+
+      def target(target_name)
+        @target_name = target_name
+      end
+
+      def clear_errors!
+        @clear_errors = true
+      end
+
+      def validators
+        @validators ||= Hash.new { |hash, key| hash[key] = [] }
+      end
+
+      def validate(*args, &block)
+        validators[nil] << CustomValidator.new(args, &block)
+      end
+
+      def validates_with(*args, &block)
+        options = Helpers.extract_options!(args)
+
+        options[:class] = self
+
+        args.each do |klass|
+          store_validators_by_attribute klass.new(options, &block)
+        end
+      end
+
+      protected ######################## PROTECTED #############################
+
+      def store_validators_by_attribute(validator)
+        if validator.respond_to?(:attributes) && !validator.attributes.empty?
+          validator.attributes.each do |attribute|
+            validators[attribute.to_sym] << validator
+          end
+        else
+          validators[nil] << validator
+        end
+      end
+
+    end
+
+  end
+end

data/lib/rest_my_case/validator/errors.rb

@@ -0,0 +1,366 @@
+module RestMyCase
+  module Validator
+
+    class Errors
+      include Enumerable
+
+      CALLBACKS_OPTIONS = [:if, :unless, :on, :allow_nil, :allow_blank, :strict]
+
+      attr_reader :messages
+
+      # Pass in the instance of the object that is using the errors object.
+      #
+      #   class Person
+      #     def initialize
+      #       @errors = ActiveModel::Errors.new(self)
+      #     end
+      #   end
+      def initialize(base)
+        @base     = base
+        @messages = {}
+      end
+
+      def initialize_dup(other) # :nodoc:
+        @messages = other.messages.dup
+        super
+      end
+
+      # Clear the error messages.
+      #
+      #   person.errors.full_messages # => ["name can not be nil"]
+      #   person.errors.clear
+      #   person.errors.full_messages # => []
+      def clear
+        messages.clear
+      end
+
+      # Returns +true+ if the error messages include an error for the given key
+      # +attribute+, +false+ otherwise.
+      #
+      #   person.errors.messages        # => {:name=>["can not be nil"]}
+      #   person.errors.include?(:name) # => true
+      #   person.errors.include?(:age)  # => false
+      def include?(attribute)
+        (v = messages[attribute]) && v.any?
+      end
+      # aliases include?
+      alias :has_key? :include?
+
+      # Get messages for +key+.
+      #
+      #   person.errors.messages   # => {:name=>["can not be nil"]}
+      #   person.errors.get(:name) # => ["can not be nil"]
+      #   person.errors.get(:age)  # => nil
+      def get(key)
+        messages[key]
+      end
+
+      # Set messages for +key+ to +value+.
+      #
+      #   person.errors.get(:name) # => ["can not be nil"]
+      #   person.errors.set(:name, ["can't be nil"])
+      #   person.errors.get(:name) # => ["can't be nil"]
+      def set(key, value)
+        messages[key] = value
+      end
+
+      # Delete messages for +key+. Returns the deleted messages.
+      #
+      #   person.errors.get(:name)    # => ["can not be nil"]
+      #   person.errors.delete(:name) # => ["can not be nil"]
+      #   person.errors.get(:name)    # => nil
+      def delete(key)
+        messages.delete(key)
+      end
+
+      # When passed a symbol or a name of a method, returns an array of errors
+      # for the method.
+      #
+      #   person.errors[:name]  # => ["can not be nil"]
+      #   person.errors['name'] # => ["can not be nil"]
+      def [](attribute)
+        get(attribute.to_sym) || set(attribute.to_sym, [])
+      end
+
+      # Adds to the supplied attribute the supplied error message.
+      #
+      #   person.errors[:name] = "must be set"
+      #   person.errors[:name] # => ['must be set']
+      def []=(attribute, error)
+        self[attribute] << error
+      end
+
+      # Iterates through each error key, value pair in the error messages hash.
+      # Yields the attribute and the error for that attribute. If the attribute
+      # has more than one error message, yields once for each error message.
+      #
+      #   person.errors.add(:name, "can't be blank")
+      #   person.errors.each do |attribute, error|
+      #     # Will yield :name and "can't be blank"
+      #   end
+      #
+      #   person.errors.add(:name, "must be specified")
+      #   person.errors.each do |attribute, error|
+      #     # Will yield :name and "can't be blank"
+      #     # then yield :name and "must be specified"
+      #   end
+      def each
+        messages.each_key do |attribute|
+          self[attribute].each { |error| yield attribute, error }
+        end
+      end
+
+      # Returns the number of error messages.
+      #
+      #   person.errors.add(:name, "can't be blank")
+      #   person.errors.size # => 1
+      #   person.errors.add(:name, "must be specified")
+      #   person.errors.size # => 2
+      def size
+        values.flatten.size
+      end
+
+      # Returns all message values.
+      #
+      #   person.errors.messages # => {:name=>["can not be nil", "must be specified"]}
+      #   person.errors.values   # => [["can not be nil", "must be specified"]]
+      def values
+        messages.values
+      end
+
+      # Returns all message keys.
+      #
+      #   person.errors.messages # => {:name=>["can not be nil", "must be specified"]}
+      #   person.errors.keys     # => [:name]
+      def keys
+        messages.keys
+      end
+
+      # Returns an array of error messages, with the attribute name included.
+      #
+      #   person.errors.add(:name, "can't be blank")
+      #   person.errors.add(:name, "must be specified")
+      #   person.errors.to_a # => ["name can't be blank", "name must be specified"]
+      def to_a
+        full_messages
+      end
+
+      # Returns the number of error messages.
+      #
+      #   person.errors.add(:name, "can't be blank")
+      #   person.errors.count # => 1
+      #   person.errors.add(:name, "must be specified")
+      #   person.errors.count # => 2
+      def count
+        to_a.size
+      end
+
+      # Returns +true+ if no errors are found, +false+ otherwise.
+      # If the error message is a string it can be empty.
+      #
+      #   person.errors.full_messages # => ["name can not be nil"]
+      #   person.errors.empty?        # => false
+      def empty?
+        all? { |k, v| v && v.empty? && !v.is_a?(String) }
+      end
+      # aliases empty?
+      alias_method :blank?, :empty?
+
+      # Returns an xml formatted representation of the Errors hash.
+      #
+      #   person.errors.add(:name, "can't be blank")
+      #   person.errors.add(:name, "must be specified")
+      #   person.errors.to_xml
+      #   # =>
+      #   #  <?xml version=\"1.0\" encoding=\"UTF-8\"?>
+      #   #  <errors>
+      #   #    <error>name can't be blank</error>
+      #   #    <error>name must be specified</error>
+      #   #  </errors>
+      def to_xml(options={})
+        to_a.to_xml({ root: "errors", skip_types: true }.merge!(options))
+      end
+
+      # Returns a Hash that can be used as the JSON representation for this
+      # object. You can pass the <tt>:full_messages</tt> option. This determines
+      # if the json object should contain full messages or not (false by default).
+      #
+      #   person.as_json                      # => {:name=>["can not be nil"]}
+      #   person.as_json(full_messages: true) # => {:name=>["name can not be nil"]}
+      def as_json(options=nil)
+        to_hash(options && options[:full_messages])
+      end
+
+      # Returns a Hash of attributes with their error messages. If +full_messages+
+      # is +true+, it will contain full messages (see +full_message+).
+      #
+      #   person.to_hash       # => {:name=>["can not be nil"]}
+      #   person.to_hash(true) # => {:name=>["name can not be nil"]}
+      def to_hash(full_messages = false)
+        if full_messages
+          messages = {}
+          self.messages.each do |attribute, array|
+            messages[attribute] = array.map { |message| full_message(attribute, message) }
+          end
+          messages
+        else
+          self.messages.dup
+        end
+      end
+
+      # Adds +message+ to the error messages on +attribute+. More than one error
+      # can be added to the same +attribute+. If no +message+ is supplied,
+      # <tt>:invalid</tt> is assumed.
+      #
+      #   person.errors.add(:name)
+      #   # => ["is invalid"]
+      #   person.errors.add(:name, 'must be implemented')
+      #   # => ["is invalid", "must be implemented"]
+      #
+      #   person.errors.messages
+      #   # => {:name=>["must be implemented", "is invalid"]}
+      #
+      # If +message+ is a symbol, it will be translated using the appropriate
+      # scope (see +generate_message+).
+      #
+      # If +message+ is a proc, it will be called, allowing for things like
+      # <tt>Time.now</tt> to be used within an error.
+      #
+      #   person.errors.messages # => {}
+      def add(attribute, message = nil, options = {})
+        message = normalize_message(attribute, message, options)
+        self[attribute] << message
+      end
+
+      # Returns +true+ if an error on the attribute with the given message is
+      # present, +false+ otherwise. +message+ is treated the same as for +add+.
+      #
+      #   person.errors.add :name, :blank
+      #   person.errors.added? :name, :blank # => true
+      def added?(attribute, message = nil, options = {})
+        message = normalize_message(attribute, message, options)
+        self[attribute].include? message
+      end
+
+      # Returns all the full error messages in an array.
+      #
+      #   class Person
+      #     validates_presence_of :name, :address, :email
+      #     validates_length_of :name, in: 5..30
+      #   end
+      #
+      #   person = Person.create(address: '123 First St.')
+      #   person.errors.full_messages
+      #   # => ["Name is too short (minimum is 5 characters)", "Name can't be blank", "Email can't be blank"]
+      def full_messages
+        map { |attribute, message| full_message(attribute, message) }
+      end
+
+      # Returns all the full error messages for a given attribute in an array.
+      #
+      #   class Person
+      #     validates_presence_of :name, :email
+      #     validates_length_of :name, in: 5..30
+      #   end
+      #
+      #   person = Person.create()
+      #   person.errors.full_messages_for(:name)
+      #   # => ["Name is too short (minimum is 5 characters)", "Name can't be blank"]
+      def full_messages_for(attribute)
+        (get(attribute) || []).map { |message| full_message(attribute, message) }
+      end
+
+      # Returns a full message for a given attribute.
+      #
+      #   person.errors.full_message(:name, 'is invalid') # => "Name is invalid"
+      def full_message(attribute, message)
+        return message if attribute == :base || !@base.class.respond_to?(:model_name)
+
+        attr_name = attribute.to_s.tr('.', '_').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
+
+      # Translates an error message in its default scope
+      # (<tt>activemodel.errors.messages</tt>).
+      #
+      # Error messages are first looked up in <tt>models.MODEL.attributes.ATTRIBUTE.MESSAGE</tt>,
+      # if it's not there, it's looked up in <tt>models.MODEL.MESSAGE</tt> and if
+      # that is not there also, it returns the translation of the default message
+      # (e.g. <tt>activemodel.errors.messages.MESSAGE</tt>). The translated model
+      # name, translated attribute name and the value are available for
+      # interpolation.
+      #
+      # When using inheritance in your models, it will check all the inherited
+      # models too, but only if the model itself hasn't been found. Say you have
+      # <tt>class Admin < User; end</tt> and you wanted the translation for
+      # the <tt>:blank</tt> error message for the <tt>title</tt> attribute,
+      # it looks for these translations:
+      #
+      # * <tt>activemodel.errors.models.admin.attributes.title.blank</tt>
+      # * <tt>activemodel.errors.models.admin.blank</tt>
+      # * <tt>activemodel.errors.models.user.attributes.title.blank</tt>
+      # * <tt>activemodel.errors.models.user.blank</tt>
+      # * any default you provided through the +options+ hash (in the <tt>activemodel.errors</tt> scope)
+      # * <tt>activemodel.errors.messages.blank</tt>
+      # * <tt>errors.attributes.title.blank</tt>
+      # * <tt>errors.messages.blank</tt>
+      def generate_message(attribute, type = :invalid, options = {})
+        type = options.delete(:message) if options[:message].is_a?(Symbol)
+
+        if !@base.class.respond_to?(:model_name)
+          return options.key?(:message) ? options[:message] : type
+        end
+
+        if @base.class.respond_to?(:i18n_scope)
+          defaults = @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
+          defaults = []
+        end
+
+        defaults << options.delete(:message)
+        defaults << :"#{@base.class.i18n_scope}.errors.messages.#{type}" if @base.class.respond_to?(:i18n_scope)
+        defaults << :"errors.attributes.#{attribute}.#{type}"
+        defaults << :"errors.messages.#{type}"
+
+        defaults.compact!
+        defaults.flatten!
+
+        key = defaults.shift
+        value = (attribute != :base ? @base.send(attribute) : nil)
+
+        options = {
+          default: defaults,
+          model: @base.class.model_name.human,
+          attribute: @base.class.human_attribute_name(attribute),
+          value: value
+        }.merge!(options)
+
+        I18n.translate(key, options)
+      end
+
+    private
+      def normalize_message(attribute, message, options)
+        message ||= :invalid
+
+        case message
+        when Symbol
+          generate_message(attribute, message, Helpers.except(options, *CALLBACKS_OPTIONS))
+        when Proc
+          message.call
+        else
+          message
+        end
+      end
+
+    end
+
+  end
+end

data/lib/rest_my_case/version.rb

@@ -1,5 +1,5 @@
 module RestMyCase
 
-  VERSION = '1.6.0'
+  VERSION = '1.7.0'
 
 end

data/spec/rest_my_case/base_spec.rb

@@ -295,7 +295,7 @@ describe RestMyCase::Base do
         it "context prove that only the correct method have ran" do
           expect(@context.setup.length).to be 7
           expect(@context.perform.length).to be 7
-          expect(@context.rollback.length).to be 7
+          expect(@context.rollback.length).to be 0
           expect(@context.final.length).to be 7
         end
 

data/spec/rest_my_case/defense_attorney/base_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe RestMyCase::DefenseAttorney::Base do
 
   let(:use_cases) do
-    trial_case = RestMyCase::Trial::Case.new(use_case_classes, id: 1)
+    trial_case = RestMyCase::Trial::Case.new(RestMyCase::Base, use_case_classes, id: 1)
 
     described_class.new(trial_case).build_case_for_the_defendant
 

data/spec/rest_my_case/trial_case/court_spec.rb

@@ -4,12 +4,14 @@ describe RestMyCase::Trial::Court do
 
   context "When using Judge::Base and DefenseAttorney::Base" do
     before do
-      @trial_court = described_class.new RestMyCase::Judge::Base, RestMyCase::DefenseAttorney::Base
+      @use_case_class = Class.new(RestMyCase::Base)
+      @trial_court = described_class.new \
+        RestMyCase::Judge::Base, RestMyCase::DefenseAttorney::Base, RestMyCase::Base
     end
 
     context "When something that responds to #to_hash is passed down" do
 
-      let(:context) { @trial_court.execute([Object], id: 1, name: '2').context }
+      let(:context) { @trial_court.execute([@use_case_class], id: 1, name: '2').context }
 
       it "should create a context with it" do
         expect(context).to be_a RestMyCase::Context::Base

data/spec/rest_my_case/validator/hierarchy_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe 'Testing hierarchy capabilities' do
+
+  it "HierarchyValidation::Son should be able to inherit Father's validations and alter them" do
+    # post_for_father = RubyPost.new
+    # father_context  = HierarchyValidation::Father.perform(post: post_for_father)
+
+    # expect(father_context.ok?).to be false
+    # expect(post_for_father.errors.added?(:title, :blank)).to be true
+    # expect(post_for_father.errors.size).to be 1
+
+    post_for_son  = RubyPost.new
+    son_context   = HierarchyValidation::Son.perform(post: post_for_son)
+
+    expect(son_context.ok?).to be false
+    expect(post_for_son.errors.added?(:title, :blank)).to be true
+    expect(post_for_son.errors.added?(:email, :blank)).to be true
+    expect(post_for_son.errors.size).to be 2
+  end
+
+end
+

data/spec/support/validator/models/ruby_post.rb

@@ -0,0 +1,9 @@
+class RubyPost
+
+  attr_accessor :title, :body, :phone_number
+
+  def initialize(attributes = {})
+    (attributes || {}).each { |name, value| send("#{name}=", value) }
+  end
+
+end

data/spec/support/validator/models/ruby_post_with_comments.rb

@@ -0,0 +1,28 @@
+class RubyPostWithComments
+
+  class RubyComment
+
+    attr_accessor :title, :email, :post_id
+
+    def initialize(attributes = {})
+      (attributes || {}).each { |name, value| send("#{name}=", value) }
+    end
+
+  end
+
+
+  attr_reader :comments
+
+  def initialize(comments = {})
+    @comments = comments.map { |comment| RubyComment.new(comment) }
+    @comments = [] if @comments.nil?
+  end
+
+  def first_two_comments
+    [
+      comments[0],
+      comments[1]
+    ]
+  end
+
+end

data/spec/support/validator/usecases/hierarchy_validation.rb

@@ -0,0 +1,17 @@
+module HierarchyValidation
+
+  class Father < RestMyCase::Validator::Base
+
+    target :post
+
+    validates_presence_of :title
+
+  end
+
+  class Son < Father
+
+    validates_presence_of :email
+
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rest_my_case
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.7.0
 platform: ruby
 authors:
 - goncalvesjoao
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-16 00:00:00.000000000 Z
+date: 2015-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -112,25 +112,37 @@ files:
 - Rakefile
 - console
 - lib/rest_my_case.rb
+- lib/rest_my_case/accusation_attorneys/base.rb
+- lib/rest_my_case/accusation_attorneys/custom.rb
+- lib/rest_my_case/accusation_attorneys/each.rb
+- lib/rest_my_case/accusation_attorneys/helper_methods.rb
+- lib/rest_my_case/accusation_attorneys/presence.rb
 - lib/rest_my_case/base.rb
 - lib/rest_my_case/config/base.rb
 - lib/rest_my_case/config/general.rb
 - lib/rest_my_case/context/base.rb
 - lib/rest_my_case/defense_attorney/base.rb
 - lib/rest_my_case/errors.rb
+- lib/rest_my_case/helpers.rb
 - lib/rest_my_case/judge/base.rb
 - lib/rest_my_case/trial/case.rb
 - lib/rest_my_case/trial/court.rb
-- lib/rest_my_case/trial/defendant.rb
+- lib/rest_my_case/validator/base.rb
+- lib/rest_my_case/validator/class_methods.rb
+- lib/rest_my_case/validator/errors.rb
 - lib/rest_my_case/version.rb
 - rest_my_case.gemspec
 - spec/rest_my_case/base_spec.rb
 - spec/rest_my_case/defense_attorney/base_spec.rb
 - spec/rest_my_case/trial_case/court_spec.rb
+- spec/rest_my_case/validator/hierarchy_spec.rb
 - spec/spec_helper.rb
 - spec/support/defense_attorney.rb
 - spec/support/perform.rb
 - spec/support/rest_my_case_base.rb
+- spec/support/validator/models/ruby_post.rb
+- spec/support/validator/models/ruby_post_with_comments.rb
+- spec/support/validator/usecases/hierarchy_validation.rb
 homepage: https://github.com/goncalvesjoao/rest_my_case
 licenses:
 - MIT
@@ -159,7 +171,11 @@ test_files:
 - spec/rest_my_case/base_spec.rb
 - spec/rest_my_case/defense_attorney/base_spec.rb
 - spec/rest_my_case/trial_case/court_spec.rb
+- spec/rest_my_case/validator/hierarchy_spec.rb
 - spec/spec_helper.rb
 - spec/support/defense_attorney.rb
 - spec/support/perform.rb
 - spec/support/rest_my_case_base.rb
+- spec/support/validator/models/ruby_post.rb
+- spec/support/validator/models/ruby_post_with_comments.rb
+- spec/support/validator/usecases/hierarchy_validation.rb

data/lib/rest_my_case/trial/defendant.rb

@@ -1,7 +0,0 @@
-module RestMyCase
-  module Trial
-
-    Defendant = Struct.new(:use_case_classes)
-
-  end
-end