kosmas58-cucumber 0.1.16.5

data/lib/cucumber/executor.rb

@@ -0,0 +1,205 @@
+module Cucumber
+  class Executor
+    attr_reader :failed
+    attr_accessor :formatters
+    attr_writer :scenario_names, :lines_for_features, :dry_run
+
+    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_outline(scenario)
+      visit_regular_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
+
+      formatters.scenario_executing(scenario)
+      @before_scenario_procs.each{|p| p.call_in(@world, *[])} unless @dry_run
+      scenario.accept(self)
+      @after_scenario_procs.each{|p| p.call_in(@world, *[])} unless @dry_run
+      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_outline(step)
+      regexp, args, proc = step.regexp_args_proc(@step_mother)
+      formatters.step_traced(step, regexp, args)
+    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) unless @dry_run
+          @after_step_procs.each{|p| p.call_in(@world, *[])}
+          formatters.step_passed(step, regexp, args)
+        rescue ForcedPending => e
+          step.error = e
+          record_pending_step(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 ForcedPending => e
+          step.error = e
+          record_pending_step(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 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.extend(World::Pending)
+      world.extend(::Spec::Matchers) if defined?(::Spec::Matchers)
+      define_step_call_methods(world)
+      world
+    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
+  end
+end

data/lib/cucumber/formatters/ansicolor.rb

@@ -0,0 +1,105 @@
+# 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
+    # Defines aliases for coloured output. You can tweak the colours by defining
+    # a <tt>CUCUMBER_COLORS</tt> variable in your shell, very much like you can
+    # tweak the familiar POSIX command <tt>ls</tt> with
+    # <a href="http://mipsisrisc.com/rambling/2008/06/27/lscolorsls_colors-now-with-linux-support/">$LSCOLORS/$LS_COLORS</a>
+    #
+    # The colours that you can change are:
+    #
+    # * <tt>missing</tt>       - defaults to <tt>yellow</tt>
+    # * <tt>pending</tt>       - defaults to <tt>yellow</tt>
+    # * <tt>pending_param</tt> - defaults to <tt>yellow,bold</tt>
+    # * <tt>failed</tt>        - defaults to <tt>red</tt>
+    # * <tt>failed_param</tt>  - defaults to <tt>red,bold</tt>
+    # * <tt>passed</tt>        - defaults to <tt>green</tt>
+    # * <tt>passed_param</tt>  - defaults to <tt>green,bold</tt>
+    # * <tt>outline</tt>       - defaults to <tt>cyan</tt>
+    # * <tt>outline_param</tt> - defaults to <tt>cyan,bold</tt>
+    # * <tt>skipped</tt>       - defaults to <tt>cyan</tt>
+    # * <tt>skipped_param</tt> - defaults to <tt>cyan,bold</tt>
+    # * <tt>comment</tt>       - defaults to <tt>grey</tt>
+    # * <tt>tag</tt>           - defaults to <tt>blue</tt>
+    #
+    # For instance, if your shell has a black background and a green font (like the
+    # "Homebrew" settings for OS X' Terminal.app), you may want to override passed
+    # steps to be white instead of green. Examples:
+    #
+    #   export CUCUMBER_COLORS="passed=white"
+    #   export CUCUMBER_COLORS="passed=white,bold:passed_param=white,bold,underline"
+    #
+    # (If you're on Windows, use SET instead of export).
+    # To see what colours and effects are available, just run this in your shell:
+    #
+    #   ruby -e "require 'rubygems'; require 'term/ansicolor'; puts Term::ANSIColor.attributes"
+    #
+    # Although not listed, you can also use <tt>grey</tt>
+    module ANSIColor
+      include Term::ANSIColor
+
+      # Not supported in Term::ANSIColor
+      def grey(m)
+        if ::Term::ANSIColor.coloring?
+          "\e[90m#{m}\e[0m"
+        else
+          m
+        end
+      end
+
+      ALIASES = Hash.new do |h,k|
+        if k.to_s =~ /(.*)_param/
+          h[$1] + ',bold'
+        end
+      end.merge({
+        'missing' => 'yellow',
+        'pending' => 'yellow',
+        'failed'  => 'red',
+        'passed'  => 'green',
+        'outline' => 'cyan',
+        'skipped' => 'cyan',
+        'comment' => 'grey',
+        'tag'     => 'blue'
+      })
+
+      if ENV['CUCUMBER_COLORS'] # Example: export CUCUMBER_COLORS="passed=red:failed=yellow"
+        ENV['CUCUMBER_COLORS'].split(':').each do |pair|
+          a = pair.split('=')
+          ALIASES[a[0]] = a[1]
+        end
+      end
+
+      ALIASES.each do |method, color|
+        unless method =~ /.*_param/
+          code = <<-EOF
+          def #{method}(string=nil, &proc)
+            #{ALIASES[method].split(",").join("(") + "(string, &proc" + ")" * ALIASES[method].split(",").length}
+          end
+          # This resets the colour to the non-param colour
+          def #{method}_param(string=nil, &proc)
+            #{ALIASES[method+'_param'].split(",").join("(") + "(string, &proc" + ")" * ALIASES[method+'_param'].split(",").length} + #{ALIASES[method].split(",").join(' + ')}
+          end
+          EOF
+          eval(code)
+        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,152 @@
+require 'cgi'
+
+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)
+        visit_scenario(scenario, Cucumber.language['scenario'])
+      end
+
+      def visit_scenario_outline(scenario)
+        visit_scenario(scenario, Cucumber.language['scenario_outline'])
+      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 = step.visible_args if step.outline?
+        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 visit_step_outline(step)
+        regexp, _, _ = step.regexp_args_proc(@step_mother)
+        @io.puts %{                <li class="new" id="#{step.id}">#{step.keyword} #{CGI.escapeHTML(step.format(nil))}</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 step_traced(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
+        @io.flush
+      end
+      
+      private
+      
+      def visit_scenario(scenario, scenario_or_scenario_outline_keyword)
+        @scenario_table_header = scenario.table_header
+        @io.puts %{          <dl class="new">}
+        @io.puts %{            <dt>#{scenario_or_scenario_outline_keyword}: #{scenario.name}</dt>}
+        @io.puts %{            <dd>}
+        @io.puts %{              <ul>}
+        scenario.accept(self)
+        @io.puts %{              </ul>}
+        @io.puts %{            </dd>}
+        @io.puts %{          </dl>}
+      end
+            
+    end
+  end
+end