atp 0.3.3 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d20477f1e1e9f17a369fd66bab80a6d281ba14aa
-  data.tar.gz: a1e3578e7ce467f355d3d977a8892dba404602bb
+  metadata.gz: 7f64914b7c8843db8db3ad65544769c34244a2be
+  data.tar.gz: 69ad71f98a175f843a851863d00937aa93c6d52a
 SHA512:
-  metadata.gz: 24ef6ffa11c6694d9d35c9919c824dab356a60626d44e5ea24fc66eab5838c169407bd0d15d3903830a1ceee49a26f5962eedda59da0cd3e0399367e3ed9f5f2
-  data.tar.gz: 2eb38eebf9358bb09fd17b1f08e67aecf30a1d21f3831bc06361e0bd81f942aedaa7e9e23a0c1523954ae989bc8d858b0186d3eb0957561b662137fcef6bed7e
+  metadata.gz: 22d183c262e97d8218ebd96db88c0c2b5a5b3dc1131240243e56e729ba358b08730fdce8db67b116ecc1a8e21934806cf8bbda95339a5a2934f14fd50e00f00a
+  data.tar.gz: 3659a5efe9ee71d5f4cad2df39b5c72e3d13523fff03602087d2dcdb19f8ba74e62c2931619085904cbfdd72ef7c574a627d996c89b8d61e70acbdb818599b92

data/config/version.rb

@@ -1,7 +1,7 @@
 module ATP
   MAJOR = 0
-  MINOR = 3
-  BUGFIX = 3
+  MINOR = 4
+  BUGFIX = 0
   DEV = nil
 
   VERSION = [MAJOR, MINOR, BUGFIX].join(".") + (DEV ? ".pre#{DEV}" : '')

data/lib/atp.rb

@@ -27,6 +27,7 @@ module ATP
     autoload :PostCleaner, 'atp/processors/post_cleaner'
     autoload :Marshal, 'atp/processors/marshal'
     autoload :AddIDs, 'atp/processors/add_ids'
+    autoload :AddSetResult, 'atp/processors/add_set_result'
     autoload :FlowID, 'atp/processors/flow_id'
   end
 

data/lib/atp/ast/builder.rb

@@ -10,8 +10,8 @@ module ATP
         @context = { conditions: [] }
       end
 
-      def flow
-        n0(:flow)
+      def flow(str)
+        n(:flow, name(str))
       end
 
       def name(str)
@@ -81,7 +81,7 @@ module ATP
         children << on_fail(options[:on_fail]) if options[:on_fail]
         children << on_pass(options[:on_pass]) if options[:on_pass]
 
-        children << n(:members, *nodes)
+        children += nodes
         group = n(:group, *children)
 
         if options[:conditions]

data/lib/atp/ast/node.rb

@@ -29,11 +29,16 @@ module ATP
 
       # Adds an empty node of the given type to the children unless another
       # node of the same type is already present
-      def ensure_node_present(type)
+      def ensure_node_present(type, child_nodes = nil)
         if children.any? { |n| n.type == type }
           self
         else
-          updated(nil, children + [n0(type)])
+          if child_nodes
+            node = n(type, *child_nodes)
+          else
+            node = n0(type)
+          end
+          updated(nil, children + [node])
         end
       end
 
@@ -58,6 +63,11 @@ module ATP
         updated(nil, children + nodes)
       end
 
+      # Remove the given nodes from the children
+      def remove(*nodes)
+        updated(nil, children - nodes)
+      end
+
       # Returns the first child node of the given type that is found
       def find(type)
         children.find { |c| c.try(:type) == type }

data/lib/atp/flow.rb

@@ -7,10 +7,12 @@ module ATP
     attr_reader :raw
     attr_accessor :id
 
-    def initialize(program, name = nil)
+    def initialize(program, name = nil, options = {})
+      name, options = nil, name if name.is_a?(Hash)
+      extract_meta!(options)
       @program = program
       @name = name
-      @raw = builder.flow
+      @raw = builder.flow(name)
     end
 
     # @api private
@@ -49,6 +51,7 @@ module ATP
     def group(name, options = {})
       open_groups.push([])
       yield
+      extract_meta!(options)
       append builder.group(name, open_groups.pop, options)
     end
 
@@ -268,9 +271,9 @@ module ATP
     end
 
     def extract_meta!(options)
