atp 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 31ba0f5ad78ad309c007c6051c63abc61869d515
-  data.tar.gz: 1506ab571ab5b6e8fe5c992bb95e81a7d866c8a7
+  metadata.gz: 7ca6eaefd174b135c5b39a8b2d287f24cd890814
+  data.tar.gz: 3c379de6d014a88c5dbec902ec85eda2d4d1abd6
 SHA512:
-  metadata.gz: 457369eaa2650117fd6477073cf192368c7041782001852498119363e5940cd4048923b93194d072400dc4430f4f05eb5b67f40da5115994c7e57e495c971a5b
-  data.tar.gz: 28f04f8b24bb72b32b0816d97833dfeb70809562967f7b13f1cfb096c0e9dd0b2affa38f7f0e4ad43f64a4a95c66ccfa8c1c363fbff0eb2560ff68c1d139c19d
+  metadata.gz: ec297a8c950f05a49eaa17c359d5c35378aea3e9a1e39f88f3c72906968658dc22e61590357f83b462f25dab699a1577d7d334efdb26d126b0f3694a159eaa9f
+  data.tar.gz: 1fc8899484368c2fc172801ba5bae1968fd9488d52420d0f0c30e1275a9db41783ab2886536317ca5744e2b7222badee59a9e6d5006d373b827f6e90d3bb6d80

data/config/commands.rb

@@ -29,13 +29,13 @@ when "my_command"
   # control flowing back to Origen
   exit 0
 
-## Example of how to make a command to run unit tests, this simply invokes RSpec on
-## the spec directory
-#when "specs"
-#  ARGV.unshift "spec"
-#  require "rspec"
-#  require "rspec/autorun"
-#  exit 0 # This will never be hit on a fail, RSpec will automatically exit 1
+# Example of how to make a command to run unit tests, this simply invokes RSpec on
+# the spec directory
+when "specs"
+  ARGV.unshift "spec"
+  require "rspec"
+  require "rspec/autorun"
+  exit 0 # This will never be hit on a fail, RSpec will automatically exit 1
 
 ## Example of how to make a command to run diff-based tests
 #when "examples"  
@@ -68,9 +68,9 @@ else
   # You probably want to also add the your commands to the help shown via
   # origen -h, you can do this be assigning the required text to @application_commands
   # before handing control back to Origen. Un-comment the example below to get started.
-#  @application_commands = <<-EOT
-# specs        Run the specs (tests), -c will enable coverage
+  @application_commands = <<-EOT
+ specs        Run the specs (tests), -c will enable coverage
+  EOT
 # examples     Run the examples (tests), -c will enable coverage
-#  EOT
 
 end 

data/config/version.rb

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

data/lib/atp.rb

@@ -1,15 +1,59 @@
 require 'origen'
-require_relative '../config/application.rb'     
+require_relative '../config/application.rb'
 module ATP
+  autoload :Program, 'atp/program'
+  autoload :Flow, 'atp/flow'
+  autoload :Processor, 'atp/processor'
+  autoload :Runner, 'atp/runner'
+  autoload :Formatter, 'atp/formatter'
+  autoload :Parser, 'atp/parser'
+  autoload :AND, 'atp/and'
+  autoload :OR, 'atp/or'
+  autoload :NOT, 'atp/not'
 
-  # Load all files in the lib directory via a wildcard, if your project becomes
-  # large or load order dependencies start to creep in then you may need to
-  # start taking control of this manually as described above.
-  # Note that there is no problem from requiring a file twice (Ruby will ignore
-  # the second require), so if you have a file that must be required up front
-  # you can do that one manually and the let the wildcard take care of the rest.
-  Dir.glob("#{File.dirname(__FILE__)}/**/*.rb").sort.each do |file| 
-    require file
+  module AST
+    autoload :Node, 'atp/ast/node'
+    autoload :Builder, 'atp/ast/builder'
+    autoload :Factories, 'atp/ast/factories'
+    autoload :Extractor, 'atp/ast/extractor'
   end
 
+  # Processors actually modify the AST to clean and optimize the user input
+  # and to implement the flow control API
+  module Processors
+    autoload :Condition,    'atp/processors/condition'
+    autoload :Relationship, 'atp/processors/relationship'
+    autoload :PreCleaner, 'atp/processors/pre_cleaner'
+    autoload :PostCleaner, 'atp/processors/post_cleaner'
+  end
+
+  # Summarizers extract summary data from the given AST
+  module Summarizers
+  end
+
+  # 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 :Condition, 'atp/validators/condition'
+  end
+
+  # Formatters are run on the processed AST to display the flow or to render
+  # it to a different format
+  module Formatters
+    autoload :Basic,   'atp/formatters/basic'
+    autoload :Datalog, 'atp/formatters/datalog'
+    autoload :Graph,   'atp/formatters/graph'
+  end
+
+  def self.or(*args)
+    OR.new(*args)
+  end
+
+  def self.and(*args)
+    AND.new(*args)
+  end
+
+  def self.not(*args)
+    NOT.new(*args)
+  end
 end

data/lib/atp/and.rb

@@ -0,0 +1,11 @@
+module ATP
+  class AND < ::Array
+    def initialize(*vals)
+      vals.flatten.each { |v| self << v }
+    end
+
+    def inspect
+      "AND#{super}"
+    end
+  end
+end

data/lib/atp/ast/builder.rb

