atp 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8dec9f1b4fc0f21e7cc484fce7787483e2e93b78
-  data.tar.gz: be379e4724e0eeac24edc94fe47b8db1b6e24b4a
+  metadata.gz: f75bbab3b302da47d1dee34b1d3ee5ff9e19fbf8
+  data.tar.gz: bdd796b0790974ab59638e3eb1c3a6d0978838e4
 SHA512:
-  metadata.gz: da277917432ec7ddd4bc4ddcb3aca7734dec9a0e034f1e756c7012c218907ef5c7e70c32e3de2de917d8a2b98735cdd67e33b26650de0834555f7a21b15678f9
-  data.tar.gz: 3fa65d6a651d94617f71f93c05d39aedc290c551e0f553a1d2b4b49330afd08bce9e1952315449206b14f87cbce0abe1bd53f84c3da1dbbbc8ea01fb84cd27d8
+  metadata.gz: c75c86487c1fa3db9cd8ec84b754850b4cb308c6cd5bd6c2fbc96342bf300d433154e66787b66bd896b484677f6c367102b641f9bdd5166f2b8be1a62a054767
+  data.tar.gz: eb3547a04a6b3ceea52ac58c831d5d320a1c818ffd161195207f858b0b30b592853ab94edeae371684221def67a0ee7075ee8c8ca7bb6e6af7890469b58e59b5

data/config/version.rb

@@ -1,6 +1,6 @@
 module ATP
   MAJOR = 0
-  MINOR = 7
+  MINOR = 8
   BUGFIX = 0
   DEV = nil
 

data/lib/atp.rb

@@ -21,7 +21,6 @@ module ATP
   # and to implement the flow control API
   module Processors
     autoload :Condition,    'atp/processors/condition'
-    autoload :ConditionExtractor, 'atp/processors/condition_extractor'
     autoload :Relationship, 'atp/processors/relationship'
     autoload :PreCleaner, 'atp/processors/pre_cleaner'
     autoload :PostCleaner, 'atp/processors/post_cleaner'

data/lib/atp/ast/builder.rb

@@ -14,6 +14,24 @@ module ATP
         n(:flow, name(str))
       end
 
+      # Ensures the given flow ast has a volatile node, then adds the
+      # given flags to it
+      def add_volatile_flags(flow, flags)
+        name, *nodes = *flow
+        if nodes[0] && nodes[0].type == :volatile
+          v = nodes.shift
+        else
+          v = n0(:volatile)
+        end
+        existing = v.children.map { |f| f.type == :flag ? f.value : nil }.compact
+        new = []
+        flags.each do |flag|
+          new << n(:flag, flag) unless existing.include?(flag)
+        end
+        v = v.updated(nil, v.children + new)
+        flow.updated(nil, [name, v] + nodes)
+      end
+
       def name(str)
         n(:name, str.to_s)
       end
@@ -220,6 +238,55 @@ module ATP
 
         children << id(options[:id].to_s.downcase.to_sym) if options[:id]
 
+        if levels = options[:level] || options[:levels]
+          levels = [levels] unless levels.is_a?(Array)
+          levels.each do |l|
+            children << level(l[:name], l[:value], l[:unit] || l[:units])
+          end
+        end
+
+        if lims = options[:limit] || options[:limits]
+          lims = [lims] unless lims.is_a?(Array)
+          lims.each do |l|
+            children << limit(l[:value], l[:rule], l[:unit] || l[:units])
+          end
+        end
+
+        if pins = options[:pin] || options[:pins]
+          pins = [pins] unless pins.is_a?(Array)
+          pins.each do |p|
+            if p.is_a?(Hash)
+              children << pin(p[:name])
+            else
+              children << pin(p)
+            end
+          end
+        end
+
+        if pats = options[:pattern] || options[:patterns]
+          pats = [pats] unless pats.is_a?(Array)
+          pats.each do |p|
+            if p.is_a?(Hash)
+              children << pattern(p[:name], p[:path])
+            else
+              children << pattern(p)
+            end
+          end
+        end
+
+        if options[:meta]
+          attrs = []
+          options[:meta].each { |k, v| attrs << attribute(k, v) }
+          children << n(:meta, *attrs)
+        end
+
+        if subs = options[:sub_test] || options[:sub_tests]
+          subs = [subs] unless subs.is_a?(Array)
+          subs.each do |s|
+            children << s.updated(:sub_test, nil)
+          end
+        end
+
         children << on_fail(options[:on_fail]) if options[:on_fail]
         children << on_pass(options[:on_pass]) if options[:on_pass]
 