-      builder.source_file = options.delete(:source_file) if options[:source_file]
-      builder.source_line_number = options.delete(:source_line_number) if options[:source_line_number]
-      builder.description = options.delete(:description) if options[:description]
+      builder.source_file = options.delete(:source_file)
+      builder.source_line_number = options.delete(:source_line_number)
+      builder.description = options.delete(:description)
     end
 
     # For testing

data/lib/atp/formatters/datalog.rb

@@ -21,8 +21,13 @@ module ATP
         else
           str += 'PASS'.ljust(9)
         end
-        str += "#{node.find(:name).value}".ljust(55)
-        str += "#{node.find(:object).value}".ljust(55)
+        if n = node.find(:name)
+          name = n.value
+        else
+          name = node.find(:object).value['Test']
+        end
+        str += "#{name}".ljust(55)
+        str += "#{node.find(:object).value['Test']}".ljust(55)
         str += "#{node.find(:id).value}"
         puts str
       end

data/lib/atp/processors/add_ids.rb

@@ -4,20 +4,41 @@ module ATP
     class AddIDs < Processor
       def run(node)
         @i = 0
+        @existing_ids = []
+        @add_ids = false
+        # First collect all existing IDs, this is required to make sure
+        # that a generated ID does not clash with an existing one
+        process(node)
+        # Now run again to fill in the blanks
+        @add_ids = true
         process(node)
       end
 
       def on_test(node)
-        @i += 1
-        node = node.ensure_node_present(:id)
-        node.updated(nil, process_all(node))
+        if @add_ids
+          node = node.ensure_node_present(:id)
+          node.updated(nil, process_all(node))
+        else
+          if id = node.find(:id)
+            @existing_ids << id.value
+          end
+          process_all(node)
+        end
       end
 
       def on_id(node)
-        unless node.value
-          node.updated(nil, ["t#{@i}"])
+        if @add_ids
+          unless node.value
+            node.updated(nil, [next_id])
+          end
         end
       end
+
+      def next_id
+        @i += 1
+        @i += 1 while @existing_ids.include?("t#{@i}")
+        "t#{@i}"
+      end
     end
   end
 end

data/lib/atp/processors/add_set_result.rb

@@ -0,0 +1,22 @@
+module ATP
+  module Processors
+    # Makes sure every test node has an on_fail/set_result node,
+    class AddSetResult < Processor
+      def run(node)
+        process(node)
+      end
+
+      def on_test(node)
+        node = node.ensure_node_present(:on_fail)
+        node.updated(nil, process_all(node))
+      end
+
+      def on_on_fail(node)
+        unless node.find(:continue)
+          node = node.ensure_node_present(:set_result, 'fail')
+        end
+        node.updated(nil, process_all(node))
+      end
+    end
+  end
+end

data/lib/atp/processors/condition.rb

@@ -7,14 +7,16 @@ module ATP
     # For example this AST:
     #
     #   (flow
-    #     (group "g1"
+    #     (group
+    #       (name "g1")
     #       (test
     #         (name "test1"))
     #       (flow-flag "bitmap" true
     #         (test
     #           (name "test2"))))
     #     (flow-flag "bitmap" true
-    #       (group "g1"
+    #       (group
+    #         (name "g1")
     #         (flow-flag "x" true
     #           (test
     #             (name "test3")))
@@ -26,7 +28,8 @@ module ATP
     # Will be optimized to this:
     #
     #   (flow
-    #     (group "g1"
+    #     (group
+    #       (name "g1")
     #       (test
     #         (name "test1"))
     #       (flow-flag "bitmap" true
@@ -66,7 +69,7 @@ module ATP
         name = children.shift
         state = children.shift
         remove_condition << node
-        children = optimize_siblings(n(:temp, children))
+        children = extract_common_embedded_conditions(n(:temp, children))
         remove_condition.pop
         if condition_to_be_removed?(node)
           process_all(children)
@@ -79,11 +82,11 @@ module ATP
       alias_method :on_test_executed, :on_boolean_condition
       alias_method :on_job, :on_boolean_condition
 
-      def on_condition(node)
+      def on_group(node)
         children = node.children.dup
         name = children.shift
         remove_condition << node
-        children = optimize_siblings(n(:temp, children))
+        children = extract_common_embedded_conditions(n(:temp, children))
         remove_condition.pop
         if condition_to_be_removed?(node)
           process_all(children)
@@ -91,7 +94,6 @@ module ATP
           node.updated(nil, [name] + process_all(children))
         end
       end
-      alias_method :on_group, :on_condition
 
       # Returns true if the given node contains the given condition within
       # its immediate children
