atp 0.1.0 → 0.2.0

data/lib/atp/processors/post_cleaner.rb

@@ -0,0 +1,43 @@
+module ATP
+  module Processors
+    # Runs at the very end of a processor run, to do some final cleanup,
+    # e.g. to assign generated IDs to tests that don't have one
+    class PostCleaner < Processor
+      # Returns a hash containing the IDs of all tests that have
+      # been used
+      attr_reader :ids
+
+      # Extracts all ID values of tests within the given AST
+      class ExtractTestIDs < Processor
+        attr_reader :results
+
+        def on_test(node)
+          id = node.children.find { |n| n.type == :id }
+          if id
+            @results ||= {}
+            @results[id] = true
+          end
+        end
+      end
+
+      def process(node)
+        # On first call extract the test_result nodes from the given AST,
+        # then process as normal thereafter
+        if @first_call_done
+          result = super
+        else
+          @first_call_done = true
+          t = ExtractTestIDs.new
+          t.process(node)
+          @ids = t.results || {}
+          result = super
+          @first_call_done = false
+        end
+        result
+      end
+
+      def on_test(node)
+      end
+    end
+  end
+end

data/lib/atp/processors/pre_cleaner.rb

@@ -0,0 +1,43 @@
+module ATP
+  module Processors
+    # Modifies the AST by performing some basic clean up, mainly to sanitize
+    # user input. For example it will ensure that all IDs are symbols, and that
+    # all names are lower-cased strings.
+    class PreCleaner < Processor
+      def initialize
+        @group_ids = []
+      end
+
+      def on_id(node)
+        id = node.to_a.first
+        id = id.to_s.downcase.to_sym
+        node.updated(nil, [id])
+      end
+
+      def on_group(node)
+        if id = node.children.find { |n| n.type == :id }
+          @group_ids << process(id).value
+        else
+          @group_ids << nil
+        end
+        group = node.updated(nil, process_all(node.children))
+        @group_ids.pop
+        group
+      end
+
+      def on_test(node)
+        # Remove IDs nodes from test nodes if they refer to the ID of a parent group
+        if @group_ids.last
+          children = node.children.reject do |n|
+            if n.type == :id
+              @group_ids.last == process(n).value
+            end
+          end
+        else
+          children = node.children
+        end
+        node.updated(nil, process_all(children))
+      end
+    end
+  end
+end

data/lib/atp/processors/relationship.rb

@@ -0,0 +1,154 @@
+module ATP
+  module Processors
+    # This processor will apply the relationships between tests, e.g. if testB should only
+    # execute if testA passes, then this processor will update the AST to make testA set
+    # a flag on pass, and then update testB to only run if that flag is set.
+    class Relationship < Processor
+      # Returns a hash containing the IDs of all tests that have dependents
+      attr_reader :test_results
+
+      # Extracts all test-result nodes from the given AST
+      class ExtractTestResults < Processor
+        attr_reader :results
+
+        def on_test_result(node)
+          ids, state, *children = *node
+          unless ids.is_a?(Array)
+            ids = [ids]
+          end
+          ids.each do |id|
+            results[id] ||= {}
+            if state
+              results[id][:passed] = true
+            else
+              results[id][:failed] = true
+            end
+          end
+          process_all(children)
+        end
+
+        def on_test_executed(node)
+          id, state, *children = *node
+          id, state = *node
+          results[id] ||= {}
+          results[id][:executed] = true
+          process_all(children)
+        end
+
+        def results
+          @results ||= {}.with_indifferent_access
+        end
+      end
+
+      def process(node)
+        # On first call extract the test_result nodes from the given AST,
+        # then process as normal thereafter
+        if @first_call_done
+          result = super
+        else
+          @first_call_done = true
+          t = ExtractTestResults.new
+          t.process(node)
+          @test_results = t.results || {}
+          result = super
+          @first_call_done = false
+        end
+        result
+      end
+
+      def add_pass_flag(id, node)
+        node = node.ensure_node_present(:on_pass)
+        node = node.ensure_node_present(:on_fail)
+        node.updated(nil, node.children.map do |n|
+          if n.type == :on_pass
+            n = n.add n1(:set_run_flag, "#{id}_PASSED")
+          elsif n.type == :on_fail
+            n.ensure_node_present(:continue)
+          else
+            n
+          end
+        end)
+      end
+
+      def add_fail_flag(id, node)
+        node = node.ensure_node_present(:on_fail)
+        node.updated(nil, node.children.map do |n|
+          if n.type == :on_fail
+            n = n.add n1(:set_run_flag, "#{id}_FAILED")
+            n.ensure_node_present(:continue)
+          else
+            n
+          end
+        end)
+      end
+
+      def add_executed_flag(id, node)
+        node = node.ensure_node_present(:on_fail)
+        node = node.ensure_node_present(:on_pass)
+        node.updated(nil, node.children.map do |n|
+          if n.type == :on_pass || n.type == :on_fail
+            n = n.add n1(:set_run_flag, "#{id}_RAN")
+          else
+            n
+          end
+        end)
+      end
+
+      # Set flags depending on the result on tests which have dependents later
+      # in the flow
+      def on_test(node)
+        nid = id(node)
+        # If this test has a dependent
+        if test_results[nid]
+          node = add_pass_flag(nid, node) if test_results[nid][:passed]
+          node = add_fail_flag(nid, node) if test_results[nid][:failed]
+          node = add_executed_flag(nid, node) if test_results[nid][:executed]
+        end
+        if node.type == :group
+          node.updated(nil, process_all(node))
+        else
+          node
+        end
+      end
+      alias_method :on_group, :on_test
+
+      # Remove test_result nodes and replace with references to the flags set
+      # up stream by the parent node
+      def on_test_result(node)
+        children = node.children.dup
+        id = children.shift
+        state = children.shift
+        if state
+          n(:run_flag, [id_to_flag(id, 'PASSED'), true] + process_all(children))
+        else
+          n(:run_flag, [id_to_flag(id, 'FAILED'), true] + process_all(children))
+        end
+      end
+
+      # Remove test_result nodes and replace with references to the flags set
+      # up stream by the parent node
+      def on_test_executed(node)
+        children = node.children.dup
+        id = children.shift
+        state = children.shift
+        n(:run_flag, [id_to_flag(id, 'RAN'), state] + children)
+      end
+
+      # Returns the ID of the give test node (if any), caller is responsible
+      # for only passing test nodes
+      def id(node)
+        if n = node.children.find { |c| c.type == :id }
+          n.children.first
+        end
+      end
+
+      def id_to_flag(id, type)
+        if id.is_a?(Array)
+          id.map { |i| "#{i}_#{type}" }
+        else
+          "#{id}_#{type}"
+        end
+      end
+    end
+  end
+end

