atp 0.8.0 → 1.0.0

data/lib/atp/processors/extract_set_flags.rb

@@ -0,0 +1,18 @@
+module ATP
+  module Processors
+    # Extracts all flags which are set within the given flow, returning
+    # them in an array
+    class ExtractSetFlags < ATP::Processor
+      def run(nodes)
+        @results = []
+        process_all(nodes)
+        @results.uniq
+      end
+
+      def on_set_flag(node)
+        flag = node.value
+        @results << flag
+      end
+    end
+  end
+end

data/lib/atp/processors/flag_optimizer.rb

@@ -0,0 +1,214 @@
+module ATP
+  module Processors
+    # This processor eliminates the use of run flags between adjacent tests:
+    #
+    #   s(:flow,
+    #     s(:name, "prb1"),
+    #     s(:test,
+    #       s(:name, "test1"),
+    #       s(:id, "t1"),
+    #       s(:on_fail,
+    #         s(:set_flag, "t1_FAILED", "auto_generated"),
+    #         s(:continue))),
+    #     s(:if_flag, "t1_FAILED",
+    #       s(:test,
+    #         s(:name, "test2"))))
+    #
+    #
+    #   s(:flow,
+    #     s(:name, "prb1"),
+    #     s(:test,
+    #       s(:name, "test1"),
+    #       s(:id, "t1"),
+    #       s(:on_fail,
+    #         s(:test,
+    #           s(:name, "test2")))))
+    #
+    class FlagOptimizer < Processor
+      attr_reader :run_flag_table
+
+      class ExtractRunFlagTable < Processor
+        # Hash table of run_flag name with number of times used
+        attr_reader :run_flag_table
+
+        # Reset hash table
+        def initialize
+          @run_flag_table = {}.with_indifferent_access
+        end
+
+        # For run_flag nodes, increment # of occurrences for specified flag
+        def on_if_flag(node)
+          children = node.children.dup
+          names = children.shift
+          state = node.type == :if_flag
+          Array(names).each do |name|
+            if @run_flag_table[name.to_sym].nil?
+              @run_flag_table[name.to_sym] = 1
+            else
+              @run_flag_table[name.to_sym] += 1
+            end
+          end
+          process_all(node.children)
+        end
+        alias_method :on_unless_flag, :on_if_flag
+      end
+
+      def run(node)
+        # Pre-process the AST for # of occurrences of each run-flag used
+        t = ExtractRunFlagTable.new
+        t.process(node)
+        @run_flag_table = t.run_flag_table
+        extract_volatiles(node)
+        process(node)
+      end
+
+      def on_named_collection(node)
+        name, *nodes = *node
+        node.updated(nil, [name] + optimize(process_all(nodes)))
+      end
+      alias_method :on_flow, :on_named_collection
+      alias_method :on_group, :on_named_collection
+      alias_method :on_unless_flag, :on_named_collection
+
+      def on_if_flag(node)
+        name, *nodes = *node
+        # Remove this node and return its children if required
+        if if_run_flag_to_remove.last == node.to_a[0]
+          node.updated(:inline, node.to_a[1..-1])
+        else
+          node.updated(nil, [name] + optimize(process_all(nodes)))
+        end
+      end
+
+      def on_on_fail(node)
+        if to_inline = nodes_to_inline_on_pass_or_fail.last
+          # If this node sets the flag that gates the node to be inlined
+          set_flag = node.find(:set_flag)
+          if set_flag && gated_by_set?(set_flag.to_a[0], to_inline)
+            # Remove the sub-node that sets the flag if there are no further references to it
+
+            if @run_flag_table[set_flag.to_a[0]] == 1 || !@run_flag_table[set_flag.to_a[0]]
+              node = node.updated(nil, node.children - [set_flag])
+            end
+
+            # And append the content of the node to be in_lined at the end of this on pass/fail node
+            append = reorder_nested_run_flags(set_flag.to_a[0], to_inline).to_a[1..-1]
+
+            # Belt and braces approach to make sure this node to be inlined does
+            # not get picked up anywhere else
+            nodes_to_inline_on_pass_or_fail.pop
+            nodes_to_inline_on_pass_or_fail << nil
+          end
+        end
+        node.updated(nil, optimize(process_all(node.children + Array(append))))
+      end
+      alias_method :on_on_pass, :on_on_fail
+
+      def optimize(nodes)
+        results = []
+        node1 = nil
+        nodes.each do |node2|
+          if node1
+            if can_be_combined?(node1, node2)
+              node1 = combine(node1, node2)
+            else
+              results << node1
+              node1 = node2
+            end
+          else
+            node1 = node2
+          end
+        end
+        results << node1 if node1
+        results
+      end
+
+      def can_be_combined?(node1, node2)
+        if node1.type == :test && (node2.type == :if_flag || node2.type == :unless_flag)
+          if node1.find_all(:on_fail, :on_pass).any? do |node|
+            if n = node.find(:set_flag)
+              # Inline instead of setting a flag if...
+              gated_by_set?(n.to_a[0], node2) && # The flag set by node1 is gating node2
+              n.to_a[1] == 'auto_generated' && # The flag has been generated and not specified by the user
+              n.to_a[0] !~ /_RAN$/ && # And don't compress RAN flags because they can be set by both on_fail and on_pass
+              !volatile?(n.to_a[0]) # And make sure the flag has not been marked as volatile
+            end
+          end
+            return true
+          end
+        end
+        false
+      end
+
+      def combine(node1, node2)
+        nodes_to_inline_on_pass_or_fail << node2
+        node1 = node1.updated(nil, process_all(node1.children))
+        nodes_to_inline_on_pass_or_fail.pop
+        node1
+      end
+
+      # node will always be an if_flag or unless_flag type node, guaranteed by the caller
+      #
+      # Returns true if flag matches the one supplied
+      #
+      #   s(:if_flag, flag,
+      #     s(:test, ...
+      #
+      # Also returns true if flag matches the one supplied, but it is nested within other flag conditions:
+      #
+      #   s(:unless_flag, other_flag,
+      #     s(:if_flag, other_flag2,
+      #       s(:if_flag, flag,
+      #         s(:test, ...
+      def gated_by_set?(flag, node)
+        (flag == node.to_a[0] && node.type == :if_flag) ||
+          (node.to_a.size == 2 && (node.to_a.last.type == :if_flag || node.to_a.last.type == :unless_flag) && gated_by_set?(flag, node.to_a.last))
+      end
+
+      # Returns the node with the run_flag clauses re-ordered to have the given flag of interest at the top.
+      #
+      # The caller guarantees the run_flag clause containing the given flag is present.
+      #
+      # For example, given this node:
+      #
+      #   s(:unless_flag, "flag1",
+      #     s(:if_flag, "ot_BEA7F3B_FAILED",
+      #       s(:test,
+      #         s(:object, <TestSuite: inner_test1_BEA7F3B>),
+      #         s(:name, "inner_test1_BEA7F3B"),
+      #         s(:number, 0),
+      #         s(:id, "it1_BEA7F3B"),
+      #         s(:on_fail,
+      #           s(:render, "multi_bin;")))))
+      #
+      # Then this node would be returned when the flag of interest is ot_BEA7F3B_FAILED:
+      #
+      #   s(:if_flag, "ot_BEA7F3B_FAILED",
+      #     s(:unless_flag, "flag1",
+      #       s(:test,
+      #         s(:object, <TestSuite: inner_test1_BEA7F3B>),
+      #         s(:name, "inner_test1_BEA7F3B"),
+      #         s(:number, 0),
+      #         s(:id, "it1_BEA7F3B"),
+      #         s(:on_fail,
+      #           s(:render, "multi_bin;")))))
+      def reorder_nested_run_flags(flag, node)
+        # If the run_flag we care about is already at the top, just return node
+        unless node.to_a[0] == flag && node.type == :if_flag
+          if_run_flag_to_remove << flag
+          node = node.updated(:if_flag, [flag] + [process(node)])
+          if_run_flag_to_remove.pop
+        end
+        node
+      end
+
+      def if_run_flag_to_remove
+        @if_run_flag_to_remove ||= []
+      end
+
+      def nodes_to_inline_on_pass_or_fail
+        @nodes_to_inline_on_pass_or_fail ||= []
+      end
+    end
+  end
+end