@@ -122,58 +124,9 @@ module ATP
       end
 
       def on_flow(node)
-        # The extract_common_embedded_conditions method can probably do the whole job,
-        # but it might get a little complicated with regards to optimizing adjacent groups,
-        # so have left the original logic to have the first crack and deal with the groups
-        # for now.
-        nodes = optimize_siblings(node)
+        name, *nodes = *node
         nodes = extract_common_embedded_conditions(nodes)
-        node.updated(nil, nodes)
-      end
-
-      def on_members(node)
-        node.updated(nil, extract_common_embedded_conditions(optimize_siblings(node)))
-      end
-
-      def optimize_siblings(top_node)
-        children = []
-        unprocessed_children = []
-        current = nil
-        last = top_node.children.size - 1
-        top_node.to_a.each_with_index do |node, i|
-          # If a condition has been identified in a previous node
-          if current
-            process_nodes = false
-            # If this node has the current condition, then buffer it for later processing
-            # and continue to the next node
-            if has_condition?(current, node)
-              unprocessed_children << node
-              node = nil
-            else
-              process_nodes = true
-            end
-            if process_nodes || i == last
-              remove_condition << current
-              current_children = current.children + [process_all(unprocessed_children)].flatten
-              unprocessed_children = []
-              remove_condition.pop
-              children << process(current.updated(nil, current_children))
-              if node && (!condition?(node) || i == last)
-                current = nil
-                children << process(node)
-              else
-                current = node
-              end
-            end
-          else
-            if condition?(node) && i != last
-              current = node
-            else
-              children << process(node)
-            end
-          end
-        end
-        children.flatten
+        node.updated(nil, [name] + nodes)
       end
 
       def extract_common_embedded_conditions(nodes)

data/lib/atp/processors/condition_extractor.rb

@@ -23,18 +23,17 @@ module ATP
       alias_method :on_test_executed, :on_boolean_condition
       alias_method :on_job, :on_boolean_condition
 
-      def on_condition(node)
+      def on_group(node)
+        sig = node.children.select { |n| [:id, :name, :on_fail, :on_pass].include?(n.try(:type)) }
         children = node.children.dup
-        name = children.shift
-        conditions << node.updated(nil, [name])
-        process_all(children)
+        conditions << node.updated(nil, sig)
+        process_all(children - sig)
         conditions.pop
       end
 
       def on_test(node)
         results << [conditions.uniq, node]
       end
-      alias_method :on_group, :on_test
       alias_method :on_log, :on_test
       alias_method :on_enable_flow_flag, :on_test
       alias_method :on_disable_flow_flag, :on_test

data/lib/atp/processors/marshal.rb

@@ -3,10 +3,12 @@ module ATP
     # Makes the AST safe for Marshaling
     class Marshal < Processor
       def on_object(node)
-        if node.value.is_a?(String)
-          node
+        if node.value.is_a?(String) || node.value.is_a?(Hash)
+          node.updated(nil, [{ 'Test' => node.value }])
+        elsif node.value.respond_to?(:to_meta)
+          node.updated(nil, [node.value.to_meta])
         else
-          node.updated(nil, [node.value.name])
+          node.updated(nil, [{ 'Test' => node.value.name }])
         end
       end
     end

data/lib/atp/program.rb

@@ -10,8 +10,8 @@ module ATP
       p
     end
 
-    def flow(name)
-      flows[name] ||= Flow.new(self, name)
+    def flow(name, options = {})
+      flows[name] ||= Flow.new(self, name, options)
     end
 
     def flows

data/lib/atp/runner.rb

@@ -5,32 +5,70 @@ module ATP
   # 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_set_result: true
+      }.merge(options)
       @options = options
       @completed = false
       @groups = []
-      process(Processors::AddIDs.new.run(node))
+      @groups_on_fail = []
+      @groups_on_pass = []
+      node = Processors::AddIDs.new.run(node)
+      node = Processors::AddSetResult.new.run(node)
+      process(node)
     end
 
     def on_flow(node)
-      @flow = []
-      process_all(node.children)
-      node.updated(nil, @flow)
+      c = open_container do
+        process_all(node.children)
+      end
+      node.updated(nil, c)
+    end
+
+    def on_name(node)
+      container << node
     end
 
     def on_flow_flag(node)
-      flag, enabled, *nodes = *node
-      flag = [flag].flatten
-      active = flag.any? { |f| flow_flags.include?(f) }
-      if (enabled && active) || (!enabled && !active)
-        process_all(nodes)
+      if @options[:evaluate_flow_flags]
+        flag, enabled, *nodes = *node
+        flag = [flag].flatten
+        active = flag.any? { |f| flow_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)
       end
     end
 
     def on_run_flag(node)