@@ -232,6 +299,38 @@ module ATP
         end
       end
 
+      def pattern(name, path = nil)
+        if path
+          n(:pattern, name, path)
+        else
+          n(:pattern, name)
+        end
+      end
+
+      def attribute(name, value)
+        n(:attribute, name, value)
+      end
+
+      def level(name, value, units = nil)
+        if units
+          n(:level, name, value, units)
+        else
+          n(:level, name, value)
+        end
+      end
+
+      def limit(value, rule, units = nil)
+        if units
+          n(:limit, value, rule, units)
+        else
+          n(:limit, value, rule)
+        end
+      end
+
+      def pin(name)
+        n(:pin, name)
+      end
+
       def on_fail(options = {})
         children = []
         if options[:bin] || options[:softbin]

data/lib/atp/flow.rb

@@ -41,6 +41,14 @@ module ATP
       ast
     end
 
+    # Indicate the that given flags should be considered volatile (can change at any time), which will
+    # prevent them from been touched by the optimization algorithms
+    def volatile(*flags)
+      options = flags.pop if flags.last.is_a?(Hash)
+      flags = flags.flatten
+      @raw = builder.add_volatile_flags(@raw, flags)
+    end
+
     # Group all tests generated within the given block
     #
     # @example
@@ -104,6 +112,16 @@ module ATP
       t
     end
 
+    # Equivalent to calling test, but returns a sub_test node instead of adding it to the flow.
+    # It will also ignore any condition nodes that would normally wrap the equivalent flow.test call.
+    #
+    # This is a helper to create sub_tests for inclusion in a top-level test node.
+    def sub_test(instance, options = {})
+      options[:return] = true
+      options[:ignore_all_conditions] = true
+      test(instance, options)
+    end
+
     def bin(number, options = {})
       extract_meta!(options)
       t = apply_open_conditions(options) do |options|
@@ -268,19 +286,23 @@ module ATP
     end
 
     def apply_open_conditions(options)
-      if options[:context] == :current
-        options[:conditions] = builder.context[:conditions]
-      end
-      builder.new_context
-      t = yield(options)
-      unless options[:context] == :current
-        unless options[:dont_apply_conditions]
-          open_conditions.each do |conditions|
-            t = builder.apply_conditions(t, conditions)
+      if options[:ignore_all_conditions]
+        yield(options)
+      else
+        if options[:context] == :current
+          options[:conditions] = builder.context[:conditions]
+        end
+        builder.new_context
+        t = yield(options)
+        unless options[:context] == :current
+          unless options[:dont_apply_conditions]
+            open_conditions.each do |conditions|
+              t = builder.apply_conditions(t, conditions)
+            end
           end
         end
+        t
       end
-      t
     end
 
     def extract_meta!(options)

data/lib/atp/processor.rb

@@ -23,6 +23,23 @@ module ATP
       end
     end
 
+    # Some of our processors remove a wrapping node from the AST, returning
+    # a node of type :inline containing the children which should be inlined.
+    # Here we override the default version of this method to deal with handlers
+    # that return an inline node in place of a regular node.
+    def process_all(nodes)
+      results = []
+      nodes.to_a.each do |node|
+        n = process(node)
+        if n.respond_to?(:type) && n.type == :inline
+          results += n.children
+        else
+          results << n
+        end
+      end
+      results
+    end
+
     def handler_missing(node)
       node.updated(nil, process_all(node.children))
     end
@@ -42,5 +59,31 @@ module ATP
     def n2(type, arg1, arg2)
       n(type, [arg1, arg2])
     end
+
+    def extract_volatiles(flow)
+      @volatiles = {}
+      if v = flow.find(:volatile)
+        @volatiles[:flags] = Array(v.find_all(:flag)).map(&:value)
+      end
+    end
+
+    def volatile_flags
+      unless @volatiles
+        fail 'You must first call extract_volatiles(node) from your on_flow hander method'
+      end
+      @volatiles[:flags] || []
+    end
+
+    # Returns true if the given flag name has been marked as volatile
+    def volatile?(flag)
+      result = volatile_flags.any? { |f| clean_flag(f) == clean_flag(flag) }
+      result
+    end
+
+    def clean_flag(flag)
+      flag = flag.dup.to_s
+      flag[0] = '' if flag[0] == '$'
+      flag.downcase
+    end
   end
 end

data/lib/atp/processors/condition.rb

@@ -43,134 +43,131 @@ module ATP
     #               (name "test4")))))))
     #
     class Condition < Processor
