rest_my_case 1.7.0 → 1.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4fbc100a76e2fe8ef3a5b546121c072662e41864
-  data.tar.gz: 335942040cc881c507bf65a3a437f50f1436c3b0
+  metadata.gz: 4686d3176a531d96c52e66d6b2b512746a102762
+  data.tar.gz: d1c4f92042481db02d456e7ffecc42f40d813557
 SHA512:
-  metadata.gz: 2872b4f50c0d422921083b393fda8d3d81010a7e7268985d966bcab5961aa5c398506af5494f2fd6889bcebeb551f2a3ecac4c09e74df57a3d4012914952254c
-  data.tar.gz: b464f45b1152e7916cc847d0b8c34e3e26a57ee0393b6b33896c831ce950e7f3b3ea4d65abba3e1ead99ee3d5c042bc0e341b0532698c147a87eeb0da8ad87df
+  metadata.gz: 308e0eb453f14fa551d35a41a8ea93a95211ef34497be4a101ac05b60a87fff2e5bf90063a5a8af05943c5e286310cad7a1696ca39b84dca5286ae020a696faa
+  data.tar.gz: c6eb0b3bc987c0b66e713ddffbdf6b831eec559bd678444d278be3551b5c0a41d9ca7eabaf85350ec0cd0c04fed7271077d3bd00ffa3d44757bda70e39d508d2

data/.rubocop.yml

@@ -19,7 +19,6 @@ AllCops:
     - 'tmp/**/*'
     - 'pkg/**/*'
     - 'lib/rest_my_case/accusation_attorneys/**/*'
-    - 'lib/rest_my_case/validator/errors.rb'
 
 Documentation:
   Enabled: false

data/lib/rest_my_case/{validator → accusation_attorneys}/errors.rb

@@ -1,5 +1,5 @@
 module RestMyCase
-  module Validator
+  module AccusationAttorneys
 
     class Errors
       include Enumerable

data/lib/rest_my_case/accusation_attorneys/format.rb

@@ -0,0 +1,60 @@
+module RestMyCase
+  module AccusationAttorneys
+
+    class Format < Each
+      def validate_each(record, attribute, value)
+        if options[:with]
+          regexp = option_call(record, :with)
+          record_error(record, attribute, :with, value) if value.to_s !~ regexp
+        elsif options[:without]
+          regexp = option_call(record, :without)
+          record_error(record, attribute, :without, value) if value.to_s =~ regexp
+        end
+      end
+
+      def check_validity!
+        unless options.include?(:with) ^ options.include?(:without)  # ^ == xor, or "exclusive or"
+          raise ArgumentError, "Either :with or :without must be supplied (but not both)"
+        end
+
+        check_options_validity(options, :with)
+        check_options_validity(options, :without)
+      end
+
+      private
+
+      def option_call(record, name)
+        option = options[name]
+        option.respond_to?(:call) ? option.call(record) : option
+      end
+
+      def record_error(record, attribute, name, value)
+        record.errors.add(attribute, :invalid, Helpers.except(options, name).merge!(value: value))
+      end
+
+      def regexp_using_multiline_anchors?(regexp)
+        regexp.source.start_with?("^") ||
+          (regexp.source.end_with?("$") && !regexp.source.end_with?("\\$"))
+      end
+
+      def check_options_validity(options, name)
+        option = options[name]
+        if option && !option.is_a?(Regexp) && !option.respond_to?(:call)
+          raise ArgumentError, "A regular expression or a proc or lambda must be supplied as :#{name}"
+        elsif option && option.is_a?(Regexp) &&
+              regexp_using_multiline_anchors?(option) && options[:multiline] != true
+          raise ArgumentError, "The provided regular expression is using multiline anchors (^ or $), " \
+          "which may present a security risk. Did you mean to use \\A and \\z, or forgot to add the " \
+          ":multiline => true option?"
+        end
+      end
+    end
+
+    module HelperMethods
+      def validates_format_of(*attr_names)
+        validates_with Format, _merge_attributes(attr_names)
+      end
+    end
+
+  end
+end