data/lib/atp/processors/flattener.rb

@@ -0,0 +1,58 @@
+module ATP
+  module Processors
+    # Gives every node their own individual wrapping of condition nodes. No attempt is made
+    # to identify or remove duplicate conditions in the wrapping, that will be done later by
+    # the RedundantConditionRemover.
+    class Flattener < Processor
+      def run(node)
+        @results = [[]]
+        @conditions = []
+        process(node)
+        node.updated(:flow, results)
+      end
+
+      def on_flow(node)
+        process_all(node.children)
+      end
+
+      # Handles the top-level flow nodes
+      def on_volatile(node)
+        results << node
+      end
+      alias_method :on_name, :on_volatile
+      alias_method :on_id, :on_volatile
+
+      def on_group(node)
+        @results << []
+        process_all(node.children)
+        nodes = @results.pop
+        results << node.updated(nil, nodes)
+      end
+
+      def on_condition_node(node)
+        flag, *nodes = *node
+        @conditions << node.updated(node.type, [flag])
+        process_all(nodes)
+        @conditions.pop
+      end
+      ATP::Flow::CONDITION_NODE_TYPES.each do |type|
+        alias_method "on_#{type}", :on_condition_node unless method_defined?("on_#{type}")
+      end
+
+      def handler_missing(node)
+        results << wrap_with_current_conditions(node)
+      end
+
+      def wrap_with_current_conditions(node)
+        @conditions.reverse_each do |condition|
+          node = condition.updated(nil, condition.children + [node])
+        end
+        node
+      end
+
+      def results
+        @results.last
+      end
+    end
+  end
+end

