atp 0.8.0 → 1.0.0

data/lib/atp/validators/missing_ids.rb

@@ -11,21 +11,21 @@ module ATP
         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:"
+            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}"
+              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):"
+          error "Test ID #{id} is referenced in flow #{flow.name} in the following line(s):"
           nodes.each do |node|
-            Origen.log.error "  #{node.source}"
+            error "  #{node.source}"
           end
-          Origen.log.error 'but it was not defined until later:'
-          Origen.log.error "  #{@present_ids[id].first.source}"
+          error 'but it was not defined until later:'
+          error "  #{@present_ids[id].first.source}"
           failed = true
         end
         failed
@@ -37,7 +37,7 @@ module ATP
         @present_ids[id] << node
       end
 
-      def on_test_executed(node)
+      def on_if_failed(node)
         ids = node.to_a[0]
         [ids].flatten.each do |id|
           unless id =~ /^extern/
@@ -51,7 +51,13 @@ module ATP
         end
         process_all(node)
       end
-      alias_method :on_test_result, :on_test_executed
+      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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: atp
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Stephen McGinty
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-02 00:00:00.000000000 Z
+date: 2017-11-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: origen
@@ -64,11 +64,10 @@ files:
 - config/commands.rb
 - config/version.rb
 - lib/atp.rb
-- lib/atp/ast/builder.rb
 - lib/atp/ast/extractor.rb
-- lib/atp/ast/factories.rb
 - lib/atp/ast/node.rb
 - lib/atp/flow.rb
+- lib/atp/flow_api.rb
 - lib/atp/formatter.rb
 - lib/atp/formatters/basic.rb
 - lib/atp/formatters/datalog.rb
@@ -76,11 +75,22 @@ files:
 - lib/atp/processor.rb
 - lib/atp/processors/add_ids.rb
 - lib/atp/processors/add_set_result.rb
+- lib/atp/processors/adjacent_if_combiner.rb
+- lib/atp/processors/append_to.rb
+- lib/atp/processors/apply_post_group_actions.rb
 - lib/atp/processors/condition.rb
+- lib/atp/processors/continue_implementer.rb
+- lib/atp/processors/else_remover.rb
+- lib/atp/processors/empty_branch_remover.rb
+- lib/atp/processors/extract_set_flags.rb
+- lib/atp/processors/flag_optimizer.rb
+- lib/atp/processors/flattener.rb
 - lib/atp/processors/flow_id.rb
 - lib/atp/processors/marshal.rb
-- lib/atp/processors/post_cleaner.rb
+- lib/atp/processors/on_pass_fail_remover.rb
+- lib/atp/processors/one_flag_per_test.rb
 - lib/atp/processors/pre_cleaner.rb
+- lib/atp/processors/redundant_condition_remover.rb
 - lib/atp/processors/relationship.rb
 - lib/atp/program.rb
 - lib/atp/runner.rb

data/lib/atp/ast/builder.rb

