cucumber 1.1.9 → 1.2.0

data/lib/cucumber/formatter/usage.rb

@@ -26,7 +26,7 @@ module Cucumber
         @duration = Time.now - @start_time
       end
 
-      def after_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
+      def after_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background, file_colon_line)
         if step_match.name.nil? # nil if it's from a scenario outline
           stepdef_key = StepDefKey.new(step_match.step_definition.regexp_source, step_match.step_definition.file_colon_line)
 

data/lib/cucumber/js_support/js_snippets.rb

@@ -1,7 +1,7 @@
 module Cucumber
   module JsSupport
     module JsSnippets
-      PARAM_PATTERN = /"([^"]*)"/
+      PARAM_PATTERN = /"(.*?)"/
       ESCAPED_PARAM_PATTERN = '"([^\\"]*)"'
 
       def snippet_text(code_keyword, step_name, multiline_arg_class)

data/lib/cucumber/platform.rb

@@ -4,7 +4,7 @@ require 'rbconfig'
 
 module Cucumber
 unless defined?(Cucumber::VERSION)
-  VERSION       = '1.1.9'
+  VERSION       = '1.2.0'
   BINARY        = File.expand_path(File.dirname(__FILE__) + '/../../bin/cucumber')
   LIBDIR        = File.expand_path(File.dirname(__FILE__) + '/../../lib')
   JRUBY         = defined?(JRUBY_VERSION)

data/lib/cucumber/rb_support/rb_dsl.rb

@@ -23,8 +23,8 @@ module Cucumber
           @rb_language.register_rb_transform(regexp, proc)          
         end
 
-        def register_rb_step_definition(regexp, proc)
-          @rb_language.register_rb_step_definition(regexp, proc)
+        def register_rb_step_definition(regexp, proc_or_sym, options = {})
+          @rb_language.register_rb_step_definition(regexp, proc_or_sym, options)
         end
       end
 
@@ -98,12 +98,19 @@ module Cucumber
       # also to the i18n translations whenever a feature of a
       # new language is loaded.
       #
-      # The +&proc+ gets executed in the context of a <tt>World</tt>
-      # object, which is defined by #World. A new <tt>World</tt>
-      # object is created for each scenario and is shared across
-      # step definitions within that scenario.
-      def register_rb_step_definition(regexp, &proc)
-        RbDsl.register_rb_step_definition(regexp, proc)
+      # If provided, the +symbol+ is sent to the <tt>World</tt> object
+      # as defined by #World. A new <tt>World</tt> object is created
+      # for each scenario and is shared across step definitions within
+      # that scenario. If the +options+ hash contains an <tt>:on</tt>
+      # key, the value for this is assumed to be a proc. This proc
+      # will be executed in the context of the <tt>World</tt> object
+      # and then sent the +symbol+.
+      #
+      # If no +symbol+ if provided then the +&proc+ gets executed in
+      # the context of the <tt>World</tt> object.
+      def register_rb_step_definition(regexp, symbol = nil, options = {}, &proc)
+        proc_or_sym = symbol || proc
+        RbDsl.register_rb_step_definition(regexp, proc_or_sym, options)
       end
     end
   end

data/lib/cucumber/rb_support/rb_language.rb

@@ -75,7 +75,7 @@ module Cucumber
         end.compact
       end
 
-      ARGUMENT_PATTERNS = ['"([^"]*)"', '(\d+)']
+      ARGUMENT_PATTERNS = ['"(.*?)"', '(\d+)']
 
       def snippet_text(code_keyword, step_name, multiline_arg_class)
         snippet_pattern = Regexp.escape(step_name).gsub('\ ', ' ').gsub('/', '\/')
@@ -110,8 +110,8 @@ module Cucumber
         add_transform(RbTransform.new(self, regexp, proc))
       end
 
-      def register_rb_step_definition(regexp, proc)
-        step_definition = RbStepDefinition.new(self, regexp, proc)
+      def register_rb_step_definition(regexp, proc_or_sym, options)
+        step_definition = RbStepDefinition.new(self, regexp, proc_or_sym, options)
         @step_definitions << step_definition
         step_definition
       end