data/lib/rest_my_case/accusation_attorneys/length.rb

@@ -0,0 +1,82 @@
+module RestMyCase
+  module AccusationAttorneys
+
+    class Length < Each
+      MESSAGES  = { is: :wrong_length, minimum: :too_short, maximum: :too_long }.freeze
+      CHECKS    = { is: :==, minimum: :>=, maximum: :<= }.freeze
+
+      RESERVED_OPTIONS  = [:minimum, :maximum, :within, :is, :tokenizer, :too_short, :too_long]
+
+      def initialize(options)
+        if range = (options.delete(:in) || options.delete(:within))
+          raise ArgumentError, ":in and :within must be a Range" unless range.is_a?(Range)
+          options[:minimum], options[:maximum] = range.min, range.max
+        end
+
+        if options[:allow_blank] == false && options[:minimum].nil? && options[:is].nil?
+          options[:minimum] = 1
+        end
+
+        super
+      end
+
+      def check_validity!
+        keys = CHECKS.keys & options.keys
+
+        if keys.empty?
+          raise ArgumentError, 'Range unspecified. Specify the :in, :within, :maximum, :minimum, or :is option.'
+        end
+
+        keys.each do |key|
+          value = options[key]
+
+          unless (value.is_a?(Integer) && value >= 0) || value == Float::INFINITY
+            raise ArgumentError, ":#{key} must be a nonnegative Integer or Infinity"
+          end
+        end
+      end
+
+      def validate_each(record, attribute, value)
+        value = tokenize(value)
+        value_length = value.respond_to?(:length) ? value.length : value.to_s.length
+        errors_options = Helpers.except(options, *RESERVED_OPTIONS)
+
+        CHECKS.each do |key, validity_check|
+          next unless check_value = options[key]
+
+          if !value.nil? || skip_nil_check?(key)
+            next if value_length.send(validity_check, check_value)
+          end
+
+          errors_options[:count] = check_value
+
+          default_message = options[MESSAGES[key]]
+          errors_options[:message] ||= default_message if default_message
+
+          record.errors.add(attribute, MESSAGES[key], errors_options)
+        end
+      end
+
+      private
+
+      def tokenize(value)
+        if options[:tokenizer] && value.kind_of?(String)
+          options[:tokenizer].call(value)
+        end || value
+      end
+
+      def skip_nil_check?(key)
+        key == :maximum && options[:allow_nil].nil? && options[:allow_blank].nil?
+      end
+    end
+
+    module HelperMethods
+      def validates_length_of(*attr_names)
+        validates_with Length, _merge_attributes(attr_names)
+      end
+
+      alias_method :validates_size_of, :validates_length_of
+    end
+
+  end
+end

data/lib/rest_my_case/accusation_attorneys/numericality.rb

