cucumber 0.4.5.rc2 → 0.5.0

data/features/wire_protocol_table_diffing.feature

@@ -0,0 +1,95 @@
+@wire
+Feature: Wire protocol table diffing
+  In order to use the amazing functionality in the Cucumber table object
+  As a wire server
+  I want to be able to ask for a table diff during a step definition invocation
+
+  Background:
+    Given a standard Cucumber project directory structure
+    And a file named "features/wired.feature" with:
+      """
+        Scenario: Wired
+          Given we're all wired
+
+      """
+    And a file named "features/step_definitions/some_remote_place.wire" with:
+      """
+      host: localhost
+      port: 54321
+
+      """
+
+  Scenario: Invoke a step definition tries to diff the table and fails
+    Given there is a wire server running on port 54321 which understands the following protocol:
+      | request                                              | response                                                                                                                                                   |
+      | ["step_matches",{"name_to_match":"we're all wired"}] | ["step_matches",[{"id":"1", "args":[]}]]                                                                                                                   |
+      | ["begin_scenario",null]                              | ["success",null]                                                                                                                                           |
+      | ["invoke",{"id":"1","args":[]}]                      | ["diff",[[["a","b"],["c","d"]],[["x","y"],["z","z"]]]]                                                                                                     |
+      | ["diff_failed",null]                                 | ["step_failed",{"message":"Not same", "exception":"DifferentException", "backtrace":["a.cs:12","b.cs:34"]}] |
+      | ["end_scenario",null]                                | ["success",null]                                                                                                                                           |
+    When I run cucumber -f progress --backtrace
+    And it should fail with
+      """
+      F
+
+      (::) failed steps (::)
+
+      Not same (DifferentException from localhost:54321)
+      a.cs:12
+      b.cs:34
+      features/wired.feature:2:in `Given we're all wired'
+
+      Failing Scenarios:
+      cucumber features/wired.feature:1 # Scenario: Wired
+
+      1 scenario (1 failed)
+      1 step (1 failed)
+
+      """
+
+  Scenario: Invoke a step definition tries to diff the table and passes
+    Given there is a wire server running on port 54321 which understands the following protocol:
+      | request                                              | response                                 |
+      | ["step_matches",{"name_to_match":"we're all wired"}] | ["step_matches",[{"id":"1", "args":[]}]] |
+      | ["begin_scenario",null]                              | ["success",null]                         |
+      | ["invoke",{"id":"1","args":[]}]                      | ["diff",[[["a"],["b"]],[["a"],["b"]]]]   |
+      | ["diff_ok",null]                                     | ["success",null]                         |
+      | ["end_scenario",null]                                | ["success",null]                         |
+    When I run cucumber -f progress
+    And it should pass with
+      """
+      .
+
+      1 scenario (1 passed)
+      1 step (1 passed)
+
+      """
+
+  Scenario: Invoke a step definition which successfully diffs a table but then fails
+    Given there is a wire server running on port 54321 which understands the following protocol:
+      | request                                              | response                                                             |
+      | ["step_matches",{"name_to_match":"we're all wired"}] | ["step_matches",[{"id":"1", "args":[]}]]                             |
+      | ["begin_scenario",null]                              | ["success",null]                                                     |
+      | ["invoke",{"id":"1","args":[]}]                      | ["diff",[[["a"],["b"]],[["a"],["b"]]]]                               |
+      | ["diff_ok",null]                                     | ["step_failed",{"message":"I wanted things to be different for us"}] |
+      | ["end_scenario",null]                                | ["success",null]                                                     |
+    When I run cucumber -f progress
+    And it should fail with
+      """
+      F
+
+      (::) failed steps (::)
+
+      I wanted things to be different for us (Cucumber::WireSupport::WireException)
+      features/wired.feature:2:in `Given we're all wired'
+
+      Failing Scenarios:
+      cucumber features/wired.feature:1 # Scenario: Wired
+
+      1 scenario (1 failed)
+      1 step (1 failed)
+
+      """
+
+
+

data/lib/cucumber/cli/configuration.rb

@@ -127,7 +127,13 @@ module Cucumber
     private
     
       def formatters(step_mother)
-        return [Formatter::Pretty.new(step_mother, nil, @options)] if @options[:autoformat]
+        # TODO: We should remove the autoformat functionality. That
+        # can be done with the gherkin CLI.
+        if @options[:autoformat]
+          require 'cucumber/formatter/pretty'
+          return [Formatter::Pretty.new(step_mother, nil, @options)]
+        end
+
         @options[:formats].map do |format_and_out|
           format = format_and_out[0]
           path_or_io = format_and_out[1]