@@ -0,0 +1,214 @@
+module ATP
+  module AST
+    class Builder
+      include Factories
+
+      attr_reader :context
+
+      def flow
+        n0(:flow)
+      end
+
+      def name(str)
+        n(:name, str.to_s)
+      end
+
+      def log(str)
+        n(:log, str.to_s)
+      end
+
+      def render(str)
+        n(:render, str.to_s)
+      end
+
+      def description(str)
+        n(:description, str.to_s)
+      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 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 << n(:members, *nodes)
+        group = n(:group, *children)
+
+        if options[:conditions]
+          apply_conditions(group, options[:conditions])
+        else
+          group
+        end
+      end
+
+      def cz(setup, node)
+        n(:cz, setup, node)
+      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
+      ]
+
+      def apply_conditions(node, conditions)
+        conditions.each do |key, value|
+          key = key.to_s.downcase.to_sym
+          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
+            # Make sure these are wrapped by an OR, AND jobs doesn't make sense anyway
+            unless value.is_a?(OR)
+              value = ATP.or(value)
+            end
+            node = n(:job, apply_boolean(value), node)
+          when :unless_job, :unless_jobs
+            # Make sure these are wrapped by an OR, AND jobs doesn't make sense anyway
+            unless value.is_a?(OR)
+              value = ATP.or(value)
+            end
+            node = n(:job, apply_boolean(ATP.not(value)), node)
+          else
+            fail "Unknown test condition attribute - #{key} (#{value})"
+          end
+        end
+        node
+      end
+
+      def apply_boolean(value)
+        if value.is_a?(OR)
+          n(:or, *value.map { |v| apply_boolean(v) })
+        elsif value.is_a?(AND)
+          n(:and, *value.map { |v| apply_boolean(v) })
+        elsif value.is_a?(NOT)
+          n(:not, apply_boolean(value.value))
+        else
+          value
+        end
+      end
+
+      def test(object, options = {})
+        children = [n(:object, object)]
+
+        if n = (options[:name] || options[:tname] || options[:test_name])
+          children << name(n)
+        end
+        if n = (options[:number] || options[:num] || options[:tnum] || options[:test_number])
+          children << number(n)
+        end
+        d = options[:description] || options[:desc]
+        children << description(d) if d
+        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]
+
+        test = n(:test, *children)
+
+        if options[:conditions]
+          apply_conditions(test, options[:conditions])
+        else
+          test
+        end
+      end
+
+      def on_fail(options = {})
+        children = []
+        if options[:bin] || options[:softbin]
+          children << set_result(:fail, bin: options[:bin], softbin: options[:softbin], description: options[:bin_description])
+        end
+        children << continue if options[:continue]
+        n(:on_fail, *children)
+      end
+
+      def on_pass(options = {})
+        children = []
+        if options[:bin] || options[:softbin]
+          children << set_result(:pass, bin: options[:bin], softbin: options[:softbin], description: options[:bin_description])
+        end
+        children << continue if options[:continue]
+        n(:on_pass, *children)
+      end
+
+      def set_result(type, options = {})
+        children = []
+        children << type
+        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)
+      end
+
+      def number(val)
+        n(:number, val.to_i)
+      end
+
+      def continue
+        n0(:continue)
+      end
+    end
+  end
+end

data/lib/atp/ast/extractor.rb

@@ -0,0 +1,26 @@
+require 'ast'
+module ATP
+  module AST
+    class Extractor
+      include ::AST::Processor::Mixin
+
+      attr_reader :types
+      attr_reader :results
+
+      def process(node, types = nil)
+        if types
+          @types = types
+          @results = []
+          # node = AST::Node.new(:wrapper, node) unless node.respond_to?(:to_ast)
+        end
+        super(node) if node.respond_to?(:to_ast)
+        results
+      end
+
+      def handler_missing(node)
+        @results << node if types.include?(node.type)
+        process_all(node.children)
+      end
+    end
+  end
+end

data/lib/atp/ast/factories.rb

@@ -0,0 +1,13 @@
+module ATP
+  module AST
+    module Factories
+      def n(type, *children)
+        ATP::AST::Node.new(type, children)
+      end
+
+      def n0(type)
+        ATP::AST::Node.new(type, [])
+      end
+    end
+  end
+end

data/lib/atp/ast/node.rb

@@ -0,0 +1,71 @@
+require 'ast'
+module ATP
+  module AST
+    class Node < ::AST::Node
+      include Factories
+
+      def initialize(type, children = [], properties = {})
+        # Always use strings instead of symbols in the AST, makes serializing
+        # back and forward to a string easier
+        children = children.map { |c| c.is_a?(Symbol) ? c.to_s : c }
+        super type, children, properties
+      end
+
+      # Create a new node from the given S-expression (a string)
+      def self.from_sexp(sexp)
+        @parser ||= Parser.new
+        @parser.string_to_ast(sexp)
+      end
+
+      # 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)
+        if children.any? { |n| n.type == type }
+          self
+        else
+          updated(nil, children + [n0(type)])
+        end
+      end
+
+      # Returns the value at the root of an AST node like this:
+      #
+      #   node # => (module-def
+      #               (module-name
+      #                 (SCALAR-ID "Instrument"))
+      #
+      #   node.value  # => "Instrument"
+      #
+      # No error checking is done and the caller is responsible for calling
+      # this only on compatible nodes
+      def value
+        val = children.first
+        val = val.children.first while val.respond_to?(:children)
+        val
+      end
+
+      # Add the given nodes to the children
+      def add(*nodes)
+        updated(nil, children + nodes)
+      end
+
+      # Returns the first child node of the given type that is found
+      def find(type)
+        nodes = find_all(type)
+        nodes.first
+      end
+
+      # Returns an array containing all child nodes of the given type(s)
+      def find_all(*types)
+        Extractor.new.process(self, types)
+      end
+
+      def to_h
+        h = {}
+        children.each do |node|
+          h[node.type] = node.children.map { |n| n.is_a?(AST::Node) ? n.to_h : n }
+        end
+        h
+      end
+    end
+  end
+end