@@ -0,0 +1,90 @@
+module RestMyCase
+  module AccusationAttorneys
+
+    class Numericality < Each
+      CHECKS = { :greater_than => :>, :greater_than_or_equal_to => :>=,
+                 :equal_to => :==, :less_than => :<, :less_than_or_equal_to => :<=,
+                 :odd => :odd?, :even => :even? }.freeze
+
+      RESERVED_OPTIONS = CHECKS.keys + [:only_integer]
+
+      def check_validity!
+        keys = CHECKS.keys - [:odd, :even]
+
+        Helpers.slice(options, *keys).each do |option, value|
+          next if value.nil? || value.is_a?(Numeric) || value.is_a?(Proc) || value.is_a?(Symbol)
+          raise ArgumentError, ":#{option} must be a number, a symbol or a proc"
+        end
+      end
+
+      def validate_each(record, attr_name, value)
+        before_type_cast = "#{attr_name}_before_type_cast"
+
+        raw_value = record.send(before_type_cast) if record.respond_to?(before_type_cast.to_sym)
+        raw_value ||= value
+
+        return if options[:allow_nil] && raw_value.nil?
+
+        unless value = parse_raw_value_as_a_number(raw_value)
+          record.errors.add(attr_name, :not_a_number, filtered_options(raw_value))
+          return
+        end
+
+        if options[:only_integer]
+          unless value = parse_raw_value_as_an_integer(raw_value)
+            record.errors.add(attr_name, :not_an_integer, filtered_options(raw_value))
+            return
+          end
+        end
+
+        Helpers.slice(options, *CHECKS.keys).each do |option, option_value|
+          next if option_value.nil?
+
+          case option
+          when :odd, :even
+            unless value.to_i.send(CHECKS[option])
+              record.errors.add(attr_name, option, filtered_options(value))
+            end
+          else
+            option_value = option_value.call(record) if option_value.is_a?(Proc)
+            option_value = record.send(option_value) if option_value.is_a?(Symbol)
+
+            unless value.send(CHECKS[option], option_value)
+              record.errors.add(attr_name, option, filtered_options(value).merge(:count => option_value))
+            end
+          end
+        end
+      end
+
+      protected
+
+      def parse_raw_value_as_a_number(raw_value)
+        case raw_value
+        when /\A0[xX]/
+          nil
+        else
+          begin
+            Kernel.Float(raw_value)
+          rescue ArgumentError, TypeError
+            nil
+          end
+        end
+      end
+
+      def parse_raw_value_as_an_integer(raw_value)
+        raw_value.to_i if raw_value.to_s =~ /\A[+-]?\d+\Z/
+      end
+
+      def filtered_options(value)
+        Helpers.except(options, *RESERVED_OPTIONS).merge!(:value => value)
+      end
+    end
+
+    module HelperMethods
+      def validates_numericality_of(*attr_names)
+        validates_with Numericality, _merge_attributes(attr_names)
+      end
+    end
+
+  end
+end

data/lib/rest_my_case/config/base.rb

@@ -3,7 +3,8 @@ module RestMyCase
 
     module Base
 
-      attr_accessor :silence_dependencies_abort
+      attr_accessor :parent_dependencies_first,
+                    :silence_dependencies_abort
 
     end
 

data/lib/rest_my_case/config/general.rb

@@ -6,6 +6,7 @@ module RestMyCase
       include Base
 
       def initialize
+        @parent_dependencies_first  = false
         @silence_dependencies_abort = false
       end
 

data/lib/rest_my_case/defense_attorney/base.rb

@@ -4,36 +4,35 @@ module RestMyCase
     class Base
 
       def initialize(trial_case)
-        @trial_case = trial_case
+        @trial_case           = trial_case
+        @trial_case.use_cases = []
       end
 
       def build_case_for_the_defendant
-        @trial_case.use_cases =
-          @trial_case.use_case_classes.map do |use_case_class|
-            all_dependencies(use_case_class)
-          end.flatten
+        dependencies(@trial_case.defendant_class).map do |dependency|
+          gather_all_use_cases dependency, @trial_case.defendant
+        end
       end
 
       protected ######################## PROTECTED #############################
 
-      def all_dependencies(use_case_class)
-        return [] if use_case_class == @trial_case.last_ancestor
-
-        all_dependencies(use_case_class.superclass) |
-          dependencies_including_itself(use_case_class, @trial_case.defendant)
-      end
-
-      private ########################### PRIVATE ##############################
+      def gather_all_use_cases(use_case_class, dependent)
+        use_case = use_case_class.new(@trial_case.context, dependent)
 
-      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_class).map do |dependency|
+          gather_all_use_cases dependency, use_case
+        end
 
-        dependencies(use_case).push use_case
+        @trial_case.use_cases.push use_case
       end
 
-      def dependencies(use_case)
-        use_case.class.dependencies.map do |dependency|
-          dependencies_including_itself dependency, use_case
+      def dependencies(use_case_class)
+        return [] if use_case_class == @trial_case.last_ancestor
+
+        if RestMyCase.get_config :parent_dependencies_first, use_case_class
+          dependencies(use_case_class.superclass) | use_case_class.dependencies
+        else
+          use_case_class.dependencies | dependencies(use_case_class.superclass)
         end
       end
 