data/lib/atp/processors/flow_id.rb

@@ -17,8 +17,8 @@ module ATP
         end
       end
 
-      def on_test_result(node)
-        tid, state, nodes = *node
+      def on_if_failed(node)
+        tid, *nodes = *node
         if tid.is_a?(Array)
           tid = tid.map do |tid|
             if tid =~ /^extern/
@@ -32,9 +32,15 @@ module ATP
             tid = "#{tid}_#{id}"
           end
         end
-        node.updated(nil, [tid, state] + [process(nodes)])
+        node.updated(nil, [tid] + process_all(nodes))
       end
-      alias_method :on_test_executed, :on_test_result
+      alias_method :on_if_any_failed, :on_if_failed
+      alias_method :on_if_all_failed, :on_if_failed
+      alias_method :on_if_passed, :on_if_failed
+      alias_method :on_if_any_passed, :on_if_failed
+      alias_method :on_if_all_passed, :on_if_failed
+      alias_method :on_if_ran, :on_if_failed
+      alias_method :on_unless_ran, :on_if_failed
     end
   end
 end

data/lib/atp/processors/on_pass_fail_remover.rb

@@ -0,0 +1,39 @@
+module ATP
+  module Processors
+    # Removes most things from embedded on_pass/fail nodes and converts them to the equivalent
+    # on_passed/failed condition at the same level as the parent node
+    class OnPassFailRemover < Processor
+      def run(node)
+        process(node)
+      end
+
+      def on_test(node)
+        on_pass = node.find(:on_pass)
+        on_fail = node.find(:on_fail)
+        if on_pass || on_fail
+          id = node.find(:id)
+          unless id
+            fail 'Something has gone wrong, all nodes should have IDs by this point'
+          end
+          id = id.value
+          nodes = [node]
+          if on_fail && contains_anything_interesting?(on_fail)
+            nodes << node.updated(:if_failed, [id] + on_fail.children)
+            nodes[0] = nodes[0].remove(on_fail)
+          end
+          if on_pass && contains_anything_interesting?(on_pass)
+            nodes << node.updated(:if_passed, [id] + on_pass.children)
+            nodes[0] = nodes[0].remove(on_pass)
+          end
+          node.updated(:inline, nodes)
+        else
+          node.updated(nil, process_all(node.children))
+        end
+      end
+
+      def contains_anything_interesting?(node)
+        node.children.any? { |n| n.type != :set_result && n.type != :continue && n.type != :set_flag }
+      end
+    end
+  end
+end

data/lib/atp/processors/one_flag_per_test.rb

