cucumber 0.8.5 → 0.8.6

data/lib/cucumber/formatter/pretty.rb

@@ -25,7 +25,7 @@ module Cucumber
         @exceptions = []
         @indent = 0
         @prefixes = options[:prefixes] || {}
-        @delayed_announcements = []
+        @delayed_messages = []
       end
 
       def after_features(features)
@@ -101,7 +101,7 @@ module Cucumber
       end
       
       def examples_name(keyword, name)
-        puts unless @visiting_first_example_name
+        @io.puts unless @visiting_first_example_name
         @visiting_first_example_name = false
         names = name.strip.empty? ? [name.strip] : name.split("\n")
         @io.puts("    #{keyword}: #{names[0]}")
@@ -150,10 +150,10 @@ module Cucumber
         source_indent = nil unless @options[:source]
         name_to_report = format_step(keyword, step_match, status, source_indent)
         @io.puts(name_to_report.indent(@scenario_indent + 2))
-        print_announcements
+        print_messages
       end
 
-      def py_string(string)
+      def doc_string(string)
         return if @hide_this_step
         s = %{"""\n#{string}\n"""}.indent(@indent)
         s = s.split("\n").map{|l| l =~ /^\s+$/ ? '' : l}.join("\n")
@@ -184,7 +184,7 @@ module Cucumber
 
       def after_table_row(table_row)
         return if !@table || @hide_this_step
-        print_table_row_announcements
+        print_table_row_messages
         @io.puts
         if table_row.exception && !@exceptions.include?(table_row.exception)
           print_exception(table_row.exception, table_row.status, @indent)

data/lib/cucumber/formatter/rerun.rb

@@ -21,17 +21,21 @@ module Cucumber
         @file_names = []
         @file_colon_lines = Hash.new{|h,k| h[k] = []}
       end
-
-      # features() is never executed at all... ?
-      def after_features(features)
-        files = @file_names.uniq.map do |file|
-          lines = @file_colon_lines[file]
-          "#{file}:#{lines.join(':')}"
+      
+      def before_feature(*)
+        @lines = []
+        @file = nil
+      end
+      
+      def after_feature(*)
+        after_first_time do
+          @io.print ' '
         end
-        @io.puts files.join(' ')
-        
-        # Flusing output to rerun tempfile here...
+        @io.print "#{@file}:#{@lines.join(':')}"
         @io.flush
+      end
+
+      def after_features(features)
         @io.close
       end
 
@@ -42,14 +46,21 @@ module Cucumber
       def after_feature_element(feature_element)
         if @rerun
           file, line = *feature_element.file_colon_line.split(':')
-          @file_colon_lines[file] << line
-          @file_names << file
+          @lines << line
+          @file = file
         end
       end
 
       def step_name(keyword, step_match, status, source_indent, background)
         @rerun = true if [:failed, :pending, :undefined].index(status)
       end
+      
+    private
+    
+      def after_first_time
+        yield if @not_first_time
+        @not_first_time = true
+      end
     end
   end
 end

data/lib/cucumber/formatter/unicode.rb

@@ -5,14 +5,17 @@ require 'cucumber/formatter/ansicolor'
 $KCODE='u' unless Cucumber::RUBY_1_9
 
 if Cucumber::WINDOWS
-  require 'iconv'
+  require 'iconv' unless Cucumber::RUBY_1_9
 
   if ENV['CUCUMBER_OUTPUT_ENCODING']
     Cucumber::CODEPAGE = ENV['CUCUMBER_OUTPUT_ENCODING']
-  elsif Cucumber::WINDOWS_MRI
-    Cucumber::CODEPAGE = "cp#{Win32::Console::OutputCP()}"
   elsif `cmd /c chcp` =~ /(\d+)/
-    Cucumber::CODEPAGE = "cp#{$1.to_i}"
+    if [65000, 65001].include? $1.to_i
+      Cucumber::CODEPAGE = 'UTF-8'
+      ENV['ANSICON_API'] = 'ruby'
+    else
+      Cucumber::CODEPAGE = "cp#{$1.to_i}"
+    end
   else
     Cucumber::CODEPAGE = "cp1252"
     STDERR.puts("WARNING: Couldn't detect your output codepage. Assuming it is 1252. You may have to chcp 1252 or SET CUCUMBER_OUTPUT_ENCODING=cp1252.")
@@ -24,27 +27,45 @@ if Cucumber::WINDOWS
         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::InvalidEncoding => e