data/lib/rest_my_case/trial/case.rb

@@ -5,13 +5,13 @@ module RestMyCase
 
       attr_accessor :use_cases, :should_abort
 
-      attr_reader :context, :defendant, :last_ancestor, :use_case_classes
+      attr_reader :context, :defendant, :last_ancestor, :defendant_class
 
       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
+        @context         = build_context attributes
+        @last_ancestor   = last_ancestor
+        @defendant_class = build_defendant(last_ancestor, use_case_classes)
+        @defendant       = @defendant_class.new @context
       end
 
       def aborted
@@ -26,10 +26,8 @@ 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)
+      def build_defendant(last_ancestor, use_case_classes)
+        Class.new(last_ancestor) { depends(*use_case_classes) }
       end
 
     end

data/lib/rest_my_case/validator.rb

@@ -0,0 +1,144 @@
+module RestMyCase
+
+  class Validator < RestMyCase::Base
+
+    module ClassMethods
+
+      attr_writer :validators
+
+      attr_reader :clear_errors
+
+      def trial_court
+        @trial_court ||= Trial::Court.new \
+          Judge::Base, DefenseAttorney::Base, RestMyCase::Validator
+      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
+
+      # Copy validators on inheritance.
+      def inherited(base)
+        dup = validators.dup
+        base.validators = dup.each { |k, v| dup[k] = v.dup }
+        super
+      end
+
+    end
+
+    ######################## INSTANCE METHODS BELLOW ###########################
+
+    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 ||= AccusationAttorneys::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

data/lib/rest_my_case/version.rb

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

data/lib/rest_my_case.rb

@@ -11,20 +11,18 @@ require 'rest_my_case/judge/base'
 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/errors'
 # 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'
+require 'rest_my_case/base'
+require 'rest_my_case/validator'
 
 module RestMyCase
 

data/spec/rest_my_case/base_spec.rb

@@ -111,10 +111,10 @@ describe RestMyCase::Base do
       end
 
       it "context prove that only the correct method have ran" do
-        expect(@context.setup.length).to be 3
+        expect(@context.setup.length).to be 4
         expect(@context.perform.length).to be 0
         expect(@context.rollback.length).to be 0
-        expect(@context.final.length).to be 7
+        expect(@context.final.length).to be 12
       end
     end
 
@@ -133,10 +133,10 @@ describe RestMyCase::Base do
       end
 
       it "context prove that only the correct method have ran" do
-        expect(@context.setup.length).to be 2
+        expect(@context.setup.length).to be 3
         expect(@context.perform.length).to be 0
         expect(@context.rollback.length).to be 0
-        expect(@context.final.length).to be 7
+        expect(@context.final.length).to be 12
       end
     end
 
@@ -151,10 +151,10 @@ describe RestMyCase::Base do
       end
 
       it "context prove that only the correct method have ran" do
-        expect(@context.setup.length).to be 2
+        expect(@context.setup.length).to be 3
         expect(@context.perform.length).to be 0
         expect(@context.rollback.length).to be 0
-        expect(@context.final.length).to be 7
+        expect(@context.final.length).to be 12
       end
     end
 
@@ -169,10 +169,10 @@ describe RestMyCase::Base do
       end
 
       it "context prove that only the correct method have ran" do
-        expect(@context.setup.length).to be 7
-        expect(@context.perform.length).to be 2
-        expect(@context.rollback.length).to be 3
-        expect(@context.final.length).to be 7
+        expect(@context.setup.length).to be 12
+        expect(@context.perform.length).to be 3
+        expect(@context.rollback.length).to be 4
+        expect(@context.final.length).to be 12
       end
     end
 
@@ -187,10 +187,10 @@ describe RestMyCase::Base do
       end
 
       it "context prove that only the correct method have ran" do