-      CONDITION_NODES = [:flow_flag, :test_result, :test_executed, :group, :job]
-
-      def process(node)
-        # Bit of a hack - To get all of the nested conditions optimized away it is necessary
-        # to execute this recursively a few times. This guard ensures that the recursion is
-        # only performed on the top-level and not on every process operation.
-        if @top_level_called
-          super
-        else
-          @top_level_called = true
-          ast1 = nil
-          ast2 = node
-          while ast1 != ast2
-            ast1 = super(ast2)
-            ast2 = super(ast1)
-          end
-          @top_level_called = false
-          ast1
-        end
+      def on_flow(node)
+        extract_volatiles(node)
+        node.updated(nil, optimize(process_all(node.children)))
       end
 
-      def on_boolean_condition(node)
-        children = node.children.dup
-        name = children.shift
-        state = children.shift
-        remove_condition << node
-        children = extract_common_embedded_conditions(n(:temp, children))
-        remove_condition.pop
-        if condition_to_be_removed?(node)
-          process_all(children)
+      def on_flow_flag(node)
+        flag, state, *nodes = *node
+        if conditions_to_remove.any? { |c| node.type == c.type && c.to_a == [flag, state] }
+          if volatile?(flag)
+            result = n(:inline, optimize(process_all(nodes)))
+          else
+            # This ensures any duplicate conditions matching the current one get removed
+            conditions_to_remove << node.updated(nil, [flag, state])
+            result = n(:inline, optimize(process_all(nodes)))
+            conditions_to_remove.pop
+          end
         else
-          node.updated(nil, [name, state] + process_all(children))
+          if volatile?(flag)
+            result = node.updated(nil, [flag, state] + optimize(process_all(nodes)))
+          else
+            conditions_to_remove << node.updated(nil, [flag, state])
+            result = node.updated(nil, [flag, state] + optimize(process_all(nodes)))
+            conditions_to_remove.pop
+          end
         end
+        result
       end
-      alias_method :on_flow_flag, :on_boolean_condition
-      alias_method :on_test_result, :on_boolean_condition
-      alias_method :on_test_executed, :on_boolean_condition
-      alias_method :on_job, :on_boolean_condition
+      alias_method :on_test_result, :on_flow_flag
+      alias_method :on_job, :on_flow_flag
+      alias_method :on_run_flag, :on_flow_flag
+      alias_method :on_test_executed, :on_flow_flag
 
       def on_group(node)
-        children = node.children.dup
-        name = children.shift
-        remove_condition << node
-        children = extract_common_embedded_conditions(n(:temp, children))
-        remove_condition.pop
-        if condition_to_be_removed?(node)
-          process_all(children)
+        name, *nodes = *node
+        if conditions_to_remove.any? { |c| node.type == c.type && c.to_a == [name] }
+          conditions_to_remove << node.updated(nil, [name])
+          result = n(:inline, optimize(process_all(nodes)))
+          conditions_to_remove.pop
         else
-          node.updated(nil, [name] + process_all(children))
+          conditions_to_remove << node.updated(nil, [name])
+          result = node.updated(nil, [name] + optimize(process_all(nodes)))
+          conditions_to_remove.pop
         end
+        result
       end
 
-      # Returns true if the given node contains the given condition within
-      # its immediate children
-      def has_condition?(condition, node)
-        ([node] + node.children.to_a).any? do |n|
-          if n.is_a?(ATP::AST::Node)
-            equal_conditions?(condition, n)
+      def optimize(nodes)
+        results = []
+        node1 = nil
+        nodes.each do |node2|
+          if node1
+            if can_be_combined?(node1, node2)
+              node1 = process(combine(node1, node2))
+            else
+              results << node1
+              node1 = node2
+            end
+          else
+            node1 = node2
           end
         end
+        results << node1 if node1
+        results
       end
 
-      def condition_to_be_removed?(node)
-        remove_condition.any? { |c| equal_conditions?(c, node) }
-      end
-
-      def equal_conditions?(node1, node2)
-        if node1.type == node2.type
-          if node1.type == :group
-            node1.to_a.take(1) == node2.to_a.take(1)
-          else
-            node1.to_a.take(2) == node2.to_a.take(2)
-          end
+      def can_be_combined?(node1, node2)
+        if condition_node?(node1) && condition_node?(node2)
+          !(conditions(node1) & conditions(node2)).empty?
+        else
+          false
         end
       end
 
-      def condition?(node)
-        node.is_a?(ATP::AST::Node) && CONDITION_NODES.include?(node.type)
+      def condition_node?(node)
+        node.respond_to?(:type) &&
+          [:flow_flag, :run_flag, :test_result, :group, :job, :test_executed].include?(node.type)
       end
 
