cucumber 0.8.6 → 0.8.7

data/lib/cucumber/formatter/unicode.rb

@@ -5,17 +5,14 @@ require 'cucumber/formatter/ansicolor'
 $KCODE='u' unless Cucumber::RUBY_1_9
 
 if Cucumber::WINDOWS
-  require 'iconv' unless Cucumber::RUBY_1_9
+  require 'iconv'
 
   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+)/
-    if [65000, 65001].include? $1.to_i
-      Cucumber::CODEPAGE = 'UTF-8'
-      ENV['ANSICON_API'] = 'ruby'
-    else
-      Cucumber::CODEPAGE = "cp#{$1.to_i}"
-    end
+    Cucumber::CODEPAGE = "cp#{$1.to_i}"
   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.")
@@ -27,45 +24,27 @@ if Cucumber::WINDOWS
         o.instance_eval do
           alias cucumber_print print
           def 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
+            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
 
           alias cucumber_puts puts
           def 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
+            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

data/lib/cucumber/js_support/js_dsl.js

@@ -1,15 +1,15 @@
 var CucumberJsDsl = {
   registerStepDefinition: function(regexp, func) {
     if(func == null) {
-      jsLanguage.execute_step_definition(regexp);
+      jsLanguage.executeStepDefinition(regexp);
     }
     else{
-      jsLanguage.add_step_definition(regexp, func);
+      jsLanguage.addStepDefinition(regexp, func);
     }
   },
 
   registerTransform: function(regexp, func) {
-    jsLanguage.register_js_transform(regexp, func);
+    jsLanguage.registerJsTransform(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.register_js_hook(label, tag_expressions, hook_func);
+    jsLanguage.registerJsHook(label, tag_expressions, hook_func);
   }
 }
 

data/lib/cucumber/js_support/js_language.rb

@@ -39,10 +39,6 @@ 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
@@ -105,10 +101,10 @@ module Cucumber
       include LanguageSupport::LanguageMethods
       include JsSnippets
 
-      def initialize(runtime)
+      def initialize(step_mother)
         @step_definitions = []
         @world = JsWorld.new
-        @runtime = runtime
+        @step_mother = step_mother
 
         @world["jsLanguage"] = self
         @world.load(File.dirname(__FILE__) + '/js_dsl.js')
@@ -150,7 +146,7 @@ module Cucumber
 
       #TODO: support multiline arguments when calling steps from within steps
       def execute_step_definition(name, multiline_argument = nil)
-        @runtime.step_match(name).invoke(multiline_argument)
+        @step_mother.step_match(name).invoke(multiline_argument)
       end
 
       def register_js_hook(phase, tag_expressions, js_function)
@@ -166,12 +162,12 @@ module Cucumber
       end
 
       def steps(steps_text, file_colon_line)
-        @runtime.invoke_steps(steps_text, @language, file_colon_line)
+        @step_mother.invoke_steps(steps_text, @language, file_colon_line)
       end
 
       private
       def path_to_load_js_from
-        paths = @runtime.features_paths
+        paths = @step_mother.options[: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(code_keyword, step_name, multiline_arg_class)
+      def snippet_text(step_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
 
-        "#{code_keyword}(/^#{escaped}$/, function(#{block_arg_string}){\n  #{multiline_class_comment}  //express the regexp above with the code you wish you had\n});"
+        "#{step_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 language support in Cucumber.
+  # This module defines the API for programming panguage 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,33 +13,28 @@ module Cucumber
         @feature || @multiline_arg
       end
 
-      def feature(feature)
+      def feature(statement, uri)
         @feature = Ast::Feature.new(
           nil, 
-          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,
+          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),
           []
         )
-        @feature.gherkin_statement(feature)
-        @feature
       end
 
-      def background(background)
+      def background(statement)
         @background = Ast::Background.new(
-          Ast::Comment.new(background.comments.map{|comment| comment.value}.join("\n")), 
-          background.line, 
-          background.keyword, 
-          background.name, 
-          background.description,
+          Ast::Comment.new(statement.comments.map{|comment| comment.value}.join("\n")), 
+          statement.line, 
+          statement.keyword, 
+          legacy_name_for(statement.name, statement.description), 
           steps=[]
         )
         @feature.background = @background
         @background.feature = @feature
         @step_container = @background
-        @background.gherkin_statement(background)
       end
 
       def scenario(statement)
@@ -49,14 +44,12 @@ module Cucumber
           Ast::Tags.new(nil, statement.tags.map{|tag| tag.name}), 
           statement.line, 
           statement.keyword, 
-          statement.name,
-          statement.description, 
+          legacy_name_for(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)
@@ -66,8 +59,7 @@ module Cucumber
           Ast::Tags.new(nil, statement.tags.map{|tag| tag.name}), 
           statement.line, 
           statement.keyword, 
-          statement.name, 
-          statement.description, 
+          legacy_name_for(statement.name, statement.description), 
           steps=[],
           example_sections=[]
         )
@@ -77,28 +69,25 @@ module Cucumber
           @background.feature_elements << scenario_outline
         end
         @step_container = scenario_outline
-        scenario_outline.gherkin_statement(statement)
       end
 
-      def examples(examples)
+      def examples(statement, examples_rows)
         examples_fields = [
-          Ast::Comment.new(examples.comments.map{|comment| comment.value}.join("\n")), 
-          examples.line, 
-          examples.keyword, 
-          examples.name, 
-          examples.description, 
-          matrix(examples.rows)
+          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)
         ]
