RubyGems - diddy - Versions diffs - 0.7.0 → 0.8.0 - Mend

diddy 0.7.0 → 0.8.0

Files changed (11) hide show

data/diddy.gemspec +2 -2
data/lib/diddy/context.rb +9 -0
data/lib/diddy/run_result.rb +119 -0
data/lib/diddy/run_result_printer.rb +74 -0
data/lib/diddy/scenario.rb +113 -0
data/lib/diddy/script.rb +67 -164
data/lib/diddy/shared_scope.rb +1 -2
data/lib/diddy/step.rb +53 -2
data/lib/diddy/steps.rb +41 -0
data/lib/diddy.rb +4 -0
metadata +7 -3

data/diddy.gemspec CHANGED Viewed

@@ -4,7 +4,7 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 Gem::Specification.new do |gem|
   gem.name          = "diddy"
-  gem.version       = '0.7.0'
+  gem.version       = '0.8.0'
   gem.authors       = ["Diederick Lawson", "Marcel de Graaf"]
   gem.email         = ["diederick@altovista.nl", "mail@marceldegraaf.net"]
   gem.description   = %q{Diddy script runner}
@@ -16,5 +16,5 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
-  gem.add_development_dependency "term/aniscolor"
+  gem.add_development_dependency "term/ansicolor"
 end

data/lib/diddy/context.rb ADDED Viewed

@@ -0,0 +1,9 @@
+module Diddy
+  class Context
+    attr_accessor :options
+    def initialize(options)
+      self.options = options
+    end
+  end
+end

data/lib/diddy/run_result.rb ADDED Viewed

@@ -0,0 +1,119 @@
+module Diddy
+  class RunResult
+    attr_accessor :scripts
+    #
+    # Starts the run of a script. Call this before running a scenario.
+    #
+    def run_script(description)
+      @scripts ||= []
+      @current_script = Script.new(description)
+      @scripts << @current_script
+    end
+    #
+    # Start the run of an entire scenario.
+    #
+    def run_scenario(description)
+      @current_scenario = Scenario.new(description)
+      @current_scenario.script = @current_script
+      @current_script.scenarios << @current_scenario
+    end
+    #
+    # Starts run of a step
+    #
+    def run_step(description)
+      @current_step = Step.new(description)
+      @current_step.scenario = @current_scenario
+      @current_scenario.steps << @current_step
+    end
+    #
+    # Starts run of a sub step
+    #
+    def run_sub_step(description)
+      @current_sub_step = SubStep.new(description)
+      @current_sub_step.step = @current_step
+      @current_step.sub_steps << @current_sub_step
+    end
+    #
+    # Sets the result of the current step
+    #
+    def set_step_result(result)
+      @current_step.result = result
+    end
+    #
+    # Sets the result to false and logs the exception of the step
+    #
+    def set_step_exception(exception)
+      @current_step.result = false
+      @current_step.exception = exception
+    end
+    #
+    # Sets the result of the sub step
+    #
+    def set_sub_step_result(result)
+      @current_sub_step.result = result
+    end
+    # helper classes
+    class Script
+      attr_accessor :scenarios, :description
+      def initialize(description)
+        self.description = description
+      end
+      def scenarios
+        @scenarios ||= []
+      end
+      def result
+        scenarios.all? { |scenario| scenario.result }
+      end
+    end
+    class Scenario
+      attr_accessor :steps, :description, :script
+      def initialize(description)
+        self.description = description
+      end
+      def steps
+        @steps ||= []
+      end
+      def result
+        steps.all? { |step| step.result }
+      end
+    end
+    class Step
+      attr_accessor :description, :sub_steps, :result, :scenario, :exception
+      def initialize(description)
+        self.description = description
+      end
+      def sub_steps
+        @sub_steps ||= []
+      end
+    end
+    class SubStep
+      attr_accessor :description, :result, :step
+      def initialize(description)
+        self.description = description
+      end
+    end
+  end
+end

