cucumber 0.1.6

data/lib/cucumber/core_ext/proc.rb

@@ -0,0 +1,43 @@
+module Cucumber
+  class ArityMismatchError < StandardError
+  end
+
+  module CoreExt
+    # Proc extension that allows a proc to be called in the context of any object.
+    # Also makes it possible to tack a name onto a Proc.
+    module CallIn
+      attr_accessor :name
+      
+      def call_in(obj, *args)
+        obj.extend(mod)
+        a = arity == -1 ? 0 : arity
+        if self != StepMother::PENDING && args.length != a
+          # We have to manually raise when the block has arity -1 (no pipes)
+          raise ArityMismatchError.new("expected #{arity == -1 ? 0 : arity} block argument(s), got #{args.length}")
+        else
+          obj.__send__(meth, *args)
+        end
+      end
+
+      def arity2
+        arity == -1 ? 0 : arity
+      end
+
+      def backtrace_line
+        to_s.match(/[\d\w]+@(.*)>/)[1] + ":in `#{name}'"
+      end
+      
+      def meth
+        @meth ||= "__cucumber_#{object_id}"
+      end
+
+      def mod
+        p = self
+        m = meth
+        @mod ||= Module.new do
+          define_method(m, &p)
+        end
+      end
+    end 
+  end
+end

data/lib/cucumber/core_ext/string.rb

@@ -0,0 +1,22 @@
+class String
+  def gzub(regexp, format=nil, &proc)
+    md = match(regexp)
+    raise "#{self.inspect} doesn't match #{regexp.inspect}" if md.nil?
+    
+    s = dup
+    pos = 0
+    md.captures.each_with_index do |m, n|
+      replacement = if block_given?
+        proc.call(m)
+      else
+        format % m
+      end
+      
+      if md.offset(n+1)[0]
+        s[md.offset(n+1)[0] + pos, m.length] = replacement
+        pos += replacement.length - m.length
+      end
+    end
+    s
+  end
+end

data/lib/cucumber/executor.rb

@@ -0,0 +1,120 @@
+require 'cucumber/core_ext/proc'
+
+module Cucumber
+  class Executor
+    attr_reader :failed
+    
+    def line=(line)
+      @line = line
+    end
+
+    def initialize(formatter, step_mother)
+      @formatter = formatter
+      @world_proc = lambda do 
+        world = Object.new
+        world.extend(Spec::Matchers) if defined?(Spec::Matchers)
+        world
+      end
+      @before_scenario_procs = []
+      @after_scenario_procs = []
+      @after_step_procs = []
+      @step_mother = step_mother
+    end
+    
+    def register_world_proc(&proc)
+      @world_proc = 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)
+      raise "Line number can only be specified when there is 1 feature. There were #{features.length}." if @line && features.length != 1
+      @formatter.visit_features(features) if @formatter.respond_to?(:visit_features)
+      features.accept(self)
+      @formatter.dump
+    end
+
+    def visit_feature(feature)
+      feature.accept(self)
+    end
+
+    def visit_header(header)
+      @formatter.header_executing(header) if @formatter.respond_to?(:header_executing)
+    end
+
+    def visit_row_scenario(scenario)
+      visit_scenario(scenario)
+    end
+
+    def visit_regular_scenario(scenario)
+      visit_scenario(scenario)
+    end
+
+    def visit_scenario(scenario)
+      if @line.nil? || scenario.at_line?(@line)
+        @error = nil
+        @pending = nil
+        @world = @world_proc.call
+        @formatter.scenario_executing(scenario) if @formatter.respond_to?(:scenario_executing)
+        @before_scenario_procs.each{|p| p.call_in(@world, *[])}
+        scenario.accept(self)
+        @after_scenario_procs.each{|p| p.call_in(@world, *[])}
+        @formatter.scenario_executed(scenario) if @formatter.respond_to?(:scenario_executed)
+      end
+    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)
+          step.execute_in(@world, regexp, args, proc)
+          @after_step_procs.each{|p| p.call_in(@world, *[])}
+          @formatter.step_passed(step, regexp, args)
+        rescue Pending
+          record_pending_step(step, regexp, args)
+        rescue => e
+          @failed = true
+          @error = step.error = e
+          @formatter.step_failed(step, regexp, args)
+        end
+      else
+        begin
+          regexp, args, proc = step.regexp_args_proc(@step_mother)
+          step.execute_in(@world, regexp, args, proc)
+          @formatter.step_skipped(step, regexp, args)
+        rescue Pending
+          record_pending_step(step, regexp, args)
+        rescue Exception
+          @formatter.step_skipped(step, regexp, args)
+        end
+      end
+    end
+    
+    def record_pending_step(step, regexp, args)
+      @pending = true
+      @formatter.step_pending(step, regexp, args)
+    end
+
+  end
+end

data/lib/cucumber/formatters.rb

@@ -0,0 +1 @@
+%w{html pretty progress}.each{|n| require "cucumber/formatters/#{n}_formatter"}

data/lib/cucumber/formatters/ansicolor.rb

@@ -0,0 +1,90 @@
+require 'term/ansicolor'
+begin
+  require 'Win32/Console/ANSI' if PLATFORM =~ /mswin|mingw/
+rescue LoadError
+  STDERR.puts "You must gem install win32console to get coloured output on this ruby platform (#{PLATFORM})"
+  ::Term::ANSIColor.coloring = false
+end
+::Term::ANSIColor.coloring = false if !STDOUT.tty?
+
+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
+    #   ** 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
+      }
+      if ENV['CUCUMBER_COLORS']
+        ENV['CUCUMBER_COLORS'].split(':').each do |pair|
+          a = pair.split('=')
+          ALIASES[a[0].to_sym] = a[1]
+        end
+      end
+      
+      ALIASES.each do |m, color_string|
+        colors = color_string.split(",").reverse
+        define_method(m) do |*s|
+          ::Term::ANSIColor.coloring = false if ENV['CUCUMBER_COLORS_DISABLED'] == '1'
+          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/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,125 @@
+module Cucumber
+  module Formatters
+    class HtmlFormatter
+      def initialize(io, step_mother)
+        @io = io
+        @step_mother = step_mother
+        @errors = []
+      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)
+        @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>}
+        @io.puts %{                <thead>}
+        @io.puts %{                  <tr>}
+        @io.puts %{                    <th>COL 1</th>}
+        @io.puts %{                    <th>COL 2</th>}
+        @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