bts-cucumber 0.1.13.1

data/lib/cucumber/executor.rb

@@ -0,0 +1,188 @@
+module Cucumber
+  class Executor
+    attr_reader :failed
+    attr_accessor :formatters
+    attr_writer :scenario_names, :lines_for_features
+
+    def initialize(step_mother)
+      @world_procs = []
+      @before_scenario_procs = []
+      @after_scenario_procs = []
+      @after_step_procs = []
+      @step_mother = step_mother
+
+      @executed_scenarios = {}
+      @regular_scenario_cache = {}
+    end
+
+    def register_world_proc(&proc)
+      @world_procs << proc
+    end
+
+    def register_before_scenario_proc(&proc)
+      proc.extend(CoreExt::CallIn)
+      @before_scenario_procs << proc
+    end
+
+    def register_after_scenario_proc(&proc)
+      proc.extend(CoreExt::CallIn)
+      @after_scenario_procs << proc
+    end
+
+    def register_after_step_proc(&proc)
+      proc.extend(CoreExt::CallIn)
+      @after_step_procs << proc
+    end
+
+    def visit_features(features)
+      formatters.visit_features(features)
+      features.accept(self)
+      formatters.dump
+    end
+
+    def visit_feature(feature)
+      @feature_file = feature.file
+            
+      if accept_feature?(feature)
+        formatters.feature_executing(feature)
+        feature.accept(self)
+        @executed_scenarios = {}
+        @regular_scenario_cache = {}
+      end
+    end
+
+    def visit_header(header)
+      formatters.header_executing(header)
+    end
+
+    def visit_row_scenario(scenario)
+      execute_scenario(@regular_scenario_cache[scenario.name]) if executing_unprepared_row_scenario?(scenario)
+      visit_scenario(scenario)
+    end
+
+    def visit_regular_scenario(scenario)
+      @regular_scenario_cache[scenario.name] = scenario
+      visit_scenario(scenario)
+    end
+
+    def visit_scenario(scenario)
+      if accept_scenario?(scenario)
+        @executed_scenarios[scenario.name] = true
+        execute_scenario(scenario)
+      end
+    end
+
+    def execute_scenario(scenario)
+      @error = nil
+      @pending = nil
+
+      @world = create_world
+      @world.extend(Spec::Matchers) if defined?(Spec::Matchers)
+      define_step_call_methods(@world)
+
+      formatters.scenario_executing(scenario)
+      @before_scenario_procs.each{|p| p.call_in(@world, *[])}
+      scenario.accept(self)
+      @after_scenario_procs.each{|p| p.call_in(@world, *[])}
+      formatters.scenario_executed(scenario)
+    end
+    
+    def accept_scenario?(scenario)
+      scenario_at_specified_line?(scenario) &&
+      scenario_has_specified_name?(scenario)
+    end
+
+    def accept_feature?(feature)
+      feature.scenarios.any? { |s| accept_scenario?(s) }
+    end
+
+    def visit_row_step(step)
+      visit_step(step)
+    end
+
+    def visit_regular_step(step)
+      visit_step(step)
+    end
+
+    def visit_step(step)
+      unless @pending || @error
+        begin
+          regexp, args, proc = step.regexp_args_proc(@step_mother)
+          formatters.step_executing(step, regexp, args)
+          step.execute_in(@world, regexp, args, proc)
+          @after_step_procs.each{|p| p.call_in(@world, *[])}
+          formatters.step_passed(step, regexp, args)
+        rescue Pending
+          record_pending_step(step, regexp, args)
+        rescue => e
+          @failed = true
+          @error = step.error = e
+          formatters.step_failed(step, regexp, args)
+        end
+      else
+        begin
+          regexp, args, proc = step.regexp_args_proc(@step_mother)
+          step.execute_in(@world, regexp, args, proc)
+          formatters.step_skipped(step, regexp, args)
+        rescue Pending
+          record_pending_step(step, regexp, args)
+        rescue Exception
+          formatters.step_skipped(step, regexp, args)
+        end
+      end
+    end
+
+    def record_pending_step(step, regexp, args)
+      @pending = true
+      formatters.step_pending(step, regexp, args)
+    end
+
+    def define_step_call_methods(world)
+      world.instance_variable_set('@__executor', self)
+      world.instance_eval do
+        class << self
+          def run_step(name)
+            _, args, proc = @__executor.instance_variable_get(:@step_mother).regexp_args_proc(name)
+            proc.call_in(self, *args)
+          end
+
+          %w{given when then and but}.each do |keyword|
+            alias_method Cucumber.language[keyword], :run_step
+          end
+        end
+      end
+    end
+    
+    def executing_unprepared_row_scenario?(scenario)
+      accept_scenario?(scenario) && !@executed_scenarios[scenario.name]
+    end
+    
+    def scenario_at_specified_line?(scenario)
+      if lines_defined_for_current_feature?
+        @lines_for_features[@feature_file].inject(false) { |at_line, line| at_line || scenario.at_line?(line) }
+      else
+        true
+      end
+    end
+    
+    def scenario_has_specified_name?(scenario)
+      if @scenario_names && !@scenario_names.empty?
+        @scenario_names.include?(scenario.name)
+      else
+        true
+      end
+    end
+    
+    def lines_defined_for_current_feature?
+      @lines_for_features && !@lines_for_features[@feature_file].nil? && !@lines_for_features[@feature_file].empty?
+    end
+    
+    def create_world
+      world = Object.new
+      @world_procs.each do |world_proc|
+        world = world_proc.call(world)
+      end
+      world
+    end
+  end
+end

