atp 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7ca6eaefd174b135c5b39a8b2d287f24cd890814
-  data.tar.gz: 3c379de6d014a88c5dbec902ec85eda2d4d1abd6
+  metadata.gz: 0318ad5ca67b39da3b87b038434eaa85b1ee2a1d
+  data.tar.gz: 63bdc11c210bba2219097d14b3c5aa55678a8c8f
 SHA512:
-  metadata.gz: ec297a8c950f05a49eaa17c359d5c35378aea3e9a1e39f88f3c72906968658dc22e61590357f83b462f25dab699a1577d7d334efdb26d126b0f3694a159eaa9f
-  data.tar.gz: 1fc8899484368c2fc172801ba5bae1968fd9488d52420d0f0c30e1275a9db41783ab2886536317ca5744e2b7222badee59a9e6d5006d373b827f6e90d3bb6d80
+  metadata.gz: ae4da77cd22cc197e3ecf80af390de270b71c6a00cfcae3c49345156b9840c5f6429520707c29c36dffb89d54ec50b8af710257c93f23b872d44b5a10fb8aad6
+  data.tar.gz: 6ee881a43ee9cf5015860b50719d6d07c461f545180d967319d8ada891a36cd47adf8ac48a5ef277c79494bfbc0a54dfdddb77d1bbaac77a70dc8a6d67b63f24

data/config/version.rb

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

data/lib/atp.rb

@@ -1,9 +1,11 @@
 require 'origen'
 require_relative '../config/application.rb'
+
 module ATP
   autoload :Program, 'atp/program'
   autoload :Flow, 'atp/flow'
   autoload :Processor, 'atp/processor'
+  autoload :Validator, 'atp/validator'
   autoload :Runner, 'atp/runner'
   autoload :Formatter, 'atp/formatter'
   autoload :Parser, 'atp/parser'
@@ -22,6 +24,7 @@ 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'
@@ -34,6 +37,8 @@ module ATP
   # Validators are run on the processed AST to check it for common errors or
   # logical issues that will prevent it being rendered to a test program format
   module Validators
+    autoload :DuplicateIDs, 'atp/validators/duplicate_ids'
+    autoload :MissingIDs, 'atp/validators/missing_ids'
     autoload :Condition, 'atp/validators/condition'
   end
 

data/lib/atp/ast/builder.rb

@@ -4,6 +4,7 @@ module ATP
       include Factories
 
       attr_reader :context
+      attr_accessor :source_file, :source_line_number
 
       def flow
         n0(:flow)
@@ -13,8 +14,13 @@ module ATP
         n(:name, str.to_s)
       end
 
-      def log(str)
-        n(:log, str.to_s)
+      def log(str, options = {})
+        test = n(:log, str.to_s)
+        if options[:conditions]
+          apply_conditions(test, options[:conditions])
+        else
+          test
+        end
       end
 
       def render(str)
@@ -41,6 +47,24 @@ module ATP
         n(:test_executed, id, executed, node)
       end
 
+      def enable_flow_flag(var, options = {})
+        test = n(:enable_flow_flag, var)
+        if options[:conditions]
+          apply_conditions(test, options[:conditions])
+        else
+          test
+        end
+      end
+
+      def disable_flow_flag(var, options = {})
+        test = n(:disable_flow_flag, var)
+        if options[:conditions]
+          apply_conditions(test, options[:conditions])
+        else
+          test
+        end
+      end
+
       def group(group_name, nodes, options = {})
         children = [name(group_name)]
 
@@ -59,8 +83,13 @@ module ATP
         end
       end
 
-      def cz(setup, node)
-        n(:cz, setup, node)
+      def cz(setup, node, options = {})
+        test = n(:cz, setup, node)
+        if options[:conditions]
+          apply_conditions(test, options[:conditions])
+        else
+          test
+        end
       end
 
       def new_context
@@ -199,7 +228,13 @@ module ATP
         children << n(:bin, options[:bin])  if options[:bin]
         children << n(:softbin, options[:softbin])  if options[:softbin]
         children << n(:description, options[:description])  if options[:description]
-        n(:set_result, *children)
+        result = n(:set_result, *children)
+
+        if options[:conditions]
+          apply_conditions(result, options[:conditions])
+        else
+          result
+        end
       end
 
       def number(val)

data/lib/atp/ast/factories.rb

@@ -2,11 +2,14 @@ module ATP
   module AST
     module Factories
       def n(type, *children)
-        ATP::AST::Node.new(type, children)
+        options = children.last.is_a?(Hash) ? children.pop : {}
+        options[:file] ||= options.delete(:source_file) || try(:source_file)
+        options[:line_number] ||= options.delete(:source_line_number) || try(:source_line_number)
+        ATP::AST::Node.new(type, children, options)
       end
 