-        expect(@context.setup.length).to be 7
-        expect(@context.perform.length).to be 6
+        expect(@context.setup.length).to be 12
+        expect(@context.perform.length).to be 11
         expect(@context.rollback.length).to be 0
-        expect(@context.final.length).to be 7
+        expect(@context.final.length).to be 12
       end
     end
 
@@ -206,10 +206,10 @@ describe RestMyCase::Base do
       end
 
       it "context prove that only the correct method have ran" do
-        expect(@context.setup.length).to be 6
-        expect(@context.perform.length).to be 6
+        expect(@context.setup.length).to be 11
+        expect(@context.perform.length).to be 11
         expect(@context.rollback.length).to be 0
-        expect(@context.final.length).to be 7
+        expect(@context.final.length).to be 12
       end
 
     end
@@ -234,10 +234,10 @@ describe RestMyCase::Base do
         end
 
         it "context prove that only the correct method have ran" do
-          expect(@context.setup.length).to be 5
+          expect(@context.setup.length).to be 8
           expect(@context.perform.length).to be 0
           expect(@context.rollback.length).to be 0
-          expect(@context.final.length).to be 7
+          expect(@context.final.length).to be 12
         end
 
       end
@@ -258,10 +258,10 @@ describe RestMyCase::Base do
         end
 
         it "context prove that only the correct method have ran" do
-          expect(@context.setup.length).to be 7
-          expect(@context.perform.length).to be 5
-          expect(@context.rollback.length).to be 5
-          expect(@context.final.length).to be 7
+          expect(@context.setup.length).to be 12
+          expect(@context.perform.length).to be 8
+          expect(@context.rollback.length).to be 8
+          expect(@context.final.length).to be 12
         end
 
       end
@@ -293,10 +293,10 @@ describe RestMyCase::Base do
         end
 
         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.setup.length).to be 12
+          expect(@context.perform.length).to be 12
           expect(@context.rollback.length).to be 0
-          expect(@context.final.length).to be 7
+          expect(@context.final.length).to be 12
         end
 
       end
@@ -340,40 +340,46 @@ describe RestMyCase::Base do
         @context = Perform::ScreammingInvoker.perform
 
         expect(@context.setup).to eq [
-          "Perform::UseCaseWrapper",
+          "Perform::Logger",
           "Perform::ScreammingInvoker",
-          "Perform::UseCaseWrapper",
+          "Perform::Logger",
           "Perform::BuildPost",
-          "Perform::UseCaseWrapper",
+          "Perform::Logger",
           "Perform::ValidateName",
+          "Perform::Logger",
           "Perform::ValidateBody",
+          "Perform::Logger",
           "Perform::Validations",
-          "Perform::UseCaseWrapper",
+          "Perform::Logger",
           "Perform::SavePost"
         ]
         expect(@context.perform).to eq [
-          "Perform::UseCaseWrapper",
+          "Perform::Logger",
           "Perform::ScreammingInvoker",
-          "Perform::UseCaseWrapper",
+          "Perform::Logger",
           "Perform::BuildPost",
-          "Perform::UseCaseWrapper",
+          "Perform::Logger",
           "Perform::ValidateName",
+          "Perform::Logger",
           "Perform::ValidateBody",
+          "Perform::Logger",
           "Perform::Validations",
-          "Perform::UseCaseWrapper",
+          "Perform::Logger",
           "Perform::SavePost"
         ]
         expect(@context.rollback).to eq []
         expect(@context.final).to eq [
-          "Perform::UseCaseWrapper",
+          "Perform::Logger",
           "Perform::BuildPost",
-          "Perform::UseCaseWrapper",
+          "Perform::Logger",
           "Perform::ValidateName",
+          "Perform::Logger",
           "Perform::ValidateBody",
+          "Perform::Logger",
           "Perform::Validations",
-          "Perform::UseCaseWrapper",
+          "Perform::Logger",
           "Perform::SavePost",
-          "Perform::UseCaseWrapper",
+          "Perform::Logger",
           "Perform::ScreammingInvoker"
         ]
       end