@@ -0,0 +1,79 @@
+module ATP
+  module Processors
+    # Ensures that all test nodes only ever set a flag once
+    class OneFlagPerTest < Processor
+      def run(node)
+        @build_table = true
+        @pass_table = {}
+        @fail_table = {}
+        process(node)
+        @counters = {}
+        @pass_table.each { |f, v| @counters[f] = 0 }
+        @fail_table.each { |f, v| @counters[f] = 0 }
+        @build_table = false
+        process(node)
+      end
+
+      def on_test(node)
+        on_pass = node.find(:on_pass)
+        on_fail = node.find(:on_fail)
+        if @build_table
+          if on_fail
+            on_fail.find_all(:set_flag).each do |n|
+              @fail_table[n.to_a[0]] ||= 0
+              @fail_table[n.to_a[0]] += 1
+            end
+          end
+          if on_pass
+            on_pass.find_all(:set_flag).each do |n|
+              @pass_table[n.to_a[0]] ||= 0
+              @pass_table[n.to_a[0]] += 1
+            end
+          end
+        else
+          to_be_set = {}
+          if on_fail
+            node = node.remove(on_fail)
+            on_fail.find_all(:set_flag).each do |set_flag|
+              old_flag = set_flag.to_a[0]
+              if @fail_table[old_flag] > 1
+                on_fail = on_fail.remove(set_flag)
+                new_flag = "#{old_flag}_#{@counters[old_flag]}"
+                @counters[old_flag] += 1
+                to_be_set[old_flag] = new_flag
+                c = set_flag.children.dup
+                c[0] = new_flag
+                set_flag = set_flag.updated(nil, c)
+                on_fail = on_fail.updated(nil, on_fail.children + [set_flag])
+              end
+            end
+            node = node.updated(nil, node.children + [on_fail])
+          end
+          if on_pass
+            node = node.remove(on_pass)
+            on_pass.find_all(:set_flag).each do |set_flag|
+              old_flag = set_flag.to_a[0]
+              if @pass_table[old_flag] > 1
+                on_pass = on_pass.remove(set_flag)
+                new_flag = "#{old_flag}_#{@counters[old_flag]}"
+                @counters[old_flag] += 1
+                to_be_set[old_flag] = new_flag
+                c = set_flag.children.dup
+                c[0] = new_flag
+                set_flag = set_flag.updated(nil, c)
+                on_pass = on_pass.updated(nil, on_pass.children + [set_flag])
+              end
+            end
+            node = node.updated(nil, node.children + [on_pass])
+          end
+          if to_be_set.empty?
+            node
+          else
+            nodes = to_be_set.map { |old, new| node.updated(:if_flag, [new, node.updated(:set_flag, [old, 'auto_generated'])]) }
+            node.updated(:inline, [node] + nodes)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/atp/processors/pre_cleaner.rb

@@ -1,8 +1,8 @@
 module ATP
   module Processors
     # Modifies the AST by performing some basic clean up, mainly to sanitize
-    # user input. For example it will ensure that all IDs are symbols, and that
-    # all names are lower-cased strings.
+    # user input. For example it will ensure that all IDs and references are underscored
+    # and lower cased.
     class PreCleaner < Processor
       def initialize
         @group_ids = []
@@ -15,12 +15,17 @@ module ATP
       end
 
       # Make all ID references use the lower case symbols
-      def on_test_executed(node)
-        children = node.children.dup
-        children[0] = clean(children[0])
-        node.updated(nil, process_all(children))
+      def on_if_failed(node)
+        id, *children = *node
+        node.updated(nil, [clean(id)] + process_all(children))
       end
-      alias_method :on_test_result, :on_test_executed
+      alias_method :on_if_passed, :on_if_failed
+      alias_method :on_if_any_failed, :on_if_failed
+      alias_method :on_if_all_failed, :on_if_failed
+      alias_method :on_if_any_passed, :on_if_failed
+      alias_method :on_if_all_passed, :on_if_failed
+      alias_method :on_if_ran, :on_if_failed
+      alias_method :on_unless_ran, :on_if_failed
 
       def on_group(node)
         if id = node.children.find { |n| n.type == :id }
@@ -51,7 +56,7 @@ module ATP
         if id.is_a?(Array)
           id.map { |i| clean(i) }
         else
-          id.to_s.downcase.to_sym
+          id.to_s.symbolize.to_s
         end
       end
     end