-              STDERR.cucumber_puts("WARNING: #{e.message}")
-              cucumber_print(*a)
-            rescue Iconv::IllegalSequence => e
-              STDERR.cucumber_puts("WARNING: #{e.message}")
-              cucumber_print(*a)
+            if Cucumber::RUBY_1_9
+              begin
+                cucumber_print(*a.map{|arg| arg.to_s.encode(Encoding.default_external)})
+              rescue Encoding::UndefinedConversionError => e
+                STDERR.cucumber_puts("WARNING: #{e.message}")
+                cucumber_print(*a)
+              end
+            else
+              begin
+                cucumber_print(*Iconv.iconv(Cucumber::CODEPAGE, "UTF-8", *a.map{|a|a.to_s}))
+              rescue Iconv::InvalidEncoding => e
+                STDERR.cucumber_puts("WARNING: #{e.message}")
+                cucumber_print(*a)
+              rescue Iconv::IllegalSequence => e
+                STDERR.cucumber_puts("WARNING: #{e.message}")
+                cucumber_print(*a)
+              end
             end
           end
 
           alias cucumber_puts puts
           def puts(*a)
-            begin
-              cucumber_puts(*Iconv.iconv(Cucumber::CODEPAGE, "UTF-8", *a.map{|a|a.to_s}))
-            rescue Iconv::InvalidEncoding => e
-              STDERR.cucumber_print("WARNING: #{e.message}")
-              cucumber_print(*a)
-            rescue Iconv::IllegalSequence => e
-              STDERR.cucumber_puts("WARNING: #{e.message}")
-              cucumber_puts(*a)
+            if Cucumber::RUBY_1_9
+              begin
+                cucumber_puts(*a.map{|arg| arg.to_s.encode(Encoding.default_external)})
+              rescue Encoding::UndefinedConversionError => e
+                STDERR.cucumber_puts("WARNING: #{e.message}")
+                cucumber_puts(*a)
+              end
+            else
+              begin
+                cucumber_puts(*Iconv.iconv(Cucumber::CODEPAGE, "UTF-8", *a.map{|a|a.to_s}))
+              rescue Iconv::InvalidEncoding => e
+                STDERR.cucumber_print("WARNING: #{e.message}")
+                cucumber_print(*a)
+              rescue Iconv::IllegalSequence => e
+                STDERR.cucumber_puts("WARNING: #{e.message}")
+                cucumber_puts(*a)
+              end
             end
           end
         end

data/lib/cucumber/js_support/js_dsl.js

@@ -1,15 +1,15 @@
 var CucumberJsDsl = {
   registerStepDefinition: function(regexp, func) {
     if(func == null) {
-      jsLanguage.executeStepDefinition(regexp);
+      jsLanguage.execute_step_definition(regexp);
     }
     else{
-      jsLanguage.addStepDefinition(regexp, func);
+      jsLanguage.add_step_definition(regexp, func);
     }
   },
 
   registerTransform: function(regexp, func) {
-    jsLanguage.registerJsTransform(regexp, func);
+    jsLanguage.register_js_transform(regexp, func);
   },
 
   beforeHook: function(tag_expressions_or_func, func) {
@@ -40,7 +40,7 @@ var CucumberJsDsl = {
       var hook_func = tag_expressions_or_func;
       var tag_expressions = [];
     }
-    jsLanguage.registerJsHook(label, tag_expressions, hook_func);
+    jsLanguage.register_js_hook(label, tag_expressions, hook_func);
   }
 }
 

data/lib/cucumber/js_support/js_language.rb

@@ -39,6 +39,10 @@ module Cucumber
         @js_language.current_world.execute(@js_function, args)
       end
 
+      def regexp_source
+        @regexp.inspect
+      end
+
       def arguments_from(step_name)
         matches = eval_js "#{@regexp}.exec('#{step_name}')"
         if matches
@@ -101,10 +105,10 @@ module Cucumber
       include LanguageSupport::LanguageMethods
       include JsSnippets
 
-      def initialize(step_mother)
+      def initialize(runtime)
         @step_definitions = []
         @world = JsWorld.new
-        @step_mother = step_mother
+        @runtime = runtime
 
         @world["jsLanguage"] = self
         @world.load(File.dirname(__FILE__) + '/js_dsl.js')
@@ -146,7 +150,7 @@ module Cucumber
 
       #TODO: support multiline arguments when calling steps from within steps
       def execute_step_definition(name, multiline_argument = nil)