-      def on_flow(node)
-        name, *nodes = *node
-        nodes = extract_common_embedded_conditions(nodes)
-        node.updated(nil, [name] + nodes)
-      end
+      def combine(node1, node2)
+        common = conditions(node1) & conditions(node2)
+        common.each { |condition| conditions_to_remove << condition }
+        node1 = process(node1)
+        node1 = [node1] unless node1.is_a?(Array)
+        node2 = process(node2)
+        node2 = [node2] unless node2.is_a?(Array)
+        common.size.times { conditions_to_remove.pop }
 
-      def extract_common_embedded_conditions(nodes)
-        nodes = [nodes] unless nodes.is_a?(Array)
-        result = []
-        cond_a = nil
-        test_a = nil
-        ConditionExtractor.new.run(nodes).each do |cond_b, test_b|
-          if cond_a
-            common = cond_a & cond_b
-            if common.empty?
-              result << combine(cond_a, extract_common_embedded_conditions(test_a))
-              cond_a = cond_b
-              test_a = test_b
-            else
-              a = combine(cond_a - common, test_a)
-              b = combine(cond_b - common, test_b)
-              cond_a = common
-              test_a = [a, b].flatten
-            end
+        node = nil
+        common.reverse_each do |condition|
+          if node
+            node = condition.updated(nil, condition.children + [node])
           else
-            cond_a = cond_b
-            test_a = test_b
+            node = condition.updated(nil, condition.children + node1 + node2)
           end
         end
-        if nodes == [test_a]
-          nodes
-        else
-          result << combine(cond_a, extract_common_embedded_conditions(test_a))
-          result.flatten
-        end
+        node
       end
 
-      def combine(conditions, node)
-        if conditions && !conditions.empty?
-          conditions.reverse_each do |n|
-            node = n.updated(nil, n.children + (node.is_a?(Array) ? node : [node]))
+      def conditions(node)
+        result = []
+        if [:flow_flag, :run_flag].include?(node.type)
+          flag, state, *children = *node
+          unless volatile?(flag)
+            result << node.updated(nil, [flag, state])
           end
+          result += conditions(children.first) if children.first
+        elsif [:test_result, :job, :test_executed].include?(node.type)
+          flag, state, *children = *node
+          result << node.updated(nil, [flag, state])
+          result += conditions(children.first) if children.first
+        elsif node.type == :group
+          name, *children = *node
+          # Sometimes a group can have an ID
+          if children.first.try(:type) == :id
+            result << node.updated(nil, [name, children.shift])
+          else
+            result << node.updated(nil, [name])
+          end
+          result += conditions(children.first) if children.first
         end
-        node
+        result
       end
 
-      def remove_condition
-        @remove_condition ||= []
+      def conditions_to_remove
+        @conditions_to_remove ||= []
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: atp
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Stephen McGinty
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-19 00:00:00.000000000 Z
+date: 2017-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: origen
@@ -77,7 +77,6 @@ files:
 - 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
 - lib/atp/processors/marshal.rb
 - lib/atp/processors/post_cleaner.rb

data/lib/atp/processors/condition_extractor.rb

@@ -1,46 +0,0 @@
-module ATP
-  module Processors
-    class ConditionExtractor < Processor
-      attr_reader :results, :conditions
-
-      def run(nodes)
-        @results = []
-        @conditions = []
-        process_all(nodes)
-        @results
-      end
-
-      def on_boolean_condition(node)
-        children = node.children.dup
-        name = children.shift
-        state = children.shift
-        conditions << node.updated(nil, [name, state])
-        process_all(children)
-        conditions.pop
-      end
-      alias_method :on_flow_flag, :on_boolean_condition
-      alias_method :on_test_result, :on_boolean_condition
-      alias_method :on_test_executed, :on_boolean_condition
-      alias_method :on_job, :on_boolean_condition
-      alias_method :on_run_flag, :on_boolean_condition
-
-      def on_group(node)
-        sig = node.children.select { |n| [:id, :name, :on_fail, :on_pass].include?(n.try(:type)) }
-        children = node.children.dup
-        conditions << node.updated(nil, sig)
-        process_all(children - sig)
-        conditions.pop
-      end
-
-      def on_test(node)
-        results << [conditions.uniq, node]
-      end
-      alias_method :on_log, :on_test
-      alias_method :on_enable_flow_flag, :on_test
-      alias_method :on_disable_flow_flag, :on_test
-      alias_method :on_cz, :on_test
-      alias_method :on_set_result, :on_test
-      alias_method :on_render, :on_test
-    end
-  end
-end