data/lib/diddy/run_result_printer.rb ADDED Viewed

@@ -0,0 +1,74 @@
+module Diddy
+  class RunResultPrinter
+    attr_accessor :run_result
+    def initialize(run_result)
+      self.run_result = run_result
+    end
+    #
+    # Converts the result to HTML
+    #
+    # @TODO needs to be refactored to a templating language. Quick hack for now.
+    #
+    def to_html
+      html = "<html><head><style type='text/css'>.error { color: red }; pre { display: block; margin: 1em; };</style><title>Run results</title></head><body>"
+      # walk over all scripts
+      run_result.scripts.each do |script|
+        html << "<h2>#{script.description}</h2>"
+        # walk of the scenarios
+        script.scenarios.each do |scenario|
+          # result was ok? than only log the scenario itself
+          if scenario.result
+            html << "<h3>#{scenario.description}</h3>"
+          else
+            # log the error and it's steps
+            html << "<h3 class='error'>#{scenario.description}</h3>"
+            html << "<ul>"
+            # walk over the steps
+            scenario.steps.each do |step|
+              # output step
+              if step.result
+                html << "<li>#{step.description}"
+              else
+                html << "<li class='error'>#{step.description}"
+              end
+              # was there an exception?
+              if step.exception
+                html << "<pre>#{step.exception.message}\n\n#{step.exception.backtrace.join("\n")}</pre>"
+              end
+              # are there any sub steps?
+              if step.sub_steps.any?
+                html << "<ul>"
+                # walk over sub steps
+                step.sub_steps.each do |sub_step|
+                  if sub_step.result
+                    html << "<li>#{sub_step.description}</li>"
+                  else
+                    html << "<li class='error'>#{sub_step.description}</li>"
+                  end
+                end
+                html << "</ul></li>"
+              else
+                html << "</li>"
+              end
+            end
+            html << "</ul>"
+          end
+        end
+      end
+      html << "</body>"
+      html
+    end
+  end
+end

data/lib/diddy/scenario.rb ADDED Viewed

@@ -0,0 +1,113 @@
+module Diddy
+  #
+  # A scenario contains several steps. This is where the real work is done.
+  #
+  class Scenario
+    attr_accessor :script, :context, :description, :steps, :run_result
+    #
+    # Creates a scenario
+    #
+    def initialize(options = {})
+      options.each { |k,v| send("#{k}=", v) }
+    end
+    #
+    # Determines which step classes should be used
+    #
+    def uses(klass)
+      @steps_instances ||= []
+      @steps_instances << klass.new(shared_scope)
+    end
+    #
+    # Describes which step should be run
+    #
+    def step(description)
+      @steps ||= []
+      # find step klass
+      steps_instance = find_steps_instance_for(description)
+      # check if step exists
+      if steps_instance && steps_instance.class.has_step?(description)
+        @steps << Diddy::Step.new(
+          description:      description,
+          steps_instance:   steps_instance,
+          definition:       steps_instance.class.definition(description)
+        )
+      else
+        raise "Step '#{description}' not defined"
+      end
+    end
+    #
+    # Runs all the steps in the script
+    #
+    def run
+      begin
+        @steps.each do |step|
+          run_step(step)
+        end
+        true
+      rescue ScenarioAborted
+        false
+      end
+    end
+    #
+    # Runs one step
+    #
+    def run_step(step)
+      # run proc on this instance as scope
+      begin
+        step.run_result = run_result
+        result = step.run
+      rescue Exception => exception
+        print_exception(exception)
+        run_result.set_step_exception(exception)
+        raise ScenarioAborted.new
+      end
+      unless result
+        raise ScenarioAborted.new
+      end
+    end
+    #
+    # Prints exception thrown by step, on screen
+    #
+    def print_exception(exception)
+      print("\n")
+      # print backtrace
+      puts("- #{exception.message}")
+      puts("  #{exception.backtrace.join("\n  ")}")
+      puts("\n")
+    end
+    #
+    # Finds the instance of the steps definition by step name
+    #
+    def find_steps_instance_for(description)
+      @steps_instances.each do |instance|
+        if instance.class.steps && instance.class.steps.has_key?(description)
+          return instance
+        end
+      end
+      nil
+    end
+    def shared_scope
+      @shared_scope ||= SharedScope.new
+    end
+    class ScenarioAborted < Exception; end
+  end
+end