-      def n0(type)
-        ATP::AST::Node.new(type, [])
+      def n0(type, options = {})
+        n(type, options)
       end
     end
   end

data/lib/atp/ast/node.rb

@@ -4,6 +4,8 @@ module ATP
     class Node < ::AST::Node
       include Factories
 
+      attr_reader :file, :line_number
+
       def initialize(type, children = [], properties = {})
         # Always use strings instead of symbols in the AST, makes serializing
         # back and forward to a string easier
@@ -11,6 +13,14 @@ module ATP
         super type, children, properties
       end
 
+      def source
+        if file
+          "#{file}:#{line_number}"
+        else
+          '<Sorry, lost the source file info, please include an example if you report as a bug>'
+        end
+      end
+
       # Create a new node from the given S-expression (a string)
       def self.from_sexp(sexp)
         @parser ||= Parser.new

data/lib/atp/flow.rb

@@ -2,12 +2,13 @@ module ATP
   # Implements the main user API for building and interacting
   # with an abstract test program
   class Flow
-    attr_reader :program
+    attr_reader :program, :name
     # Returns the raw AST
     attr_reader :raw
 
-    def initialize(program)
+    def initialize(program, name = nil)
       @program = program
+      @name = name
       @builder = AST::Builder.new
       @raw = builder.flow
     end
@@ -16,6 +17,8 @@ module ATP
     # used to build and represent the given test flow
     def ast
       ast = Processors::PreCleaner.new.process(raw)
+      Validators::DuplicateIDs.new(self).process(ast)
+      Validators::MissingIDs.new(self).process(ast)
       ast = Processors::Condition.new.process(ast)
       ast = Processors::Relationship.new.process(ast)
       ast = Processors::PostCleaner.new.process(ast)
@@ -44,60 +47,86 @@ module ATP
     # @option options [Hash] :on_pass What action to take if the test passes
     # @option options [Hash] :conditions What conditions must be met to execute the test
     def test(instance, options = {})
+      extract_meta!(options)
       r = options.delete(:return)
-      if options[:context] == :current
-        options[:conditions] = builder.context[:conditions]
-      end
-      # Allows any continue, bin, or soft bin argument passed in at the options top-level to be assumed
-      # to be the action to take if the test fails
-      if b = options.delete(:bin)
-        options[:on_fail] ||= {}
-        options[:on_fail][:bin] = b
-      end
-      if b = options.delete(:softbin) || b = options.delete(:sbin) || b = options.delete(:soft_bin)
-        options[:on_fail] ||= {}
-        options[:on_fail][:softbin] = b
-      end
-      if options.delete(:continue)
-        options[:on_fail] ||= {}
-        options[:on_fail][:continue] = true
-      end
-      builder.new_context
-
-      t = builder.test(instance, options)
-      unless options[:context] == :current
-        open_conditions.each do |conditions|
-          t = builder.apply_conditions(t, conditions)
+      t = apply_open_conditions(options) do |options|
+        # Allows any continue, bin, or soft bin argument passed in at the options top-level to be assumed
+        # to be the action to take if the test fails
+        if b = options.delete(:bin)
+          options[:on_fail] ||= {}
+          options[:on_fail][:bin] = b
+        end
+        if b = options.delete(:softbin) || b = options.delete(:sbin) || b = options.delete(:soft_bin)
+          options[:on_fail] ||= {}
+          options[:on_fail][:softbin] = b
         end
+        if options.delete(:continue)
+          options[:on_fail] ||= {}
+          options[:on_fail][:continue] = true
+        end
+        builder.test(instance, options)
       end
       append(t) unless r
       t
     end
 
     def bin(number, options = {})
-      fail 'A :type option set to :pass or :fail is required when calling bin' unless options[:type]
-      options[:bin] = number
-      options[:softbin] ||= options[:soft_bin] || options[:sbin]
-      append builder.set_result(options[:type], options)
+      extract_meta!(options)
+      t = apply_open_conditions(options) do |options|
+        fail 'A :type option set to :pass or :fail is required when calling bin' unless options[:type]
+        options[:bin] = number
+        options[:softbin] ||= options[:soft_bin] || options[:sbin]
+        builder.set_result(options[:type], options)
+      end
+      append(t)
     end
 
     def cz(instance, cz_setup, options = {})