data/lib/cucumber/rb_support/rb_step_definition.rb

@@ -19,18 +19,25 @@ module Cucumber
 
       class MissingProc < StandardError
         def message
-          "Step definitions must always have a proc"
+          "Step definitions must always have a proc or symbol"
         end
       end
 
-      def initialize(rb_language, regexp, proc)
-        raise MissingProc if proc.nil?
+      def initialize(rb_language, regexp, proc_or_sym, options)
+        raise MissingProc if proc_or_sym.nil?
         if String === regexp
           p = Regexp.escape(regexp)
           p = p.gsub(/\\\$\w+/, '(.*)') # Replace $var with (.*)
           regexp = Regexp.new("^#{p}$") 
         end
-        @rb_language, @regexp, @proc = rb_language, regexp, proc
+        @rb_language, @regexp, @proc = rb_language, regexp, proc_or_sym
+        if @proc.kind_of? Symbol
+          @proc = lambda do |*args|
+            target = options[:on] ? instance_exec(&options[:on]) : self
+            target.send(proc_or_sym, *args)
+          end
+        end
+
         @rb_language.available_step_definition(regexp_source, file_colon_line)
       end
 
@@ -71,7 +78,12 @@ module Cucumber
       end
 
       def file_colon_line
-        @proc.file_colon_line
+        case @proc
+        when Proc
+          @proc.file_colon_line
+        when Symbol
+          ":#{@proc}"
+        end
       end
     
       def file

data/lib/cucumber/term/ansicolor.rb