data/lib/diddy/script.rb CHANGED Viewed

@@ -1,216 +1,119 @@
 # encoding: utf-8
 module Diddy
+  #
+  # A script contains several scenarios. A script can be a recipe, an application etc.
+  #
   class Script
-    STATE_OK = 1
-    STATE_FAILED = 2
-    STATE_EXCEPTION = 3
+    attr_accessor :scenarios, :description, :context, :run_result
-    attr_accessor :steps, :scenario, :log
-    #
-    # Creates a script
-    #
-    def initialize(scenario)
-      @scenario = scenario
+    def initialize(description)
+      self.description = description
     end
     #
-    # Determines which step classes should be used
+    # Defines a new scenario
     #
-    def uses(klass)
-      @steps_instances ||= []
-      @steps_instances << klass.new(shared_scope)
-    end
+    #    scenario('Do something') do
+    #       uses SomeSteps
     #
-    # Full log
+    #       step 'Do this'
+    #       step 'Do that'
+    #     end
     #
-    def log
-      @log ||= ""
-    end
+    def scenario(description, &block)
+      @scenarios ||= []
-    #
-    # Describes which step should be run
-    #
-    def step(description)
-      @steps ||= []
-      # find step klass
-      steps_instance = find_steps_instance_for(description)
-      # check if step exists
-      if steps_instance && steps_instance.class.has_step?(description)
-        @steps << Diddy::Step.new(
-          description:      description,
-          steps_instance:   steps_instance,
-          definition:       steps_instance.class.definition(description)
-        )
-      else
-        raise "Step '#{description}' not defined"
-      end
+      # instantiate scenario
+      scenario = Scenario.new(
+        script: self,
+        context: context,
+        description: description,
+        run_result: run_result
+      )
+      # run the DSL
+      scenario.instance_eval(&block)
+      # add to our collection of scenarios
+      @scenarios << scenario
     end
     #
-    # Runs all the steps in the script
+    # Run the script
     #
     def run
-      begin
-        self.class.write_log(scenario)
+      scenarios.each_with_index do |scenario, index|
+        # print on screen
+        puts("Scenario #{index + 1}: #{scenario.description}")
-        @steps.each do |step|
-          run_step(step)
-        end
-        return true
+        # also log
+        run_result.run_scenario("Scenario #{index + 1}: #{scenario.description}")
-      rescue ScriptAborted
-        self.class.write_log("Aborted")
-        return false
+        # run all the steps within the scenario
+        scenario.run_result = run_result
+        scenario.run
+        puts("\n")
       end
     end
     #
-    # Returns the log of the last run
+    # Defines a new script
     #
-    def self.last_log
-      @last_log ||= ""
-    end
-    #
-    # Defines a script
+    #     Diddy::Script.define('Some recipe') do
+    #       scenario('Putting stuff in a bowl') do
+    #         step 'Put milk in it'
+    #         step 'Drink from bowl'
+    #       end
+    #     end
     #
-    #   Diddy::Script.define('Test API') do
-    #     uses ApiSteps
-    #     uses LoginSteps
-    #
-    #     step 'Do something'
-    #     step 'Do something else'
-    #   end
-    #
-    def self.define(scenario, &block)
+    def self.define(description, &block)
       @scripts ||= []
-      script = self.new(scenario)
+      script = self.new(description)
       script.instance_eval(&block)
       @scripts << script