-      options[:return] = true
-      append(builder.cz(cz_setup, test(instance, options)))
+      extract_meta!(options)
+      t = apply_open_conditions(options) do |options|
+        conditions = options.delete(:conditions)
+        options[:return] = true
+        builder.cz(cz_setup, test(instance, options), conditions: conditions)
+      end
+      append(t)
     end
     alias_method :characterize, :cz
 
     # Append a log message line to the flow
     def log(message, options = {})
-      append builder.log(message)
+      extract_meta!(options)
+      t = apply_open_conditions(options) do |options|
+        builder.log(message, options)
+      end
+      append(t)
+    end
+
+    # Enable a flow control variable
+    def enable(var, options = {})
+      extract_meta!(options)
+      t = apply_open_conditions(options) do |options|
+        builder.enable_flow_flag(var, options)
+      end
+      append(t)
+    end
+
+    # Disable a flow control variable
+    def disable(var, options = {})
+      extract_meta!(options)
+      t = apply_open_conditions(options) do |options|
+        builder.disable_flow_flag(var, options)
+      end
+      append(t)
     end
 
     # Insert explicitly rendered content in to the flow
     def render(str, options = {})
+      extract_meta!(options)
       append builder.render(str)
     end
 
     def with_condition(options)
+      extract_meta!(options)
       open_conditions.push(options)
       yield
       open_conditions.pop
@@ -112,6 +141,25 @@ module ATP
 
     private
 
+    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
+        open_conditions.each do |conditions|
+          t = builder.apply_conditions(t, conditions)
+        end
+      end
+      t
+    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]
+    end
+
     # For testing
     def raw=(ast)
       @raw = ast

data/lib/atp/processor.rb

@@ -11,6 +11,10 @@ module ATP
   class Processor
     include ::AST::Processor::Mixin
 
+    def run(node)
+      process(node)
+    end
+
     def process(node)
       if node.respond_to?(:to_ast)
         super(node)

data/lib/atp/processors/condition.rb

@@ -65,7 +65,9 @@ module ATP
         children = node.children.dup
         name = children.shift
         state = children.shift
+        remove_condition << node
         children = optimize_siblings(n(:temp, children))
+        remove_condition.pop
         if condition_to_be_removed?(node)
           process_all(children)
         else
@@ -79,7 +81,9 @@ module ATP
       def on_condition(node)
         children = node.children.dup
         name = children.shift
+        remove_condition << node
         children = optimize_siblings(n(:temp, children))
+        remove_condition.pop
         if condition_to_be_removed?(node)
           process_all(children)
         else
@@ -100,7 +104,7 @@ module ATP
       end
 
       def condition_to_be_removed?(node)
-        remove_condition.last && equal_conditions?(remove_condition.last, node)
+        remove_condition.any? { |c| equal_conditions?(c, node) }
       end
 
       def equal_conditions?(node1, node2)
@@ -118,11 +122,17 @@ module ATP
       end
 
       def on_flow(node)
-        node.updated(nil, optimize_siblings(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)
+        nodes = extract_common_embedded_conditions(nodes)
+        node.updated(nil, nodes)
       end
 
       def on_members(node)
-        node.updated(nil, optimize_siblings(node))
+        node.updated(nil, extract_common_embedded_conditions(optimize_siblings(node)))
       end
 
       def optimize_siblings(top_node)
@@ -166,6 +176,46 @@ module ATP
         children.flatten
       end
 
+      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
+          else
+            cond_a = cond_b
+            test_a = test_b
+          end
+        end
+        if nodes == [test_a]
+          nodes
+        else
+          result << combine(cond_a, extract_common_embedded_conditions(test_a))
+          result.flatten
+        end
+      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]))
+          end
+        end
+        node
+      end
+
       def remove_condition
         @remove_condition ||= []
       end

data/lib/atp/processors/condition_extractor.rb

@@ -0,0 +1,46 @@
+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
+
+      def on_condition(node)
+        children = node.children.dup
+        name = children.shift
+        conditions << node.updated(nil, [name])
+        process_all(children)
+        conditions.pop
+      end
+      alias_method :on_job, :on_condition
+
+      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
+      alias_method :on_cz, :on_test
+      alias_method :on_set_result, :on_test
+      alias_method :on_render, :on_test
+    end
+  end
+end

data/lib/atp/processors/pre_cleaner.rb

@@ -8,12 +8,20 @@ module ATP
         @group_ids = []
       end
 
+      # Make all IDs lower cased symbols
       def on_id(node)
-        id = node.to_a.first
-        id = id.to_s.downcase.to_sym
-        node.updated(nil, [id])
+        id = node.to_a[0]
+        node.updated(nil, [clean(id)])
       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))