@@ -401,39 +407,47 @@ describe RestMyCase::Base do
 
       it "invoker should abort the process it his invokees have also aborted" do
         expect(@context.setup).to eq [
-          "Perform::UseCaseWrapper",
+          "Perform::Logger",
           "Perform::BuildPost",
+          "Perform::Logger",
           "Perform::Validations2",
+          "Perform::Logger",
           "Perform::SavePost",
+          "Perform::Logger",
           "Perform::CreatePost2",
-          "Perform::UseCaseWrapper",
+          "Perform::Logger",
           "Perform::ValidateName",
-          "Perform::UseCaseWrapper",
+          "Perform::Logger",
           "Perform::ValidateBody"
         ]
         expect(@context.perform).to eq [
-          "Perform::UseCaseWrapper",
+          "Perform::Logger",
           "Perform::BuildPost",
+          "Perform::Logger",
           "Perform::Validations2",
-          "Perform::UseCaseWrapper",
+          "Perform::Logger",
           "Perform::ValidateName"
         ]
         expect(@context.rollback).to eq [
           "Perform::ValidateName",
-          "Perform::UseCaseWrapper",
+          "Perform::Logger",
           "Perform::Validations2",
+          "Perform::Logger",
           "Perform::BuildPost",
-          "Perform::UseCaseWrapper"
+          "Perform::Logger"
         ]
         expect(@context.final).to eq [
-          "Perform::UseCaseWrapper",
+          "Perform::Logger",
           "Perform::ValidateName",
-          "Perform::UseCaseWrapper",
+          "Perform::Logger",
           "Perform::ValidateBody",
-          "Perform::UseCaseWrapper",
+          "Perform::Logger",
           "Perform::BuildPost",
+          "Perform::Logger",
           "Perform::Validations2",
+          "Perform::Logger",
           "Perform::SavePost",
+          "Perform::Logger",
           "Perform::CreatePost2"
         ]
       end

data/spec/rest_my_case/defense_attorney/base_spec.rb

@@ -48,21 +48,83 @@ describe RestMyCase::DefenseAttorney::Base do
     let(:use_case_classes) { [DefenseAttorney::CreatePostWithComments] }
 
     it_behaves_like "a porper shepherd", [
+      DefenseAttorney::BuildComments,
+      DefenseAttorney::SaveComments,
+      DefenseAttorney::CreateComments,
+      DefenseAttorney::AssignAttributes,
+      DefenseAttorney::BuildSomething,
+      DefenseAttorney::BuildPost,
+      DefenseAttorney::SavePost,
       DefenseAttorney::BuilEvent,
       DefenseAttorney::SaveEvent,
       DefenseAttorney::CreateEvent,
       DefenseAttorney::LogEvents,
       DefenseAttorney::AnalyseEvents,
-      DefenseAttorney::UseCaseWrapper,
-      DefenseAttorney::BuildPost,
-      DefenseAttorney::SavePost,
-      DefenseAttorney::CreatePost,
-      DefenseAttorney::BuildComments,
-      DefenseAttorney::SaveComments,
-      DefenseAttorney::CreateComments,
       DefenseAttorney::CreatePostWithComments
     ]
 
   end
 