data/lib/atp/program.rb

@@ -0,0 +1,27 @@
+module ATP
+  # Program is the top-level container for a collection of test flows
+  class Program
+    def flow(name)
+      flows[name] ||= Flow.new(self)
+    end
+
+    def flows
+      @flows ||= {}
+    end
+
+    def respond_to?(*args)
+      flows.key?(args.first) || super
+    end
+
+    def method_missing(method, *args, &block) # :nodoc:
+      if f = flows[method]
+        define_singleton_method method do
+          f
+        end
+        f
+      else
+        super
+      end
+    end
+  end
+end

data/lib/atp/runner.rb

@@ -0,0 +1,53 @@
+module ATP
+  # This class is responsible for executing the given test flow based on a given
+  # set of runtime conditions.
+  # A subset of the input AST will be returned containing only the nodes that would
+  # be hit when the flow is executed under the given conditions.
+  class Runner < Processor
+    def run(node, options = {})
+      @options = options
+      process(node)
+    end
+
+    def on_flow(node)
+      @flow = []
+      process_all(node.children)
+      node.updated(nil, @flow)
+    end
+
+    def on_flow_flag(node)
+      flag, enabled, *nodes = *node
+      if (enabled && flow_flags.include?(flag)) ||
+         (!enabled && !flow_flags.include?(flag))
+        process_all(nodes)
+      end
+    end
+
+    def on_test(node)
+      if id = node.find(:id)
+        id = id.to_a[0]
+        if failed_test_ids.include?(id)
+          node = node.add(n0(:failed))
+        end
+      end
+      @flow << node
+    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
+    end
+
+    def failed_test_ids
+      @failed_test_ids ||= [@options[:failed_test_id] || @options[:failed_test_ids]].flatten.compact
+    end
+
+    # Returns an array of enabled flow flags
+    def flow_flags
+      @flow_flags ||= [@options[:flow_flag] || @options[:flow_flags]].flatten.compact
+    end
+  end
+end

data/lib/atp/validators/condition.rb

@@ -0,0 +1,4 @@
+module ATP
+  module Validators
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: atp
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Stephen McGinty
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-07 00:00:00.000000000 Z
+date: 2016-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: origen
@@ -16,14 +16,42 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.6
+        version: 0.2.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.0.6
+        version: 0.2.3
+- !ruby/object:Gem::Dependency
+  name: ast
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: sexpistol
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
 description: 
 email:
 - stephen.f.mcginty@gmail.com
@@ -32,13 +60,30 @@ extensions: []
 extra_rdoc_files: []
 files:
 - config/application.rb
+- config/boot.rb
 - config/commands.rb
-- config/development.rb
-- config/environment.rb
-- config/users.rb
 - config/version.rb
 - lib/atp.rb
-- lib/atp/top_level.rb
+- lib/atp/and.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/formatter.rb
+- lib/atp/formatters/basic.rb
+- lib/atp/formatters/datalog.rb
+- lib/atp/not.rb
+- lib/atp/or.rb
+- lib/atp/parser.rb
+- lib/atp/processor.rb
+- lib/atp/processors/condition.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/validators/condition.rb
 - lib/tasks/atp.rake
 - templates/web/archive.md.erb
 - templates/web/contact.md.erb
@@ -46,7 +91,7 @@ files:
 - templates/web/layouts/_basic.html.erb
 - templates/web/partials/_navbar.html.erb
 - templates/web/release_notes.md.erb
-homepage: http://origen.freescale.net/atp
+homepage: http://origen-sdk.org/atp
 licenses: []
 metadata: {}
 post_install_message: 
@@ -65,7 +110,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.8.11
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: An abstract test program model for Origen

data/config/development.rb

@@ -1,12 +0,0 @@
-# This file is similar to environment.rb and will be loaded
-# automatically at the start of each invocation of Origen.
-#
-# However the major difference is that it will not be loaded
-# if the application is imported by a 3rd party app - in that
-# case only environment.rb is loaded.
-#
-# Therefore this file should be used to load anything you need
-# to setup a development environment for this app, normally
-# this would be used to load some dummy classes to instantiate
-# your objects so that they can be tested and/or interacted with
-# in the console.