+      end
+      alias_method :on_test_result, :on_test_executed
+
       def on_group(node)
         if id = node.children.find { |n| n.type == :id }
           @group_ids << process(id).value
@@ -38,6 +46,14 @@ module ATP
         end
         node.updated(nil, process_all(children))
       end
+
+      def clean(id)
+        if id.is_a?(Array)
+          id.map { |i| clean(i) }
+        else
+          id.to_s.downcase.to_sym
+        end
+      end
     end
   end
 end

data/lib/atp/program.rb

@@ -2,7 +2,7 @@ module ATP
   # Program is the top-level container for a collection of test flows
   class Program
     def flow(name)
-      flows[name] ||= Flow.new(self)
+      flows[name] ||= Flow.new(self, name)
     end
 
     def flows

data/lib/atp/validator.rb

@@ -0,0 +1,24 @@
+require 'ast'
+module ATP
+  class Validator < Processor
+    attr_reader :flow
+
+    def initialize(flow)
+      @flow = flow
+    end
+
+    def process(node)
+      if @top_level_called
+        super
+      else
+        @top_level_called = true
+        setup
+        super(node)
+        exit 1 if on_completion
+      end
+    end
+
+    def setup
+    end
+  end
+end

data/lib/atp/validators/duplicate_ids.rb

@@ -0,0 +1,32 @@
+module ATP
+  module Validators
+    class DuplicateIDs < Validator
+      def on_completion
+        if @duplicate_ids
+          @duplicate_ids.each do |id, nodes|
+            Origen.log.error "Test ID #{id} is defined more than once in flow #{flow.name}:"
+            nodes.each do |node|
+              Origen.log.error "  #{node.source}"
+            end
+          end
+          true
+        end
+      end
+
+      def on_id(node)
+        @existing_ids ||= {}
+        id = node.value
+        if @existing_ids[id]
+          @duplicate_ids ||= {}
+          if @duplicate_ids[id]
+            @duplicate_ids[id] << node
+          else
+            @duplicate_ids[id] = [@existing_ids[id], node]
+          end
+        else
+          @existing_ids[id] = node
+        end
+      end
+    end
+  end
+end

data/lib/atp/validators/missing_ids.rb

@@ -0,0 +1,55 @@
+module ATP
+  module Validators
+    class MissingIDs < Validator
+      def setup
+        @referenced_ids = {}
+        @present_ids ||= {}.with_indifferent_access
+        @referenced_early = {}.with_indifferent_access
+      end
+
+      def on_completion
+        failed = false
+        @referenced_ids.each do |id, nodes|
+          unless @present_ids[id]
+            Origen.log.error "Test ID #{id} is referenced in flow #{flow.name} in the following lines, but it is never defined:"
+            nodes.each do |node|
+              Origen.log.error "  #{node.source}"
+            end
+            failed = true
+            @referenced_early.delete(id)
+          end
+        end
+        @referenced_early.each do |id, nodes|
+          Origen.log.error "Test ID #{id} is referenced in flow #{flow.name} in the following line(s):"
+          nodes.each do |node|
+            Origen.log.error "  #{node.source}"
+          end
+          Origen.log.error 'but it was not defined until later:'
+          Origen.log.error "  #{@present_ids[id].first.source}"
+          failed = true
+        end
+        failed
+      end
+
+      def on_id(node)
+        id = node.value
+        @present_ids[id] ||= []
+        @present_ids[id] << node
+      end
+
+      def on_test_executed(node)
+        ids = node.to_a[0]
+        [ids].flatten.each do |id|
+          @referenced_ids[id] ||= []
+          @referenced_ids[id] << node
+          unless @present_ids[id]
+            @referenced_early[id] ||= []
+            @referenced_early[id] << node
+          end
+        end
+        process_all(node)
+      end
+      alias_method :on_test_result, :on_test_executed
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: atp
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Stephen McGinty
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-20 00:00:00.000000000 Z
+date: 2016-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: origen
@@ -78,12 +78,16 @@ files:
 - lib/atp/parser.rb
 - lib/atp/processor.rb
 - lib/atp/processors/condition.rb
+- lib/atp/processors/condition_extractor.rb
 - lib/atp/processors/post_cleaner.rb
 - lib/atp/processors/pre_cleaner.rb
 - lib/atp/processors/relationship.rb
 - lib/atp/program.rb
 - lib/atp/runner.rb
+- lib/atp/validator.rb
 - lib/atp/validators/condition.rb
+- lib/atp/validators/duplicate_ids.rb
+- lib/atp/validators/missing_ids.rb
 - lib/tasks/atp.rake
 - templates/web/archive.md.erb
 - templates/web/contact.md.erb