-    end
-    #
-    # Runs all defined scripts. Returns true if and only if all indivudial
-    # scripts returned true. Otherwise returns false.
-    #
-    def self.run_all
-      # empty log
-      @last_log = ""
-      write_log("[#{Time.now}] Diddy starting to run #{@scripts.size} scripts")
-      # Run all scripts and remember their return status
-      status = @scripts.map do |script|
-        # run the script
-        result = script.run
-        # concat log of script to general log
-        write_log(script.log)
-        result
-      end
-      write_log("[#{Time.now}] Diddy finished running #{@scripts.size} scripts")
-      # If one of the scripts returned with "false"; make the entire run
-      # return false as well
-      status.include?(false) ? false : true
+      script
     end
     #
-    # Only runs given script
+    # Returns all the defined scripts
     #
-    def self.only_run(scenario)
-      @scripts.select { |script| script.scenario == scenario }.first.run
-    end
     def self.scripts
       @scripts
     end
-    private
-    def self.write_log(message, print = true)
-      puts(message) if print
-      self.last_log << "#{message}\n"
-    end
     #
-    # Runs one step
+    # Runs a given script
     #
-    def run_step(step)
-      # run proc on this instance as scope
-      begin
-        result = step.run
-      rescue Exception => exception
-        log_step(step, STATE_EXCEPTION)
-        print_exception(step, exception)
-        raise ScriptAborted.new
-      end
-      if result
-        log_step(step, STATE_OK)
-      else
-        log_step(step, STATE_FAILED)
-        raise ScriptAborted.new
-      end
-    end
+    def self.run(run_result, description, options = {})
+      # find script
+      script = scripts.find { |script| script.description == description }
+      raise CannotFindScriptError.new("Cannot find script #{description}") unless script
-    #
-    # Logs step to log
-    #
-    def log_step(step, state)
-      if state == STATE_FAILED || state == STATE_EXCEPTION
-        print(red(bold("✕ #{step.description}")))
-        self.class.write_log("✕ #{step.description}", false)
-        if state == STATE_EXCEPTION
-          print(" [EXCEPTION]")
-          print("\n\n")
-          self.class.write_log("[EXCEPTION]", false)
-        end
+      # output and run
+      if options.any?
+        vars = " (" + options.map { |k, v| "#{k}=#{v}" }.join(', ') + ")"
       else
-        print(green("✓ #{step.description}"), "\n")
-        self.class.write_log("✓ #{step.description}", false)
+        vars = ""
       end
-    end
-    #
-    # Prints exception thrown by step, on screen
-    #
-    def print_exception(current_step, exception)
-      # print backtrace
-      self.class.write_log("- #{exception.message}")
-      self.class.write_log("  #{exception.backtrace.join("\n  ")}")
-      self.class.write_log("\n")
-    end
+      # print to screen what we are doing
+      puts(bold("Running #{description}#{vars}"))
-    #
-    # Finds the instance of the steps definition by step name
-    #
-    def find_steps_instance_for(description)
-      @steps_instances.each do |instance|
-        if instance.class.steps && instance.class.steps.has_key?(description)
-          return instance
-        end
-      end
+      # also log to result logger
+      run_result.run_script("Running #{description}#{vars}")
-      nil
-    end
+      # apply the context and run result
+      script.context = Context.new(options)
+      script.run_result = run_result
-    def shared_scope
-      @shared_scope ||= SharedScope.new
+      # run the entire script
+      script.run
     end
-    class ScriptAborted < Exception; end
+    class CannotFindScriptError < StandardError; end
   end
 end

data/lib/diddy/shared_scope.rb CHANGED Viewed

@@ -9,10 +9,9 @@ module Diddy
     end
     private
     def vars
       @vars ||= {}
     end
   end
 end

data/lib/diddy/step.rb CHANGED Viewed

@@ -1,7 +1,12 @@
 # encoding: utf-8
 module Diddy
   class Step
-    attr_accessor :description, :definition, :steps_instance
+    STATE_OK = 1
+    STATE_FAILED = 2
+    STATE_EXCEPTION = 3
+    STATE_PENDING = 4
+    attr_accessor :description, :definition, :steps_instance, :run_result
     #
     # Initializes step