@@ -0,0 +1,118 @@
+module Cucumber
+  module Term
+    # The ANSIColor module can be used for namespacing and mixed into your own
+    # classes.
+    module ANSIColor
+      # :stopdoc:
+      ATTRIBUTES = [
+        [ :clear        ,   0 ], 
+        [ :reset        ,   0 ],     # synonym for :clear
+        [ :bold         ,   1 ], 
+        [ :dark         ,   2 ], 
+        [ :italic       ,   3 ],     # not widely implemented
+        [ :underline    ,   4 ], 
+        [ :underscore   ,   4 ],     # synonym for :underline
+        [ :blink        ,   5 ], 
+        [ :rapid_blink  ,   6 ],     # not widely implemented
+        [ :negative     ,   7 ],     # no reverse because of String#reverse
+        [ :concealed    ,   8 ], 
+        [ :strikethrough,   9 ],     # not widely implemented
+        [ :black        ,  30 ], 
+        [ :red          ,  31 ], 
+        [ :green        ,  32 ], 
+        [ :yellow       ,  33 ], 
+        [ :blue         ,  34 ], 
+        [ :magenta      ,  35 ], 
+        [ :cyan         ,  36 ], 
+        [ :white        ,  37 ], 
+        [ :on_black     ,  40 ], 
+        [ :on_red       ,  41 ], 
+        [ :on_green     ,  42 ], 
+        [ :on_yellow    ,  43 ], 
+        [ :on_blue      ,  44 ], 
+        [ :on_magenta   ,  45 ], 
+        [ :on_cyan      ,  46 ], 
+        [ :on_white     ,  47 ], 
+      ]
+
+      ATTRIBUTE_NAMES = ATTRIBUTES.transpose.first
+      # :startdoc:
+
+      # Returns true, if the coloring function of this module
+      # is switched on, false otherwise.
+      def self.coloring?
+        @coloring
+      end
+
+      # Turns the coloring on or off globally, so you can easily do
+      # this for example:
+      #  Cucumber::Term::ANSIColor::coloring = STDOUT.isatty
+      def self.coloring=(val)
+        @coloring = val
+      end
+      self.coloring = true
+
+      ATTRIBUTES.each do |c, v|
+        eval %Q{
+            def #{c}(string = nil)
+              result = ''
+              result << "\e[#{v}m" if Cucumber::Term::ANSIColor.coloring?
+              if block_given?
+                result << yield
+              elsif string
+                result << string
+              elsif respond_to?(:to_str)
+                result << to_str
+              else
+                return result #only switch on
+              end
+              result << "\e[0m" if Cucumber::Term::ANSIColor.coloring?
+              result
+            end
+        }
+      end
+
+      # Regular expression that is used to scan for ANSI-sequences while
+      # uncoloring strings.
+      COLORED_REGEXP = /\e\[(?:[34][0-7]|[0-9])?m/
+
+
+      def self.included(klass)
+        if version_is_greater_than_18? and klass == String
+          ATTRIBUTES.delete(:clear)
+          ATTRIBUTE_NAMES.delete(:clear)
+        end
+      end
+
+      # Returns an uncolored version of the string, that is all
+      # ANSI-sequences are stripped from the string.
+      def uncolored(string = nil) # :yields:
+        if block_given?
+          yield.gsub(COLORED_REGEXP, '')
+        elsif string
+          string.gsub(COLORED_REGEXP, '')
+        elsif respond_to?(:to_str)
+          to_str.gsub(COLORED_REGEXP, '')
+        else
+          ''
+        end
+      end
+
+      module_function
+
+      # Returns an array of all Cucumber::Term::ANSIColor attributes as symbols.
+      def attributes
+        ATTRIBUTE_NAMES
+      end
+      extend self
+
+      private
+
+      def version_is_greater_than_18?
+        version = RUBY_VERSION.split('.')
+        version.map! &:to_i
+        version[0] >= 1 && version[1] > 8
+      end
+    end
+  end
+end

data/spec/cucumber/ast/table_spec.rb

@@ -474,6 +474,15 @@ module Cucumber
             lambda { @t.dup.diff!(t) }.should_not raise_error
             lambda { @t.dup.diff!(t, :surplus_col => true) }.should raise_error
           end
+
+          it "should not raise on misplaced columns" do
+            t = table(%{
+              | b | a |
+              | d | c |
+            }, __FILE__, __LINE__)
+            lambda { @t.dup.diff!(t) }.should_not raise_error
+            lambda { @t.dup.diff!(t, :misplaced_col => true) }.should raise_error
+          end
         end
 
         def table(text, file, offset)

data/spec/cucumber/cli/configuration_spec.rb

@@ -321,12 +321,12 @@ END_OF_MESSAGE
     end
 
     it "should accept --color option" do
-      Term::ANSIColor.should_receive(:coloring=).with(true)
+      Cucumber::Term::ANSIColor.should_receive(:coloring=).with(true)
       config.parse!(['--color'])
     end
 
     it "should accept --no-color option" do
-      Term::ANSIColor.should_receive(:coloring=).with(false)
+      Cucumber::Term::ANSIColor.should_receive(:coloring=).with(false)
       config = Configuration.new(StringIO.new)
       config.parse!(['--no-color'])
     end
@@ -404,14 +404,20 @@ END_OF_MESSAGE
     end
     
     describe "#tag_expression" do
+      include RSpec::WorkInProgress
+
       it "returns an empty expression when no tags are specified" do
-        config.parse!([])
-        config.tag_expression.should be_empty
+        pending_under :java, 'the java class Gherkin::TagExpression has no isEmpty method' do
+          config.parse!([])
+          config.tag_expression.should be_empty
+        end
       end
 
       it "returns an expression when tags are specified" do
-        config.parse!(['--tags','@foo'])
-        config.tag_expression.should_not be_empty
+        pending_under :java, 'the java class Gherkin::TagExpression has no isEmpty method' do
+          config.parse!(['--tags','@foo'])
+          config.tag_expression.should_not be_empty
+        end
       end
     end
     

data/spec/cucumber/cli/options_spec.rb

@@ -55,14 +55,20 @@ module Cli
 
       context '--i18n' do
         context "with LANG specified as 'help'" do
+          include RSpec::WorkInProgress
+
           it "lists all known langues" do
-            when_parsing '--i18n help' do
-              Kernel.should_receive(:exit)
+            pending_under :java, "require gherkin >= b5e96f13" do
+              when_parsing '--i18n help' do
+                Kernel.should_receive(:exit)
+              end
             end
           end
 
           it "exits the program" do
-            when_parsing('--i18n help') { Kernel.should_receive(:exit) }
+            pending_under :java, "require gherkin >= b5e96f13" do
+              when_parsing('--i18n help') { Kernel.should_receive(:exit) }
+            end
           end
         end
       end

data/spec/cucumber/constantize_spec.rb

@@ -8,5 +8,9 @@ module Cucumber
       clazz = constantize('Cucumber::Formatter::Html')
       clazz.name.should == 'Cucumber::Formatter::Html'
     end
+
+    it "fails to load a made up class" do
+      expect { constantize('My::MadeUp::ClassName') }.to raise_error(LoadError)
+    end
   end
-end
+end

data/spec/cucumber/formatter/ansicolor_spec.rb

@@ -23,7 +23,7 @@ module Cucumber
       end
       
       it "should not generate ansi codes when colors are disabled" do
-        ::Term::ANSIColor.coloring = false
+        ::Cucumber::Term::ANSIColor.coloring = false
         passed("foo").should == "foo"
       end
     end

data/spec/cucumber/formatter/interceptor_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+require 'cucumber/formatter/interceptor'
+
+module Cucumber::Formatter
+  describe Interceptor::Pipe do
+    let(:pipe) do
+      pipe = double('original pipe')
+      pipe.stub(:instance_of?).and_return(true)
+      pipe
+    end
+
+    describe '#wrap!' do
+      it 'should raise an ArgumentError if its not passed :stderr/:stdout' do
+        expect {
+          Interceptor::Pipe.wrap(:nonsense)
+        }.to raise_error(ArgumentError)
+
+      end
+
+      context 'when passed :stderr' do
+        before :each do
+          @stderr = $stdout
+        end
+
+        it 'should wrap $stderr' do
+          wrapped = Interceptor::Pipe.wrap(:stderr)
+          $stderr.should be_instance_of Interceptor::Pipe
+          $stderr.should be wrapped
+        end
+
+        after :each do
+          $stderr = @stderr
+        end
+      end
+
+      context 'when passed :stdout' do
+        before :each do
+          @stdout = $stdout
+        end
+
+        it 'should wrap $stdout' do
+          wrapped = Interceptor::Pipe.wrap(:stdout)
+          $stdout.should be_instance_of Interceptor::Pipe
+          $stdout.should be wrapped
+        end
+
+        after :each do
+          $stdout = @stdout
+        end
+      end
+    end
+
+    describe '#unwrap!' do
+      before :each do
+        @stdout = $stdout
+        @wrapped = Interceptor::Pipe.wrap(:stdout)
+      end
+
+      it 'should raise an ArgumentError if it wasn\'t passed :stderr/:stdout' do
+        expect {
+          Interceptor::Pipe.unwrap!(:nonsense)
+        }.to raise_error(ArgumentError)
+      end
+
+      it 'should reset $stdout when #unwrap! is called' do
+        interceptor = Interceptor::Pipe.unwrap! :stdout
+        interceptor.should be_instance_of Interceptor::Pipe
+        $stdout.should_not be interceptor
+      end
+
+      it 'should disable the pipe bypass' do
+        buffer = '(::)'
+        Interceptor::Pipe.unwrap! :stdout
+
+        @wrapped.should_receive(:write).with(buffer)
+        @wrapped.buffer.should_not_receive(:<<)
+        @wrapped.write(buffer)
+      end
+
+      after :each do
+        $stdout = @stdout
+      end
+    end
+
+    describe '#write' do
+      let(:buffer) { 'Some stupid buffer' }
+      let(:pi) { Interceptor::Pipe.new(pipe) }
+
+      it 'should write arguments to the original pipe' do
+        pipe.should_receive(:write).with(buffer).and_return(buffer.size)
+        pi.write(buffer).should == buffer.size
+      end
+
+      it 'should add the buffer to its stored output' do
+        pipe.stub(:write)
+        pi.write(buffer)
+        pi.buffer.should_not be_empty
+        pi.buffer.first.should == buffer
+      end
+    end
+
+    describe '#method_missing' do
+      let(:pi) { Interceptor::Pipe.new(pipe) }
+
+      it 'should pass #tty? to the original pipe' do
+        pipe.should_receive(:tty?).and_return(true)
+        pi.tty?.should be true
+      end
+    end
+  end
+end