Module: ConditionatorHooks

Defined in:
lib/conditionator/hooks.rb

Defined Under Namespace

Modules: ClassLevelConditionator Classes: PreconditionsNotMet

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.included(base) ⇒ Object 



20
21
22
 
# File 'lib/conditionator/hooks.rb', line 20

def self.included(base)
  base.send :extend, ClassLevelConditionator
end

Instance Method Details

#failsafe_for(method) ⇒ Object 



34
35
36
 
# File 'lib/conditionator/hooks.rb', line 34

def failsafe_for method
  self.class.data[self.class.name][method][:pre][:failsafe]
end

#load_conditions ⇒ Object

Creates all methods needed for the hooks to take place.



39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
# File 'lib/conditionator/hooks.rb', line 39

def load_conditions

  _data = self.class.data
  _data[self.class.name] = {} if _data[self.class.name].nil?

  _data[self.class.name].each { |method, type|
    type.each { |_when, data|

      arr_methods = data[:methods]

      if !self.respond_to? "#{method}_with_#{_when}_cond".to_sym
        self.class.send :define_method, "#{method}_with_#{_when}_cond".to_sym do |*p|
          execute_method = true
          if(_when == :pre)
            returns = arr_methods.collect do |m| 
              self.send(m, *p) ? true : false
            end
            returns.uniq!

            #if one of the preconditions returned false, we act accordingly
            if returns.include? false
              execute_method = false
              if !data[:failsafe].nil? #if we had setup a failsafe method, we use that
                ret_value = self.send(data[:failsafe], *p) #if we execute the failsafe, that method will give us the returning value
              else #otherwise, we raise the exception if the dev didn't mute it
                raise PreconditionsNotMet if !data[:mute]
              end
            end
          end 
          if execute_method
            ret_value = self.send "#{method}_without_#{_when}_cond".to_sym, *p
          end
          if(_when == :post)
            arr_methods.each do |m| 
              self.send m, *p, ret_value 
            end
          end 
          return ret_value
        end
        self.class.send :alias_method, "#{method}_without_#{_when}_cond".to_sym, method
        self.class.send :alias_method, method, "#{method}_with_#{_when}_cond".to_sym
      end
    }
  }
end

#postconditions ⇒ Object 



30
31
32
 
# File 'lib/conditionator/hooks.rb', line 30

def postconditions
  conditions :post
end

#preconditions ⇒ Object

Returns a list of all preconditions, grouped by the method they’re a precondition to.



26
27
28
 
# File 'lib/conditionator/hooks.rb', line 26

def preconditions
  conditions :pre
end