-        @step_container.add_examples(examples_fields, examples)
+        @step_container.add_examples(examples_fields)
       end
 
-      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)
+      def step(statement, multiline_arg, result)
+        @table_owner = Ast::Step.new(statement.line, statement.keyword, statement.name)
+        multiline_arg = rubify(multiline_arg)
         case(multiline_arg)
-        when Gherkin::Formatter::Model::DocString
-          @table_owner.multiline_arg = Ast::DocString.new(multiline_arg.value)
+        when Gherkin::Formatter::Model::PyString
+          @table_owner.multiline_arg = Ast::PyString.new(multiline_arg.value)
         when Array
           @table_owner.multiline_arg = Ast::Table.new(matrix(multiline_arg))
         end
@@ -114,6 +103,12 @@ 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
-unless defined?(Cucumber::VERSION)
-  VERSION       = '0.10.7'
+  version       = YAML.load_file(File.dirname(__FILE__) + '/../../VERSION.yml')
+  VERSION       = [version[:major], version[:minor], version[:patch], version[:build]].compact.join('.')
   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       = RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
-  OS_X          = RbConfig::CONFIG['host_os'] =~ /darwin/
+  WINDOWS       = Config::CONFIG['host_os'] =~ /mswin|mingw/
+  OS_X          = Config::CONFIG['host_os'] =~ /darwin/
   WINDOWS_MRI   = WINDOWS && !JRUBY && !IRONRUBY
   RAILS         = defined?(Rails)
-  RUBY_BINARY   = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
+  RUBY_BINARY   = File.join(Config::CONFIG['bindir'], Config::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, encoding="UTF-8") #:nodoc:
-      RUBY_1_9 ? "#{m}:#{encoding}" : m
+    def file_mode(m) #:nodoc:
+      RUBY_1_9 ? "#{m}:UTF-8" : 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(code_keyword, step_name, multiline_arg_class)
-        "python snippet: #{code_keyword}, #{step_name}"
+      def snippet_text(step_keyword, step_name, multiline_arg_class)
+        "python snippet: #{step_keyword}, #{step_name}"
       end
 
       def begin_scenario(scenario)

data/lib/cucumber/rake/task.rb

@@ -1,5 +1,4 @@
 require 'cucumber/platform'
-require 'gherkin/formatter/ansi_escapes'
 
 begin
   # Support Rake > 0.8.7
@@ -7,7 +6,6 @@ begin
   include Rake::DSL
 rescue LoadError
 end
-
 module Cucumber
   module Rake
     # Defines a Rake task for running features.
@@ -16,7 +14,7 @@ module Cucumber
     #
     #   Cucumber::Rake::Task.new
     #
-    # This will define a task named <tt>cucumber</tt> described as 'Run Cucumber features'.
+    # This will define a task named <tt>cucumber</tt> described as 'Run Cucumber features'. 
     # It will use steps from 'features/**/*.rb' and features in 'features/**/*.feature'.
     #
     # To further configure the task, you can pass a block:
@@ -30,96 +28,68 @@ module Cucumber
     #   Cucumber::Rake::Task.new do |t|
     #     t.rcov = true
     #   end
-    #
+    # 
     # See the attributes for additional configuration possibilities.
     class Task
-      include Gherkin::Formatter::AnsiEscapes
-
       class InProcessCucumberRunner #:nodoc:
         attr_reader :args
-
+        
         def initialize(libs, cucumber_opts, feature_files)
           raise "libs must be an Array when running in-process" unless Array === libs
           libs.reverse.each{|lib| $LOAD_PATH.unshift(lib)}
           @args = (
-            cucumber_opts +
+            cucumber_opts + 
             feature_files
           ).flatten.compact
         end
-
+        
         def run
           require 'cucumber/cli/main'
           failure = Cucumber::Cli::Main.execute(args)
           raise "Cucumber failed" if failure
         end
       end
-
+      
       class ForkedCucumberRunner #:nodoc:
-
-        def initialize(libs, cucumber_bin, cucumber_opts, bundler, feature_files)
-          @libs          = libs
-          @cucumber_bin  = cucumber_bin
-          @cucumber_opts = cucumber_opts
-          @bundler       = bundler
-          @feature_files = feature_files
+        attr_reader :args
+        
+        def initialize(libs, cucumber_bin, cucumber_opts, feature_files)
+          @args = (
+            ['-I'] + load_path(libs) + 
+            quoted_binary(cucumber_bin) + 
+            cucumber_opts + 
+            feature_files
+          ).flatten
         end
 
         def load_path(libs)