data/lib/cucumber/formatters/ansicolor.rb

@@ -0,0 +1,109 @@
+# Hack to work around Win32/Console, which bundles a licence-violating, outdated
+# copy of term/ansicolor that doesn't implement Term::ANSIColor#coloring=. 
+# We want the official one!
+gem 'term-ansicolor'
+$LOAD_PATH.each{|path| $LOAD_PATH.unshift($LOAD_PATH.delete(path)) if path =~ /term-ansicolor/}
+require 'term/ansicolor'
+
+if $CUCUMBER_WINDOWS_MRI
+  begin
+    require 'Win32/Console/ANSI' 
+  rescue LoadError
+    STDERR.puts "You must gem install win32console to get coloured output on MRI/Windows"
+    Term::ANSIColor.coloring = false
+  end
+end
+
+Term::ANSIColor.coloring = false if !STDOUT.tty? || ($CUCUMBER_WINDOWS && !$CUCUMBER_WINDOWS_MRI)
+
+module Cucumber
+  module Formatters
+    # Adds ANSI color support to formatters.
+    # You can define your own colours by defining CUCUMBER_COLORS in your shell. Example:
+    #
+    #   CUCUMBER_COLORS=pending=black,on_yellow:failed=dark,magenta:failed_param=bold,red
+    # 
+    # The string must be a series of key=value pairs where:
+    #
+    #   * Each key=value pair is separated by a colon (:)
+    #   * Each key must be one of:
+    #   ** passed
+    #   ** passed_param
+    #   ** failed
+    #   ** failed_param
+    #   ** skipped
+    #   ** skipped_param
+    #   ** pending
+    #   * Each value must be a comma-separated string composed of:
+    #   ** bold
+    #   ** dark
+    #   ** italic
+    #   ** underline
+    #   ** underscore
+    #   ** blink
+    #   ** rapid_blink
+    #   ** negative
+    #   ** concealed
+    #   ** strikethrough
+    #   ** black
+    #   ** red
+    #   ** green
+    #   ** yellow
+    #   ** blue
+    #   ** magenta
+    #   ** cyan
+    #   ** white
+    #   ** grey
+    #   ** on_black
+    #   ** on_red
+    #   ** on_green
+    #   ** on_yellow
+    #   ** on_blue
+    #   ** on_magenta
+    #   ** on_cyan
+    #   ** on_white
+    #
+    module ANSIColor
+      include ::Term::ANSIColor
+
+      # Params are underlined bold, except in windows, which doesn't support underline. Use non-bold colour.
+      param = PLATFORM =~ /mswin|mingw/ ? '' : 'underline,bold,'
+
+      # Default aliases
+      ALIASES = {
+        :passed        => 'bold,green',
+        :passed_param  => "#{param}green",
+        :failed        => 'bold,red',
+        :failed_param  => "#{param}red",
+        :skipped       => 'bold,cyan',
+        :skipped_param => "#{param}cyan",
+        :pending       => 'bold,yellow', # No pending_param
+        :comment       => 'grey'
+      }
+      if ENV['CUCUMBER_COLORS']
+        ENV['CUCUMBER_COLORS'].split(':').each do |pair|
+          a = pair.split('=')
+          ALIASES[a[0].to_sym] = a[1]
+        end
+      end
+      
+      # Not supported in Term::ANSIColor
+      def grey(m)
+        if ::Term::ANSIColor.coloring?
+          "\e[90m#{m}\e[0m" 
+        else
+          m
+        end
+      end
+      
+      ALIASES.each do |m, color_string|
+        colors = color_string.split(",").reverse
+        define_method(m) do |*s|
+          clear + colors.inject(s[0]) do |memo, color|
+            s[0].nil? ? __send__(color) + memo.to_s : __send__(color, memo.to_s)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/formatters/autotest_formatter.rb