@@ -1,397 +0,0 @@
-module ATP
-  module AST
-    class Builder
-      include Factories
-
-      attr_reader :context
-      attr_accessor :source_file, :source_line_number, :description
-
-      def initialize
-        @context = { conditions: [] }
-      end
-
-      def flow(str)
-        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
-
-      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, options = {})
-        test = n(:render, str)
-        if options[:conditions]
-          apply_conditions(test, options[:conditions])
-        else
-          test
-        end
-      end
-
-      def id(symbol)
-        n(:id, symbol.to_sym)
-      end
-
-      def flow_flag(name, enabled, node)
-        n(:flow_flag, name, enabled, node)
-      end
-
-      def test_result(id, passed, node)
-        n(:test_result, id, passed, node)
-      end
-
-      def test_executed(id, executed, node)
-        n(:test_executed, id, executed, node)
-      end
-
-      def job(id, enabled, node)
-        n(:job, id, enabled, node)
-      end
-
-      def run_flag(id, enabled, node)
-        n(:run_flag, id, enabled, node)
-      end
-
-      def set_run_flag(flag)
-        n(:set_run_flag, flag)
-      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)]
-
-        children << id(options[:id].to_s.downcase.to_sym) if options[:id]
-
-        children << on_fail(options[:on_fail]) if options[:on_fail]
-        children << on_pass(options[:on_pass]) if options[:on_pass]
-
-        children += nodes
-        group = n(:group, *children)
-
-        if options[:conditions]
-          apply_conditions(group, options[:conditions])
-        else
-          group
-        end
-      end
-
-      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
-        @context = { conditions: [] }
-        yield if block_given?
-        @context
-      end
-
-      CONDITION_KEYS = [
-        :if_enabled, :enabled, :enable_flag, :enable, :if_enable,
-        :unless_enabled, :not_enabled, :disabled, :disable, :unless_enable,
-        :if_failed, :unless_passed, :failed,
-        :if_passed, :unless_failed, :passed,
-        :if_ran, :if_executed,
-        :unless_ran, :unless_executed,
-        :job, :jobs, :if_job, :if_jobs,
-        :unless_job, :unless_jobs,
-        :if_any_failed, :unless_all_passed,
-        :if_all_failed, :unless_any_passed,
-        :if_any_passed, :unless_all_failed,
-        :if_all_passed, :unless_any_failed,
-        :if_flag, :unless_flag
-      ]
-
-      def apply_conditions(node, conditions)
-        conditions.each do |key, value|
-          # Sometimes conditions can be an array (in the case of the current context
-          # being re-used), so rectify that now
-          if key.is_a?(Hash)
-            fail 'Something has gone wrong applying the test conditions' if key.size > 1
-            key, value = key.first[0], key.first[1]
-          end
-          key = key.to_s.downcase.to_sym
-          # Represent all condition values as lower cased strings internally
-          if value.is_a?(Array)
-            value = value.map { |v| (v[0] == '$') ? v.to_s : v.to_s.downcase }
-          else
-            value = (value[0] == '$') ? value.to_s : value.to_s.downcase
-          end
-          context[:conditions] << { key => value }
-          case key
-          when :if_enabled, :enabled, :enable_flag, :enable, :if_enable
-            node = flow_flag(value, true, node)
-          when :unless_enabled, :not_enabled, :disabled, :disable, :unless_enable
-            node = flow_flag(value, false, node)
-          when :if_failed, :unless_passed, :failed
-            if value.is_a?(Array)
-              fail 'if_failed only accepts one ID, use if_any_failed or if_all_failed for multiple IDs'
-            end
-            node = test_result(value, false, node)
-          when :if_passed, :unless_failed, :passed
-            if value.is_a?(Array)
-              fail 'if_passed only accepts one ID, use if_any_passed or if_all_passed for multiple IDs'
-            end
-            node = test_result(value, true, node)
-          when :if_any_failed, :unless_all_passed
-            node = test_result(value, false, node)
-          when :if_all_failed, :unless_any_passed
-            node = value.reduce(nil) do |nodes, val|
-              test_result(val, false, nodes ? nodes : node)
-            end
-          when :if_any_passed, :unless_all_failed
-            node = test_result(value, true, node)
-          when :if_all_passed, :unless_any_failed
-            node = value.reduce(nil) do |nodes, val|
-              test_result(val, true, nodes ? nodes : node)
-            end
-          when :if_ran, :if_executed
-            node = test_executed(value, true, node)
-          when :unless_ran, :unless_executed
-            node = test_executed(value, false, node)
-          when :job, :jobs, :if_job, :if_jobs
-            node = job(value, true, node)
-          when :unless_job, :unless_jobs
-            node = job(value, false, node)
-          when :if_flag
-            if value.is_a?(Array)
-              fail 'if_flag only accepts one flag'
-            end
-            node = run_flag(value, true, node)
-          when :unless_flag
-            if value.is_a?(Array)
-              fail 'unless_flag only accepts one flag'
-            end
-            node = run_flag(value, false, node)
-          else
-            fail "Unknown test condition attribute - #{key} (#{value})"
-          end
-        end
-        node
-      end
-
-      def test(object, options = {})
-        children = [n(:object, object)]
-
-        n = (options[:name] || options[:tname] || options[:test_name])
-        unless n
-          [:name, :tname, :test_name].each do |m|
-            n ||= object.respond_to?(m) ? object.send(m) : nil
-          end
-        end
-        children << name(n) if n
-
-        n = (options[:number] || options[:num] || options[:tnum] || options[:test_number])
-        unless n
-          [:number, :num, :tnum, :test_number].each do |m|
-            n ||= object.respond_to?(m) ? object.send(m) : nil
-          end
-        end
-        children << number(n) if n
-
-        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]
-
-        test = n(:test, *children)
-
-        if options[:conditions]
-          apply_conditions(test, options[:conditions])
-        else
-          test
-        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]
-          fail_opts = { bin: options[:bin], softbin: options[:softbin] }
-          fail_opts[:bin_description] = options[:bin_description] if options[:bin_description]
-          fail_opts[:softbin_description] = options[:softbin_description] if options[:softbin_description]
-          children << set_result(:fail, fail_opts)
-        end
-        if options[:set_run_flag] || options[:set_flag]
-          children << set_run_flag(options[:set_run_flag] || options[:set_flag])
-        end
-        children << continue if options[:continue]
-        children << render(options[:render]) if options[:render]
-        n(:on_fail, *children)
-      end
-
-      def on_pass(options = {})
-        children = []
-        if options[:bin] || options[:softbin]
-          pass_opts = { bin: options[:bin], softbin: options[:softbin] }
-          pass_opts[:bin_description] = options[:bin_description] if options[:bin_description]
-          pass_opts[:softbin_description] = options[:softbin_description] if options[:softbin_description]
-          children << set_result(:pass, pass_opts)
-        end
-        if options[:set_run_flag] || options[:set_flag]
-          children << set_run_flag(options[:set_run_flag] || options[:set_flag])
-        end
-        children << continue if options[:continue]
-        children << render(options[:render]) if options[:render]
-        n(:on_pass, *children)
-      end
-
-      def set_result(type, options = {})
-        children = []
-        children << type
-        if options[:bin] && options[:bin_description]
-          children << n(:bin, options[:bin], options[:bin_description])
-        else
-          children << n(:bin, options[:bin]) if options[:bin]
-        end
-        if options[:softbin] && options[:softbin_description]
-          children << n(:softbin, options[:softbin], options[:softbin_description])
-        else
-          children << n(:softbin, options[:softbin]) if options[:softbin]
-        end
-        result = n(:set_result, *children)
-
-        if options[:conditions]
-          apply_conditions(result, options[:conditions])
-        else
-          result
-        end
-      end
-
-      def number(val)
-        n(:number, val.to_i)
-      end
-
-      def continue
-        n0(:continue)
-      end
-    end
-  end
-end