-          ['"%s"' % @libs.join(File::PATH_SEPARATOR)]
+          ['"%s"' % libs.join(File::PATH_SEPARATOR)]
         end
 
         def quoted_binary(cucumber_bin)
           ['"%s"' % cucumber_bin]
         end
 
-        def use_bundler
-          @bundler.nil? ? File.exist?("./Gemfile") && gem_available?("bundler") : @bundler
-        end
-
-        def gem_available?(gemname)
-          gem_available_new_rubygems?(gemname) || gem_available_old_rubygems?(gemname)
-        end
-
-        def gem_available_old_rubygems?(gemname)
-          Gem.available?(gemname)
-        end
-
-        def gem_available_new_rubygems?(gemname)
-          Gem::Specification.respond_to?(:find_all_by_name) && Gem::Specification.find_all_by_name(gemname).any?
-        end
-
-        def cmd
-          if use_bundler
-            [ Cucumber::RUBY_BINARY, '-S', 'bundle', 'exec', 'cucumber', @cucumber_opts,
-            @feature_files ].flatten
-          else
-            [ Cucumber::RUBY_BINARY, '-I', load_path(@libs), quoted_binary(@cucumber_bin),
-            @cucumber_opts, @feature_files ].flatten
-          end
+        def runner
+          File.exist?("./Gemfile") ? ["bundle", "exec", RUBY] : [RUBY]
         end
 
         def run
-          sh(cmd.join(" "))
+          sh((runner + args).join(" "))
         end
       end
 
       class RCovCucumberRunner < ForkedCucumberRunner #:nodoc:
-
-        def initialize(libs, cucumber_bin, cucumber_opts, bundler, feature_files, rcov_opts)
-          super(       libs, cucumber_bin, cucumber_opts, bundler, feature_files )
-          @rcov_opts = rcov_opts
-        end
-
-        def cmd
-          if use_bundler
-            [Cucumber::RUBY_BINARY, '-S', 'bundle', 'exec', 'rcov', @rcov_opts,
-             quoted_binary(@cucumber_bin), '--', @cucumber_opts, @feature_files].flatten
-          else
-            [Cucumber::RUBY_BINARY, '-I', load_path(@libs), '-S', 'rcov', @rcov_opts,
-             quoted_binary(@cucumber_bin), '--', @cucumber_opts, @feature_files].flatten
-          end
+        def initialize(libs, cucumber_bin, cucumber_opts, feature_files, rcov_opts)
+          @args = (
+            ['-I'] + load_path(libs) + 
+            ['-S', 'rcov'] + rcov_opts +
+            quoted_binary(cucumber_bin) + 
+            ['--'] + 
+            cucumber_opts + 
+            feature_files
+          ).flatten
         end
-        
       end
 
       LIB = File.expand_path(File.dirname(__FILE__) + '/../..') #:nodoc:
@@ -140,12 +110,6 @@ module Cucumber
       # Run cucumber with RCov? Defaults to false. If you set this to
       # true, +fork+ is implicit.
       attr_accessor :rcov
-      def rcov=(flag)
-        if(flag && Cucumber::RUBY_1_9)
-          raise failed + "RCov only works on Ruby 1.8.x. You may want to use SimpleCov: https://github.com/colszowka/simplecov" + reset
-        end
-        @rcov = flag
-      end
 
       # Extra options to pass to rcov.
       # It's recommended to pass an Array, but if it's a String it will be #split by ' '.
@@ -159,17 +123,10 @@ module Cucumber
       # your load path and gems.
       attr_accessor :fork
 
-      # Define what profile to be used.  When used with cucumber_opts it is simply appended
+      # Define what profile to be used.  When used with cucumber_opts it is simply appended 
       # to it. Will be ignored when CUCUMBER_OPTS is used.
       attr_accessor :profile
 
-      # Whether or not to run with bundler (bundle exec). Setting this to false may speed
-      # up the execution. The default value is true if Bundler is installed and you have
-      # a Gemfile, false otherwise.
-      #
-      # Note that this attribute has no effect if you don't run in forked mode.
-      attr_accessor :bundler
-
       # Define Cucumber Rake task
       def initialize(task_name = "cucumber", desc = "Run Cucumber features")
         @task_name, @desc = task_name, desc
@@ -195,9 +152,9 @@ module Cucumber
       def runner(task_args = nil) #:nodoc:
         cucumber_opts = [(ENV['CUCUMBER_OPTS'] ? ENV['CUCUMBER_OPTS'].split(/\s+/) : nil) || cucumber_opts_with_profile]
         if(@rcov)
-          RCovCucumberRunner.new(libs, binary, cucumber_opts, bundler, feature_files, rcov_opts)
+          RCovCucumberRunner.new(libs, binary, cucumber_opts, feature_files, rcov_opts)
         elsif(@fork)
-          ForkedCucumberRunner.new(libs, binary, cucumber_opts, bundler, feature_files)
+          ForkedCucumberRunner.new(libs, binary, cucumber_opts, feature_files)
         else
           InProcessCucumberRunner.new(libs, cucumber_opts, feature_files)
         end