-        @step_mother.step_match(name).invoke(multiline_argument)
+        @runtime.step_match(name).invoke(multiline_argument)
       end
 
       def register_js_hook(phase, tag_expressions, js_function)
@@ -162,12 +166,12 @@ module Cucumber
       end
 
       def steps(steps_text, file_colon_line)
-        @step_mother.invoke_steps(steps_text, @language, file_colon_line)
+        @runtime.invoke_steps(steps_text, @language, file_colon_line)
       end
 
       private
       def path_to_load_js_from
-        paths = @step_mother.options[:paths]
+        paths = @runtime.features_paths
         if paths.empty?
           '' # Using rake
         else

data/lib/cucumber/js_support/js_snippets.rb

@@ -4,7 +4,7 @@ module Cucumber
       PARAM_PATTERN = /"([^"]*)"/
       ESCAPED_PARAM_PATTERN = '"([^\\"]*)"'
 
-      def snippet_text(step_keyword, step_name, multiline_arg_class)
+      def snippet_text(code_keyword, step_name, multiline_arg_class)
         escaped = Regexp.escape(step_name).gsub('\ ', ' ').gsub('/', '\/')
         escaped = escaped.gsub(PARAM_PATTERN, ESCAPED_PARAM_PATTERN)
 
@@ -20,7 +20,7 @@ module Cucumber
           multiline_class_comment = "//#{multiline_arg_class.default_arg_name} is a #{multiline_arg_class.to_s}\n"
         end
 
-        "#{step_keyword}(/^#{escaped}$/, function(#{block_arg_string}){\n  #{multiline_class_comment}  //express the regexp above with the code you wish you had\n});"
+        "#{code_keyword}(/^#{escaped}$/, function(#{block_arg_string}){\n  #{multiline_class_comment}  //express the regexp above with the code you wish you had\n});"
       end
     end
   end

data/lib/cucumber/language_support.rb

@@ -1,5 +1,5 @@
 module Cucumber
-  # This module defines the API for programming panguage support in Cucumber.
+  # This module defines the API for programming language support in Cucumber.
   # While Cucumber itself is written in Ruby, any programming language can
   # be supported by implementing this API.
   #
@@ -27,4 +27,4 @@ module Cucumber
   #
   module LanguageSupport
   end
-end
+end

data/lib/cucumber/parser/gherkin_builder.rb

@@ -13,28 +13,33 @@ module Cucumber
         @feature || @multiline_arg
       end
 
-      def feature(statement, uri)
+      def feature(feature)
         @feature = Ast::Feature.new(
           nil, 
-          Ast::Comment.new(statement.comments.map{|comment| comment.value}.join("\n")), 
-          Ast::Tags.new(nil, statement.tags.map{|tag| tag.name}),
-          statement.keyword,
-          legacy_name_for(statement.name, statement.description),
+          Ast::Comment.new(feature.comments.map{|comment| comment.value}.join("\n")), 
+          Ast::Tags.new(nil, feature.tags.map{|tag| tag.name}),
+          feature.keyword,
+          feature.name.lstrip,
+          feature.description.rstrip,
           []
         )
+        @feature.gherkin_statement(feature)
+        @feature
       end
 
-      def background(statement)
+      def background(background)
         @background = Ast::Background.new(
-          Ast::Comment.new(statement.comments.map{|comment| comment.value}.join("\n")), 
-          statement.line, 
-          statement.keyword, 
-          legacy_name_for(statement.name, statement.description), 
+          Ast::Comment.new(background.comments.map{|comment| comment.value}.join("\n")), 
+          background.line, 
+          background.keyword, 
+          background.name, 
+          background.description,
           steps=[]
         )
         @feature.background = @background
         @background.feature = @feature
         @step_container = @background
+        @background.gherkin_statement(background)
       end
 
       def scenario(statement)
@@ -44,12 +49,14 @@ module Cucumber
           Ast::Tags.new(nil, statement.tags.map{|tag| tag.name}), 
           statement.line, 
           statement.keyword, 
-          legacy_name_for(statement.name, statement.description), 
+          statement.name,
+          statement.description, 
           steps=[]
         )
         @feature.add_feature_element(scenario)
         @background.feature_elements << scenario if @background
         @step_container = scenario
+        scenario.gherkin_statement(statement)
       end
 
       def scenario_outline(statement)
@@ -59,7 +66,8 @@ module Cucumber
           Ast::Tags.new(nil, statement.tags.map{|tag| tag.name}), 
           statement.line, 
           statement.keyword, 