data/lib/cucumber/cli/main.rb

@@ -5,7 +5,6 @@ require 'logger'
 require 'cucumber/parser'
 require 'cucumber/feature_file'
 require 'cucumber/formatter/color_io'
-require 'cucumber/cli/language_help_formatter'
 require 'cucumber/cli/configuration'
 require 'cucumber/cli/drb_client'
 require 'cucumber/ast/tags'
@@ -27,7 +26,12 @@ module Cucumber
 
       def initialize(args, out_stream = STDOUT, error_stream = STDERR)
         @args         = args
-        @out_stream   = out_stream == STDOUT ? Formatter::ColorIO.new : out_stream
+        if Cucumber::WINDOWS_MRI
+          @out_stream   = out_stream == STDOUT ? Formatter::ColorIO.new(Kernel, STDOUT) : out_stream
+        else
+          @out_stream   = out_stream
+        end
+
         @error_stream = error_stream
         @configuration = nil
       end

data/lib/cucumber/cli/options.rb

@@ -1,4 +1,6 @@
 require 'cucumber/cli/profile_loader'
+require 'cucumber/formatter/ansicolor'
+
 module Cucumber
   module Cli
 
@@ -115,17 +117,13 @@ module Cucumber
             "This option can be specified multiple times.") do |v|
             @options[:require] << v
           end
-          opts.on("-l LANG", "--language LANG (DEPRECATED)",
-            "Specify language for features (Default: #{@options[:lang]})",
-            %{Run with "--language help" to see all languages},
-            %{Run with "--language LANG help" to list keywords for LANG}) do |v|
-            if v == 'help'
+          opts.on("--i18n LANG",
+            "List keywords for in a particular language",
+            %{Run with "--i18n help" to see all languages}) do |lang|
+            if lang == 'help'
               list_languages_and_exit
-            elsif args==['help']
-              list_keywords_and_exit(v)
             else