+  context "When general config has parent_dependencies_first = true" do
+
+    before do
+      RestMyCase.configure do |config|
+        config.parent_dependencies_first = true
+      end
+    end
+    after { RestMyCase.reset_config }
+
+    context "When a use case inherits from another that also has dependencies" do
+
+      let(:use_case_classes) { [DefenseAttorney::CreatePostWithComments] }
+
+      it_behaves_like "a porper shepherd", [
+        DefenseAttorney::BuilEvent,
+        DefenseAttorney::SaveEvent,
+        DefenseAttorney::CreateEvent,
+        DefenseAttorney::LogEvents,
+        DefenseAttorney::AnalyseEvents,
+        DefenseAttorney::BuildSomething,
+        DefenseAttorney::AssignAttributes,
+        DefenseAttorney::BuildPost,
+        DefenseAttorney::SavePost,
+        DefenseAttorney::BuildComments,
+        DefenseAttorney::SaveComments,
+        DefenseAttorney::CreateComments,
+        DefenseAttorney::CreatePostWithComments
+      ]
+
+    end
+
+  end
+
+  context "When dependent use_case has parent_dependencies_first = true" do
+
+    before { DefenseAttorney::BuildPost.parent_dependencies_first = true }
+    after  { DefenseAttorney::BuildPost.parent_dependencies_first = nil }
+
+    context "When a use case inherits from another that also has dependencies" do
+
+      let(:use_case_classes) { [DefenseAttorney::CreatePostWithComments] }
+
+      it_behaves_like "a porper shepherd", [
+        DefenseAttorney::BuildComments,
+        DefenseAttorney::SaveComments,
+        DefenseAttorney::CreateComments,
+        DefenseAttorney::BuildSomething,
+        DefenseAttorney::AssignAttributes,
+        DefenseAttorney::BuildPost,
+        DefenseAttorney::SavePost,
+        DefenseAttorney::BuilEvent,
+        DefenseAttorney::SaveEvent,
+        DefenseAttorney::CreateEvent,
+        DefenseAttorney::LogEvents,
+        DefenseAttorney::AnalyseEvents,
+        DefenseAttorney::CreatePostWithComments
+      ]
+
+    end
+
+  end
+
 end

data/spec/support/defense_attorney.rb

@@ -14,7 +14,17 @@ module DefenseAttorney
 
   class AnalyseEvents < RestMyCase::Base; end
 
-  class BuildPost < RestMyCase::Base; end
+  class BuildSomething < RestMyCase::Base; end
+
+  class AssignAttributes < RestMyCase::Base; end
+
+  class Builder < RestMyCase::Base
+    depends BuildSomething
+  end
+
+  class BuildPost < Builder
+    depends AssignAttributes
+  end
 
   class SavePost < RestMyCase::Base; end
 

data/spec/support/perform.rb

@@ -1,6 +1,6 @@
 module Perform
 
-  class UseCaseWrapper < RestMyCase::Base
+  class Test < RestMyCase::Base
     def flow_control(method)
       id = "#{self.class.name}_#{method}"
 
@@ -42,6 +42,12 @@ module Perform
     end
   end
 
+  class Logger < Test; end
+
+  class UseCaseWrapper < Test
+    depends Logger
+  end
+
   class ValidateName < UseCaseWrapper; end
 
   class ValidateBody < UseCaseWrapper; end

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

@@ -1,6 +1,6 @@
 module HierarchyValidation
 
-  class Father < RestMyCase::Validator::Base
+  class Father < RestMyCase::Validator
 
     target :post
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rest_my_case
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.7.4
 platform: ruby
 authors:
 - goncalvesjoao
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-17 00:00:00.000000000 Z
+date: 2015-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -115,7 +115,11 @@ files:
 - 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/errors.rb
+- lib/rest_my_case/accusation_attorneys/format.rb
 - lib/rest_my_case/accusation_attorneys/helper_methods.rb
+- lib/rest_my_case/accusation_attorneys/length.rb
+- lib/rest_my_case/accusation_attorneys/numericality.rb
 - lib/rest_my_case/accusation_attorneys/presence.rb
 - lib/rest_my_case/base.rb
 - lib/rest_my_case/config/base.rb
@@ -127,9 +131,7 @@ files:
 - 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/validator/base.rb
-- lib/rest_my_case/validator/class_methods.rb
-- lib/rest_my_case/validator/errors.rb
+- lib/rest_my_case/validator.rb
 - lib/rest_my_case/version.rb
 - rest_my_case.gemspec
 - spec/rest_my_case/base_spec.rb

data/lib/rest_my_case/validator/base.rb

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

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