-          legacy_name_for(statement.name, statement.description), 
+          statement.name, 
+          statement.description, 
           steps=[],
           example_sections=[]
         )
@@ -69,25 +77,28 @@ module Cucumber
           @background.feature_elements << scenario_outline
         end
         @step_container = scenario_outline
+        scenario_outline.gherkin_statement(statement)
       end
 
-      def examples(statement, examples_rows)
+      def examples(examples)
         examples_fields = [
-          Ast::Comment.new(statement.comments.map{|comment| comment.value}.join("\n")), 
-          statement.line, 
-          statement.keyword, 
-          legacy_name_for(statement.name, statement.description), 
-          matrix(examples_rows)
+          Ast::Comment.new(examples.comments.map{|comment| comment.value}.join("\n")), 
+          examples.line, 
+          examples.keyword, 
+          examples.name, 
+          examples.description, 
+          matrix(examples.rows)
         ]
-        @step_container.add_examples(examples_fields)
+        @step_container.add_examples(examples_fields, examples)
       end
 
-      def step(statement, multiline_arg, result)
-        @table_owner = Ast::Step.new(statement.line, statement.keyword, statement.name)
-        multiline_arg = rubify(multiline_arg)
+      def step(step)
+        @table_owner = Ast::Step.new(step.line, step.keyword, step.name)
+        @table_owner.gherkin_statement(step)
+        multiline_arg = rubify(step.multiline_arg)
         case(multiline_arg)
-        when Gherkin::Formatter::Model::PyString
-          @table_owner.multiline_arg = Ast::PyString.new(multiline_arg.value)
+        when Gherkin::Formatter::Model::DocString
+          @table_owner.multiline_arg = Ast::DocString.new(multiline_arg.value)
         when Array
           @table_owner.multiline_arg = Ast::Table.new(matrix(multiline_arg))
         end
@@ -103,12 +114,6 @@ module Cucumber
       
     private
     
-      def legacy_name_for(name, description)
-        s = name
-        s += "\n#{description}" if description != ""
-        s
-      end
-
       def matrix(gherkin_table)
         gherkin_table.map do |gherkin_row|
           row = gherkin_row.cells

data/lib/cucumber/platform.rb

@@ -1,29 +1,29 @@
 # Detect the platform we're running on so we can tweak behaviour
 # in various places.
 require 'rbconfig'
-require 'yaml'
 
 module Cucumber
-  version       = YAML.load_file(File.dirname(__FILE__) + '/../../VERSION.yml')
-  VERSION       = [version[:major], version[:minor], version[:patch], version[:build]].compact.join('.')
+unless defined?(Cucumber::VERSION)
+  VERSION       = '0.10.7'
   BINARY        = File.expand_path(File.dirname(__FILE__) + '/../../bin/cucumber')
   LIBDIR        = File.expand_path(File.dirname(__FILE__) + '/../../lib')
   JRUBY         = defined?(JRUBY_VERSION)
   IRONRUBY      = defined?(RUBY_ENGINE) && RUBY_ENGINE == "ironruby"
-  WINDOWS       = Config::CONFIG['host_os'] =~ /mswin|mingw/
-  OS_X          = Config::CONFIG['host_os'] =~ /darwin/
+  WINDOWS       = RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
+  OS_X          = RbConfig::CONFIG['host_os'] =~ /darwin/
   WINDOWS_MRI   = WINDOWS && !JRUBY && !IRONRUBY
   RAILS         = defined?(Rails)
-  RUBY_BINARY   = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
+  RUBY_BINARY   = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
   RUBY_1_9      = RUBY_VERSION =~ /^1\.9/
   RUBY_1_8_7    = RUBY_VERSION =~ /^1\.8\.7/
 
   class << self
     attr_accessor :use_full_backtrace
 
-    def file_mode(m) #:nodoc:
-      RUBY_1_9 ? "#{m}:UTF-8" : m
+    def file_mode(m, encoding="UTF-8") #:nodoc:
+      RUBY_1_9 ? "#{m}:#{encoding}" : m
     end
   end
   self.use_full_backtrace = false
 end
+end

data/lib/cucumber/py_support/py_language.rb

@@ -28,8 +28,8 @@ module Cucumber
         mod = import(py_file)
       end
 
-      def snippet_text(step_keyword, step_name, multiline_arg_class)
-        "python snippet: #{step_keyword}, #{step_name}"
+      def snippet_text(code_keyword, step_name, multiline_arg_class)
+        "python snippet: #{code_keyword}, #{step_name}"
       end
 
       def begin_scenario(scenario)