aslakhellesoy-cucumber 0.1.5 → 0.1.9

data/lib/cucumber/core_ext/proc.rb

@@ -0,0 +1,54 @@
+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)
+        if self != StepMother::PENDING && args.length != arity2
+          # We have to manually raise when the block has arity -1 (no pipes)
+          raise ArityMismatchError.new("expected #{arity2} block argument(s), got #{args.length}")
+        else
+          obj.__send__(meth, *args)
+        end
+      end
+
+      def arity2
+        arity == -1 ? 0 : arity
+      end
+
+      def to_backtrace_line
+        "#{file_colon_line}:in `#{name}'"
+      end
+      
+      def to_comment_line
+        "# #{file_colon_line}"
+      end
+      
+      def file_colon_line
+        path, line = *to_s.match(/[\d\w]+@(.*):(.*)>/)[1..2]
+        path = File.expand_path(path)
+        pwd = Dir.pwd
+        path = path[pwd.length+1..-1]        
+        "#{path}:#{line}"
+      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,170 @@
+require 'cucumber/core_ext/proc'
+
+module Cucumber
+  class Executor
+    attr_reader :failed
+    attr_accessor :formatters
+    attr_writer :scenario_names
+
+    def line=(line)
+      @line = line
+    end
+
+    def initialize(step_mother)
+      @world_proc = lambda do
+        Object.new
+      end
+      @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_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
+      formatters.visit_features(features)
+      features.accept(self)
+      formatters.dump
+    end
+
+    def visit_feature(feature)
+      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 = @world_proc.call
+      @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)
+      accept = true
+      accept &&= scenario.at_line?(@line) if @line
+      accept &&= @scenario_names.include? scenario.name if @scenario_names && !@scenario_names.empty?
+      accept
+    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
+    
+  end
+end

data/lib/cucumber/formatters.rb

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

data/lib/cucumber/formatters/ansicolor.rb

@@ -0,0 +1,111 @@
+gem 'term-ansicolor'
+# 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!
+$LOAD_PATH.each{|path| $LOAD_PATH.unshift($LOAD_PATH.delete(path)) if path =~ /term-ansicolor/}
+
+require 'term/ansicolor'
+require 'rbconfig'
+
+win = Config::CONFIG['host_os'] =~ /mswin|mingw/
+jruby = defined?(JRUBY_VERSION)
+
+begin
+  require 'Win32/Console/ANSI' if (win && !jruby)
+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? || (win && jruby)
+
+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;
+}