@@ -14,7 +19,53 @@ module Diddy
     # Runs the step
     #
     def run
-      steps_instance.instance_eval(&definition)
+      # set the sub steps to 0
+      steps_instance.sub_steps = []
+      # write to screen
+      print(blue(". #{description}"))
+      # and to log
+      run_result.run_step(description)
+      # eval the step
+      steps_instance.current_step = self
+      # run the step itself
+      result = steps_instance.instance_eval(&definition)
+      # check if there were any sub steps
+      # if so, the result is dependent of those substeps
+      if steps_instance.sub_steps.size > 0
+        # check result of all sub_steps
+        result = steps_instance.sub_steps.all? { |step| step[:valid] }
+        # also log
+        steps_instance.sub_steps.each do |sub_step|
+          run_result.run_sub_step(sub_step[:description])
+          run_result.set_sub_step_result(sub_step[:valid])
+        end
+        # faulty
+        print("\n")
+      else
+        print("\r")
+        if result
+          print(green("✓ #{description}"))
+        else
+          print(red(bold("✕ #{description}")))
+        end
+      end
+      # log result of step
+      run_result.set_step_result(result)
+      # next line
+      print("\n")
+      # return the result
+      result
     end
   end
 end

data/lib/diddy/steps.rb CHANGED Viewed

@@ -1,7 +1,10 @@
+# encoding: utf-8
 module Diddy
   class Steps
     include Helpers
+    attr_accessor :sub_steps, :current_step
     def initialize(shared_scope)
       @shared_scope = shared_scope
     end
@@ -17,6 +20,20 @@ module Diddy
     # Steps must return TRUE to keep the script running.
     # When a step returns a FALSE, it will stop the script.
     #
+    # It is also to use sub_steps (not to confuse with dubstep).
+    #
+    #   step('Do something crazy') do
+    #     sub_step('Eat brains') do
+    #       a == true
+    #     end
+    #
+    #     sub_step('Go insane') do
+    #       b == true
+    #     end
+    #   end
+    #
+    # In the case above, every sub_step needs to return true.
+    #
     def self.step(description, &block)
       @steps ||= {}
       @steps[description] = block
@@ -49,5 +66,29 @@ module Diddy
     def shared
       @shared_scope
     end
+    #
+    # Adds a sub_step
+    #
+    def sub_step(description, &block)
+      # print pending to screen
+      print("\n")
+      print(blue("  . #{description}"))
+      # yield the block
+      valid = yield(block)
+      # jump back to beginning of line
+      print("\r")
+      # print out success or failure
+      if valid
+        print(green("  ✓ #{description}"))
+      else
+        print(red(bold("  ✕ #{description}")))
+      end
+      self.sub_steps << { description: description, valid: valid }
+    end
   end
 end

data/lib/diddy.rb CHANGED Viewed

@@ -5,6 +5,10 @@ end
 require 'diddy/helpers'
 require 'diddy/script'
+require 'diddy/context'
+require 'diddy/scenario'
 require 'diddy/step'
 require 'diddy/steps'
+require 'diddy/run_result'
+require 'diddy/run_result_printer'
 require 'diddy/shared_scope'

metadata CHANGED Viewed

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: diddy
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
   prerelease:
 platform: ruby
 authors:
@@ -10,10 +10,10 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-02-28 00:00:00.000000000 Z
+date: 2013-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: term/aniscolor
+  name: term/ansicolor
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
@@ -43,7 +43,11 @@ files:
 - diddy-0.1.0.gem
 - diddy.gemspec
 - lib/diddy.rb
+- lib/diddy/context.rb
 - lib/diddy/helpers.rb
+- lib/diddy/run_result.rb
+- lib/diddy/run_result_printer.rb
+- lib/diddy/scenario.rb
 - lib/diddy/script.rb
 - lib/diddy/shared_scope.rb
 - lib/diddy/step.rb