-              warn("\nWARNING: --language is deprecated and will be removed in version 0.5.\nSee http://wiki.github.com/aslakhellesoy/cucumber/spoken-languages")
-              @options[:lang] = v
+              list_keywords_and_exit(lang)
             end
           end
           opts.on("-f FORMAT", "--format FORMAT",
@@ -367,11 +365,13 @@ module Cucumber
         unless Cucumber::LANGUAGES[lang]
           raise("No language with key #{lang}")
         end
+        require 'cucumber/cli/language_help_formatter'
         LanguageHelpFormatter.list_keywords(@out_stream, lang)
         Kernel.exit(0)
       end
 
       def list_languages_and_exit
+        require 'cucumber/cli/language_help_formatter'
         LanguageHelpFormatter.list_languages(@out_stream)
         Kernel.exit(0)
       end

data/lib/cucumber/feature_file.rb

@@ -23,7 +23,7 @@ module Cucumber
     # be filtered.
     def parse(step_mother, options)
       filter = Filter.new(@lines, options)
-      language = Parser::NaturalLanguage.get(step_mother, (lang || options[:lang] || 'en'))
+      language = Parser::NaturalLanguage.get(step_mother, (lang || 'en'))
       language.parse(source, @path, filter)
     end
     

data/lib/cucumber/formatter/color_io.rb

@@ -2,15 +2,15 @@ require 'forwardable'
 
 module Cucumber
   module Formatter
-    # Adapter to make #puts/#print/#flush work with colours on Windows
+    # Adapter to make #puts/#print/#flush work with win32console
     class ColorIO #:nodoc:
       extend Forwardable
       def_delegators :@kernel, :puts, :print # win32console colours only work when sent to Kernel
       def_delegators :@stdout, :flush, :tty?, :write, :close
 
-      def initialize
-        @kernel = Kernel
-        @stdout = STDOUT
+      def initialize(kernel, stdout)
+        @kernel = kernel
+        @stdout = stdout
       end
 
       # Ensure using << still gets colours in win32console

data/lib/cucumber/formatter/html.rb

@@ -315,16 +315,17 @@ module Cucumber
           backtrace = Array.new
           @builder.div(:class => 'message') do
             message = exception.message
-            if message.include?('Exception caught')
+            if defined?(RAILS_ROOT) && message.include?('Exception caught')
               matches = message.match(/Showing <i>(.+)<\/i>(?:.+)#(\d+)/)
               backtrace += ["#{RAILS_ROOT}/#{matches[1]}:#{matches[2]}"]
               message = message.match(/<code>([^(\/)]+)<\//m)[1]
             end
-            @builder << "<pre>#{message}</pre>"
+            @builder.pre do 
+              @builder.text!(message)
+            end
           end
           @builder.div(:class => 'backtrace') do
             @builder.pre do
-              # backtrace += (exception.backtrace.size == 1 || exception.backtrace[0].include?('(eval):')) ? ["#{RAILS_ROOT}/#{@step_match.file_colon_line}"] + exception.backtrace : exception.backtrace
               backtrace = exception.backtrace
               backtrace.delete_if { |x| x =~ /\/gems\/(cucumber|rspec)/ }
               @builder << backtrace_line(backtrace.join("\n"))

data/lib/cucumber/formatter/tag_cloud.rb

@@ -1,4 +1,5 @@
 require 'cucumber/formatter/io'
+require 'cucumber/formatter/pretty'
 
 module Cucumber
   module Formatter

data/lib/cucumber/formatter/unicode.rb

@@ -1,35 +1,40 @@
 # Require this file if you need Unicode support.
 require 'cucumber/platform'
 require 'cucumber/formatter/ansicolor'
-
 $KCODE='u' unless Cucumber::RUBY_1_9
 
-if Cucumber::WINDOWS_MRI && `chcp` =~ /(\d+)/
+if Cucumber::WINDOWS && `cmd /c chcp` =~ /(\d+)/
+  require 'iconv'
   codepage = $1.to_i
-  codepages = (1251..1252)
+  Cucumber::CODEPAGE = "cp#{codepage}"
 
-  if codepages.include?(codepage)
-    Cucumber::CODEPAGE = "cp#{codepage}"
-  
-    require 'iconv'
-    module Kernel #:nodoc:
-      alias cucumber_print print
-      def print(*a)
-        begin
-          cucumber_print(*Iconv.iconv(Cucumber::CODEPAGE, "UTF-8", *a))
-        rescue Iconv::IllegalSequence
-          cucumber_print(*a)
-        end
-      end
+  module Cucumber
+    module WindowsOutput #:nodoc:
+      def self.extended(o)
+        o.instance_eval do
+          alias cucumber_print print
+          def print(*a)
+            begin
+              cucumber_print(*Iconv.iconv(Cucumber::CODEPAGE, "UTF-8", *a.map{|a|a.to_s}))
+            rescue Iconv::IllegalSequence
+              cucumber_print(*a)
+            end
+          end
 
-      alias cucumber_puts puts
-      def puts(*a)
-        begin
-          cucumber_puts(*Iconv.iconv(Cucumber::CODEPAGE, "UTF-8", *a))
-        rescue Iconv::IllegalSequence
-          cucumber_puts(*a)
+          alias cucumber_puts puts
+          def puts(*a)
+            begin
+              cucumber_puts(*Iconv.iconv(Cucumber::CODEPAGE, "UTF-8", *a.map{|a|a.to_s}))
+            rescue Iconv::IllegalSequence
+              cucumber_puts(*a)
+            end
+          end
         end
       end
+
+      Kernel.extend(self)
+      STDOUT.extend(self)
+      STDERR.extend(self)
     end
   end
-end
+end

data/lib/cucumber/languages.yml

@@ -333,7 +333,7 @@
   scenario: Scenario
   scenario_outline: Abstract Scenario
   examples: Voorbeelden
-  given: *|Gegeven
+  given: *|Gegeven|Stel
   when: *|Als
   then: *|Dan
   and: *|En

data/lib/cucumber/step_argument.rb

@@ -1,9 +1,9 @@
 module Cucumber
   class StepArgument
-    attr_reader :val, :pos
+    attr_reader :val, :byte_offset
 
-    def initialize(val, pos)
-      @val, @pos = val, pos
+    def initialize(val, byte_offset)
+      @val, @byte_offset = val, byte_offset
     end
   end
 end

data/lib/cucumber/step_match.rb

@@ -59,7 +59,7 @@ module Cucumber
       s = string.dup
       offset = 0
       step_arguments.each do |step_argument|
-        next if step_argument.pos.nil?
+        next if step_argument.byte_offset.nil?
         replacement = if block_given?
           proc.call(step_argument.val)
         elsif Proc === format
@@ -68,7 +68,7 @@ module Cucumber
           format % step_argument.val
         end
 
-        s[step_argument.pos + offset, step_argument.val.length] = replacement
+        s[step_argument.byte_offset + offset, step_argument.val.length] = replacement
         offset += replacement.jlength - step_argument.val.jlength
       end
       s

data/lib/cucumber/wire_support/connection.rb

@@ -22,6 +22,10 @@ module Cucumber
           raise "Timed out calling server with message #{message}"
         end
       end
+      
+      def exception(params)
+        WireException.new(params, @host, @port)
+      end
 
       private
       

data/lib/cucumber/wire_support/request_handler.rb

@@ -12,7 +12,7 @@ module Cucumber
       end
 
       def handle_fail(params)
-        raise WireException.new(params)
+        raise @connection.exception(params)
       end
     end
   end

data/lib/cucumber/wire_support/wire_exception.rb

@@ -2,8 +2,30 @@ module Cucumber
   module WireSupport
     # Proxy for an exception that occured at the remote end of the wire
     class WireException < StandardError
-      def initialize(args)
+      module CanSetName
+        attr_writer :exception_name
+        def to_s
+          @exception_name
+        end
+      end
+      
+      def initialize(args, host, port)
         super args['message']
+        if args['exception']
+          self.class.extend(CanSetName)
+          self.class.exception_name = "#{args['exception']} from #{host}:#{port}"
+        end
+        if args['backtrace']
+          @backtrace = if args['backtrace'].is_a?(String)
+              args['backtrace'].split("\n") # TODO: change cuke4nuke to pass an array instead of a big string
+            else
+              args['backtrace']
+            end
+        end
+      end
+      
+      def backtrace
+        @backtrace || super
       end
     end
   end

data/lib/cucumber/wire_support/wire_language.rb

@@ -29,7 +29,10 @@ module Cucumber
       end
 
       def snippet_text(step_keyword, step_name, multiline_arg_class)
-        "Snippets are not implemented for the wire yet"
+        snippets = @connections.map do |remote| 
+          remote.snippet_text(step_keyword, step_name, multiline_arg_class.to_s)
+        end
+        snippets.flatten.join("\n")
       end
       
       protected

data/lib/cucumber/wire_support/wire_packet.rb

@@ -22,10 +22,6 @@ module Cucumber
         [@message, @params].to_json
       end
       
-      def raise_if_bad
-        raise WireException.new(@params) if @message == 'fail' || @message == 'step_failed'
-      end
-      
       def handle_with(handler)
         handler.send("handle_#{@message}", @params)
       end

data/lib/cucumber/wire_support/wire_protocol.rb

@@ -9,7 +9,7 @@ module Cucumber
         make_request(:step_matches, :name_to_match => name_to_match) do
           def handle_step_matches(params)
             params.map do |raw_step_match|
-              step_definition = WireStepDefinition.new(raw_step_match['id'], @connection)
+              step_definition = WireStepDefinition.new(@connection, raw_step_match)
               step_args = raw_step_match['args'].map do |raw_arg|
                 StepArgument.new(raw_arg['val'], raw_arg['pos'])
               end
@@ -23,12 +23,37 @@ module Cucumber
         StepMatch.new(step_definition, @name_to_match, @name_to_report, step_args)
       end
       
+      def snippet_text(step_keyword, step_name, multiline_arg_class_name)
+        request_params = { :step_keyword => step_keyword, :step_name => step_name, :multiline_arg_class => multiline_arg_class_name }
+
+        make_request(:snippet_text, request_params) do
+          def handle_snippet_text(text)
+            text
+          end
+        end
+      end
+      
       def invoke(step_definition_id, args)
         request_params = { :id => step_definition_id, :args => args }
-        
+
         make_request(:invoke, request_params) do
           def handle_success(params)
           end
+          
+          def handle_pending(message)
+            raise Pending, message || "TODO"
+          end
+          
+          def handle_diff(tables)
+            table1 = Ast::Table.new(tables[0])
+            table2 = Ast::Table.new(tables[1])
+            begin
+              table1.diff!(table2)
+            rescue Cucumber::Ast::Table::Different
+              @connection.diff_failed
+            end
+            @connection.diff_ok
+          end
         
           def handle_step_failed(params)
             handle_fail(params)
@@ -36,6 +61,28 @@ module Cucumber
         end
       end
       
+      def diff_failed
+        make_request(:diff_failed) do
+          def handle_success(params)
+          end
+          
+          def handle_step_failed(params)
+            handle_fail(params)
+          end
+        end
+      end
+      
+      def diff_ok
+        make_request(:diff_ok) do
+          def handle_success(params)
+          end
+          
+          def handle_step_failed(params)
+            handle_fail(params)
+          end
+        end
+      end
+      
       def begin_scenario(scenario)
         make_request(:begin_scenario) do
           def handle_success(params)
@@ -52,12 +99,9 @@ module Cucumber
       
       private
       
-      def handler(request_message, &block)
-        RequestHandler.new(self, request_message, &block)
-      end
-      
       def make_request(request_message, params = nil, &block)
-        handler(request_message, &block).execute(params)
+        handler = RequestHandler.new(self, request_message, &block)
+        handler.execute(params)
       end
     end
   end