@@ -0,0 +1,23 @@
+require 'cucumber/formatters/ansicolor'
+
+module Cucumber
+  module Formatters
+    class AutotestFormatter
+      def initialize(io)
+        @io = io
+        @failed_scenarios = []
+      end
+      
+      def step_didnt_pass(step, regexp, args)
+        unless @failed_scenarios.include? step.scenario.name
+          @failed_scenarios << step.scenario.name
+          @io.puts step.scenario.name
+        end
+      end
+      
+      alias step_failed  step_didnt_pass
+      alias step_pending step_didnt_pass
+      alias step_skipped step_didnt_pass
+    end
+  end
+end

data/lib/cucumber/formatters/cucumber.css

@@ -0,0 +1,132 @@
+body {
+  background: #fff;
+  font-size: 80%;
+  margin:0pt;
+  padding:0pt;
+}
+
+#container {
+  background:white none repeat scroll 0%;
+  font-family:Helvetica,Arial,sans-serif;
+  margin:0pt auto;
+  position:relative;
+  text-align:left;
+  top:1.0em;
+  width:78em;
+}
+
+span {
+ font-weight: bold;
+ text-decoration: underline;
+}
+
+dl {
+  font: normal 11px "Lucida Grande", Helvetica, sans-serif;
+  margin-left: 5px;
+}
+
+dl.new {
+  border-left: 5px solid #444444;
+}
+
+dl.pending {
+  border-left: 5px solid #FAF834;
+}
+
+dl.failed {
+  border-left: 5px solid #C20000;
+}
+
+dl.passed {
+  border-left: 5px solid #65C400;
+}
+
+dt {
+  color: #fff;
+  padding: 3px;
+  font-weight: bold;
+}
+
+dl.new > dt {
+  background: #444444;
+}
+
+dl.pending > dt {
+  color: #131313;
+  background: #FAF834;
+}
+
+dl.failed > dt {
+  background: #C20000;
+}
+
+dl.passed > dt {
+  background: #65C400;
+}
+
+dd {
+  margin: 0px 0px 0px 0px;
+}
+
+dd p, pre {
+  padding: 5px;
+  margin-top: 0;
+  margin-bottom: 5px;
+}
+
+dl.passed > dd > p, li.passed {
+  background: #DBFFB4; color: #3D7700;
+  border-bottom: 1px solid #65C400;
+}
+
+dl.failed > dd > p, li.failed {
+  color: #C20000; background: #FFFBD3;
+  border-bottom: 1px solid #C20000;
+}
+
+dl.pending > dd > p, li.pending {
+  color: #131313; background: #FCFB98;
+  border-bottom: 1px solid #FAF834;
+}
+
+dl.new > dd > p, li.new {
+  color: #444444; background: #DDDDDD;
+  border-bottom: 1px solid #444444;
+}
+
+span.param, span.param_editor {
+  font-weight: bold;
+}
+
+input {
+  width: 100%;
+}
+
+ul {
+  padding: 0px;
+  list-style: none;
+}
+
+ul > li {
+  margin: 5px 0px 5px 5px;
+  padding: 3px 3px 3px 5px;
+}
+
+div.auto_complete ul {
+  list-style-type: none;
+  border: 2px solid #F0F0F0;
+  margin: 0px;
+  padding: 0px;
+}
+
+div.auto_complete ul li {
+  background-color: white;
+  list-style-type: none;
+  display: block;
+  margin: 0;
+  padding: 2px;
+}
+
+div.auto_complete ul li.selected {
+  color: #444444; background: #DDDDDD;
+}

data/lib/cucumber/formatters/cucumber.js

@@ -0,0 +1,11 @@
+function stepPassed(id) {
+  $("#"+id).removeClass("new").addClass("passed");
+}
+
+function stepPending(id) {
+  $("#"+id).removeClass("new").addClass("pending");
+}
+
+function stepFailed(id, message, backtrace) {
+  $("#"+id).removeClass("new").addClass("failed").append("<div>" + message + "</div>").append("<pre>" + backtrace + "</pre>");
+}

