lib/atp/runner.rb in atp-0.8.0 vs lib/atp/runner.rb in atp-1.0.0

@@ -4,12 +4,12 @@
   # A subset of the input AST will be returned containing only the nodes that would
   # be hit when the flow is executed under the given conditions.
   class Runner < Processor
     def run(node, options = {})
       options = {
-        evaluate_flow_flags: true,
-        evaluate_run_flags:  true,
+        evaluate_enables:    true,
+        evaluate_flags:      true,
         evaluate_set_result: true
       }.merge(options)
       @options = options
       @completed = false
       @groups = []
@@ -29,57 +29,65 @@
 
     def on_name(node)
       container << node
     end
 
-    def on_flow_flag(node)
-      if @options[:evaluate_flow_flags]
-        flag, enabled, *nodes = *node
+    def on_if_flag(node)
+      if @options[:evaluate_flags]
+        flag, *nodes = *node
         flag = [flag].flatten
-        active = flag.any? { |f| flow_flags.include?(f) }
+        enabled = node.type == :if_flag
+        active = flag.any? { |f| set_flags.include?(f) }
         if (enabled && active) || (!enabled && !active)
           process_all(nodes)
         end
       else
         c = open_container do
           process_all(node.children)
         end
-        container << node.updated(nil, node.children.take(2) + c)
+        container << node.updated(nil, node.children.take(1) + c)
       end
     end
+    alias_method :on_unless_flag, :on_if_flag
 
-    def on_run_flag(node)
-      if @options[:evaluate_run_flags]
-        flag, enabled, *nodes = *node
+    def on_if_enabled(node)
+      if @options[:evaluate_enables]
+        flag, *nodes = *node
         flag = [flag].flatten
-        active = flag.any? { |f| run_flags.include?(f) }
+        enabled = node.type == :if_enabled
+        active = flag.any? { |f| set_enables.include?(f) }
         if (enabled && active) || (!enabled && !active)
           process_all(nodes)
         end
       else
         c = open_container do
           process_all(node.children)
         end
-        container << node.updated(nil, node.children.take(2) + c)
+        container << node.updated(nil, node.children.take(1) + c)
       end
     end
+    alias_method :on_unless_enabled, :on_if_enabled
 
-    # Not sure why this method is here, all test_result nodes should have been
-    # converted to run_flag nodes by now
-    def on_test_result(node)
-      id, passed, *nodes = *node
-      if (passed && !failed_test_ids.include?(id)) ||
-         (!passed && failed_test_ids.include?(id))
+    def on_if_failed(node)
+      id, *nodes = *node
+      if failed_test_ids.include?(id)
         process_all(nodes)
       end
     end
 
+    def on_if_passed(node)
+      id, *nodes = *node
+      unless failed_test_ids.include?(id)
+        process_all(nodes)
+      end
+    end
+
     def on_test(node)
       if id = node.find(:id)
         id = id.to_a[0]
         if failed_test_ids.include?(id)
-          node = node.add(n0(:failed))
+          node = node.add(node.updated(:failed, []))
           failed = true
           if n_on_fail = node.find(:on_fail)
             node = node.remove(n_on_fail)
           end
         end
@@ -153,39 +161,41 @@
         container << node unless completed?
         @completed = true if @options[:evaluate_set_result]
       end
     end
 
-    def on_set_run_flag(node)
-      run_flags << node.to_a[0]
+    def on_set_flag(node)
+      set_flags << node.to_a[0]
     end
 
-    def on_enable_flow_flag(node)
-      flow_flags << node.value unless flow_flags.include?(node.value)
+    def on_enable(node)
+      set_enables << node.value unless set_enables.include?(node.value)
     end
 
-    def on_disable_flow_flag(node)
-      flow_flags.delete(node.value)
+    def on_disable(node)
+      set_enables.delete(node.value)
     end
 
     def on_log(node)
       container << node unless completed?
     end
     alias_method :on_render, :on_log
 
-    def on_job(node)
-      jobs, state, *nodes = *node
+    def on_if_job(node)
+      jobs, *nodes = *node
       jobs = clean_job(jobs)
+      state = node.type == :if_job
       unless job
         fail 'Flow contains JOB-based conditions and no current JOB has been given!'
       end
       if state
         process_all(node) if jobs.include?(job)
       else
         process_all(node) unless jobs.include?(job)
       end
     end
+    alias_method :on_unless_job, :on_if_job
 
     def clean_job(job)
       [job].flatten.map { |j| j.to_s.upcase }
     end
 
@@ -195,16 +205,16 @@
 
     def failed_test_ids
       @failed_test_ids ||= [@options[:failed_test_id] || @options[:failed_test_ids]].flatten.compact
     end
 
-    def run_flags
-      @run_flags ||= []
+    def set_flags
+      @set_flags ||= []
     end
 
     # Returns an array of enabled flow flags
-    def flow_flags
-      @flow_flags ||= [@options[:flow_flag] || @options[:flow_flags]].flatten.compact
+    def set_enables
+      @set_enables ||= [@options[:enable] || @options[:enables]].flatten.compact
     end
 
     def completed?
       @completed
     end