-      flag, enabled, *nodes = *node
-      flag = [flag].flatten
-      active = flag.any? { |f| run_flags.include?(f) }
-      if (enabled && active) || (!enabled && !active)
+      if @options[:evaluate_run_flags]
+        flag, enabled, *nodes = *node
+        flag = [flag].flatten
+        active = flag.any? { |f| run_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)
+      end
+    end
+
+    # 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))
         process_all(nodes)
       end
     end
@@ -43,7 +81,19 @@ module ATP
           failed = true
         end
       end
-      @flow << node unless completed?
+      # If there is a group on_fail, then remove any test specific one as that
+      # will be overridden
+      if @groups_on_fail.last
+        if n_on_fail = node.find(:on_fail)
+          node = node.remove(n_on_fail)
+        end
+      end
+      if @groups_on_pass.last
+        if n_on_pass = node.find(:on_pass)
+          node = node.remove(n_on_pass)
+        end
+      end
+      container << node unless completed?
       if failed
         # Give indication to the parent group that at least one test within it failed
         if @groups.last
@@ -51,9 +101,11 @@ module ATP
           @groups << false
         end
         if n = node.find(:on_fail)
-          @continue = !!n.find(:continue)
+          # If it has been set by a parent group, don't clear it
+          orig = @continue
+          @continue ||= !!n.find(:continue)
           process_all(n)
-          @continue = false
+          @continue = orig
         end
       else
         if n = node.find(:on_pass)
@@ -63,37 +115,41 @@ module ATP
     end
 
     def on_group(node)
-      @groups << true  # This will be set to false by any tests that fail within the group
-      process_all(node.find(:members))
-      if !@groups.pop # If failed
-        if n = node.find(:on_fail)
-          @continue = !!n.find(:continue)
-          process_all(n)
-          @continue = false
+      on_fail = node.find(:on_fail)
+      on_pass = node.find(:on_pass)
+      c = open_container do
+        @groups << true  # This will be set to false by any tests that fail within the group
+        @groups_on_fail << on_fail
+        @groups_on_pass << on_pass
+        if on_fail
+          orig = @continue
+          @continue = !!on_fail.find(:continue)
+          process_all(node.children - [on_fail, on_pass])
+          @continue = orig
+        else
+          process_all(node.children - [on_fail, on_pass])
         end
-      else
-        if n = node.find(:on_pass)
-          process_all(n)
+        if !@groups.pop # If failed
+          if on_fail
+            @continue = !!on_fail.find(:continue)
+            process_all(on_fail)
+            @continue = false
+          end
+        else
+          if on_pass
+            process_all(on_pass)
+          end
         end
+        @groups_on_fail.pop
+        @groups_on_pass.pop
       end
-    end
-
-    def on_members(node)
-      # Do nothing, will be processed directly by the on_group handler
-    end
-
-    def on_test_result(node)
-      id, passed, *nodes = *node
-      if (passed && !failed_test_ids.include?(id)) ||
-         (!passed && failed_test_ids.include?(id))
-        process_all(nodes)
-      end
+      container << node.updated(nil, c + [on_fail, on_pass])
     end
 
     def on_set_result(node)
       unless @continue
-        @flow << node unless completed?
-        @completed = true
+        container << node unless completed?
+        @completed = true if @options[:evaluate_set_result]
       end
     end
 
@@ -110,7 +166,7 @@ module ATP
     end
 
     def on_log(node)
-      @flow << node unless completed?
+      container << node unless completed?
     end
     alias_method :on_render, :on_log
 
@@ -151,5 +207,16 @@ module ATP
     def completed?
       @completed
     end
+
+    def open_container(c = [])
+      @containers ||= []
+      @containers << c
+      yield
+      @containers.pop
+    end
+
+    def container
+      @containers.last
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: atp
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.4.0
 platform: ruby
 authors:
 - Stephen McGinty
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-11 00:00:00.000000000 Z
+date: 2016-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: origen
@@ -75,6 +75,7 @@ files:
 - lib/atp/parser.rb
 - lib/atp/processor.rb
 - lib/atp/processors/add_ids.rb
+- lib/atp/processors/add_set_result.rb
 - lib/atp/processors/condition.rb
 - lib/atp/processors/condition_extractor.rb
 - lib/atp/processors/flow_id.rb