data/lib/cucumber/formatters/html_formatter.rb

@@ -0,0 +1,128 @@
+module Cucumber
+  module Formatters
+    class HtmlFormatter
+      def initialize(io, step_mother)
+        @io = io
+        @step_mother = step_mother
+        @errors = []
+        @scenario_table_header = []
+      end
+
+      def visit_features(features)
+        # IMPORTANT NOTICE ABOUT JQUERY BELOW. THE ORIGINAL BACKSLASHES (\) HAVE
+        # BEEN REPLACED BY DOUBLE BACKSLASHES (\\) IN THIS FILE TO MAKE SURE THEY
+        # ARE PRINTED PROPERLY WITH ONLY ONE BACKSLASH (\).
+        @io.puts(<<-HTML)
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html 
+  PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
+  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <title>#{Cucumber.language['feature']}</title>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <meta http-equiv="Expires" content="-1" />
+    <meta http-equiv="Pragma" content="no-cache" />
+    <script type="text/javascript">
+#{IO.read(File.dirname(__FILE__) + '/jquery.js')}
+#{IO.read(File.dirname(__FILE__) + '/cucumber.js')}
+    </script>
+    <style>
+#{IO.read(File.dirname(__FILE__) + '/cucumber.css')}
+    </style>
+  </head>
+  <body>
+    <div id="container">
+HTML
+        features.accept(self)
+        @io.puts %{    </div>}
+      end
+
+      def visit_feature(feature)
+        @io.puts %{      <dl class="feature new">}
+        feature.accept(self)
+        @io.puts %{        </dd>}
+        @io.puts %{      </dl>}
+      end
+      
+      def visit_header(header)
+        header = header.gsub(/\n/, "<br />\n")
+        @io.puts %{        <dt>#{header}}
+        @io.puts %{        </dt>}
+        @io.puts %{        <dd>}
+      end
+
+      def visit_regular_scenario(scenario)
+        @scenario_table_header = scenario.table_header
+        @io.puts %{          <dl class="new">}
+        @io.puts %{            <dt>#{Cucumber.language['scenario']}: #{scenario.name}</dt>}
+        @io.puts %{            <dd>}
+        @io.puts %{              <ul>}
+        scenario.accept(self)
+        @io.puts %{              </ul>}
+        @io.puts %{            </dd>}
+        @io.puts %{          </dl>}
+      end
+
+      def visit_row_scenario(scenario)
+        @io.puts %{          <dl class="new">}
+        @io.puts %{            <dt>#{Cucumber.language['scenario']}: #{scenario.name}</dt>}
+        @io.puts %{            <dd>}
+        @io.puts %{              <table cellpadding="3">}
+        @io.puts %{                <thead>}
+        @io.puts %{                  <tr>}
+        @scenario_table_header.each do |column_header|
+          @io.puts %{                    <th>#{column_header}</th>}
+        end
+        @io.puts %{                  </tr>}
+        @io.puts %{                </thead>}
+        @io.puts %{                <tbody>}
+        scenario.accept(self)
+        @io.puts %{                </tbody>}
+        @io.puts %{              </table>}
+        @io.puts %{            </dd>}
+        @io.puts %{          </dl>}
+      end
+
+      def visit_row_step(step)
+        _, args, _ = step.regexp_args_proc(@step_mother)
+        args.each do |arg|
+          @io.puts %{                    <td id="#{step.id}"><span>#{arg}</span></td>}
+        end
+      end
+
+      def visit_regular_step(step)
+        regexp, _, _ = step.regexp_args_proc(@step_mother)
+        @io.puts %{                <li class="new" id="#{step.id}">#{step.keyword} #{step.format(regexp, '<span>%s</span>')}</li>}
+      end
+      
+      def step_passed(step, regexp, args)
+        print_javascript_tag("stepPassed(#{step.id})")
+      end
+      
+      def step_failed(step, regexp, args)
+        @errors << step.error
+        print_javascript_tag("stepFailed(#{step.id}, #{step.error.message.inspect}, #{step.error.backtrace.join("\n").inspect})")
+      end
+      
+      def step_pending(step, regexp, args)
+        print_javascript_tag("stepPending(#{step.id})")
+      end
+      
+      def step_skipped(step, regexp, args)
+        # noop
+      end
+
+      def print_javascript_tag(js)
+        @io.puts %{    <script type="text/javascript">#{js}</script>}
+      end
+
+      def dump
+        @io.puts <<-HTML
+  </body>
+</html>
+HTML
+      end
+    end
+  end
+end