cucumber 2.0.0 → 2.0.1

data/lib/cucumber/cli/main.rb

@@ -36,27 +36,34 @@ module Cucumber
         end
 
         runtime.run!
-        failure = runtime.failure? || Cucumber.wants_to_quit
-        @kernel.exit(failure ? 1 : 0)
+        if Cucumber.wants_to_quit
+          exit_unable_to_finish
+        else
+          if runtime.failure?
+            exit_tests_failed
+          else
+            exit_ok
+          end
+        end
+      rescue SystemExit => e
+        @kernel.exit(e.status)
       rescue FileNotFoundException => e
         @err.puts(e.message)
         @err.puts("Couldn't open #{e.path}")
-        @kernel.exit(1)
+        exit_unable_to_finish
       rescue FeatureFolderNotFoundException => e
         @err.puts(e.message + ". You can use `cucumber --init` to get started.")
-        @kernel.exit(1)
+        exit_unable_to_finish
       rescue ProfilesNotDefinedError, YmlLoadError, ProfileNotFound => e
         @err.puts(e.message)
-        @kernel.exit(1)
-      rescue SystemExit => e
-        @kernel.exit(e.status)
+        exit_unable_to_finish
       rescue Errno::EACCES, Errno::ENOENT => e
         @err.puts("#{e.message} (#{e.class})")
-        @kernel.exit(1)
+        exit_unable_to_finish
       rescue Exception => e
         @err.puts("#{e.message} (#{e.class})")
         @err.puts(e.backtrace.join("\n"))
-        @kernel.exit(1)
+        exit_unable_to_finish
       end
 
       def configuration
@@ -68,9 +75,27 @@ module Cucumber
 
       private
 
+
+      def exit_ok
+        @kernel.exit 0
+      end
+
+      def exit_tests_failed
+        @kernel.exit 1
+      end
+
+      def exit_unable_to_finish
+        @kernel.exit 2
+      end
+
+      # stops the program immediately, without running at_exit blocks
+      def exit_unable_to_finish!
+        @kernel.exit! 2
+      end
+
       def trap_interrupt
         trap('INT') do
-          exit!(1) if Cucumber.wants_to_quit
+          exit_unable_to_finish! if Cucumber.wants_to_quit
           Cucumber.wants_to_quit = true
           STDERR.puts "\nExiting... Interrupt again to exit immediately."
         end

data/lib/cucumber/cli/options.rb

@@ -65,7 +65,7 @@ module Cucumber
         @profile_loader = options[:profile_loader]
         @options[:skip_profile_information] = options[:skip_profile_information]
 
-        @quiet = @disable_profile_loading = nil
+        @disable_profile_loading = nil
       end
 
       def [](key)
@@ -116,8 +116,12 @@ module Cucumber
           opts.on("--i18n LANG",
             "List keywords for in a particular language",
             %{Run with "--i18n help" to see all languages}) do |lang|
+            require 'gherkin/i18n'
+
             if lang == 'help'
               list_languages_and_exit
+            elsif !Gherkin::I18n::LANGUAGES.keys.include? lang
+              indicate_invalid_language_and_exit(lang)
             else
               list_keywords_and_exit(lang)
             end
@@ -188,6 +192,7 @@ module Cucumber
           opts.on("-d", "--dry-run", "Invokes formatters without executing the steps.",
             "This also omits the loading of your support/env.rb file if it exists.") do
             @options[:dry_run] = true
+            @options[:duration] = false
           end
           opts.on("-m", "--no-multiline",
             "Don't print multiline strings and tables under steps.") do
@@ -207,7 +212,12 @@ module Cucumber
           end
 
           opts.on("-q", "--quiet", "Alias for --no-snippets --no-source.") do
-            @quiet = true
+            @options[:snippets] = false
+            @options[:source] = false
+            @options[:duration] = false
+          end
+          opts.on("--no-duration", "Don't print the duration at the end of the summary") do
+            @options[:duration] = false
           end
           opts.on("-b", "--backtrace", "Show full backtrace for all errors.") do
             Cucumber.use_full_backtrace = true
@@ -252,17 +262,13 @@ TEXT
           end
         end.parse!
 
-        if @quiet
-          @options[:snippets] = @options[:source] = false
-        else
-          @options[:snippets] = true if @options[:snippets].nil?
-          @options[:source]   = true if @options[:source].nil?
-        end
         @args.map! { |a| "#{a}:#{@options[:lines]}" } if @options[:lines]
 
         extract_environment_variables
         @options[:paths] = @args.dup #whatver is left over
 
+        check_formatter_stream_conflicts()
+
         merge_profiles
 
         self
@@ -276,6 +282,13 @@ TEXT
         @options[:filters] ||= []
       end
 
+      def check_formatter_stream_conflicts()
+        streams = @options[:formats].uniq.map { |(_, stream)| stream }
+        if streams != streams.uniq
+          raise "All but one formatter must use --out, only one can print to each stream (or STDOUT)"
+        end
+      end
+
     protected
 
       attr_reader :options, :profiles, :expanded_args
@@ -353,6 +366,7 @@ TEXT
         end
         @options[:source] &= other_options[:source]
         @options[:snippets] &= other_options[:snippets]
+        @options[:duration] &= other_options[:duration]
         @options[:strict] |= other_options[:strict]
         @options[:dry_run] |= other_options[:dry_run]
 
@@ -369,6 +383,13 @@ TEXT
         self
       end
 
+      def indicate_invalid_language_and_exit(lang)
+        require 'gherkin/i18n'
+        @out_stream.write("Invalid language '#{lang}'. Available languages are:\n")
+        @out_stream.write(Gherkin::I18n.language_table)
+        Kernel.exit(0)
+      end
+
       def list_keywords_and_exit(lang)
         require 'gherkin/i18n'
         @out_stream.write(Gherkin::I18n.get(lang).keyword_table)
@@ -391,7 +412,10 @@ TEXT
           :tag_expressions  => [],
           :name_regexps => [],
           :env_vars     => {},
-          :diff_enabled => true
+          :diff_enabled => true,
+          :snippets     => true,
+          :source       => true,
+          :duration     => true
         }
       end
     end

data/lib/cucumber/cli/rerun_file.rb

@@ -0,0 +1,29 @@
+module Cucumber
+  module Cli
+    class RerunFile
+      attr_reader :path
+
+      def self.can_read?(path)
+        path[0] == '@' && File.file?(real_path(path))
+      end
+
+      def self.real_path(path)
+        path[1..-1] # remove leading @
+      end
+
+      def initialize(path)
+        @path = self.class.real_path(path)
+      end
+
+      def features
+        lines.map { |l| l.scan(/(?:^| )(.*?\.feature(?:(?::\d+)*))/) }.flatten
+      end
+
+      private
+
+      def lines
+        IO.read(@path).split("\n")
+      end
+    end
+  end
+end

data/lib/cucumber/filters/prepare_world.rb

@@ -24,9 +24,8 @@ module Cucumber
           end
           around_hooks = [init_scenario] + @original_test_case.around_hooks
 
-          default_hook = Cucumber::Hooks.before_hook(@original_test_case.source) do
-            #no op - legacy format adapter expects a before hooks
-          end
+          empty_hook = proc {} #no op - legacy format adapter expects a before hooks
+          default_hook = Cucumber::Hooks.before_hook(@original_test_case.source, Cucumber::Hooks.location(empty_hook), &empty_hook)
           steps = [default_hook] + @original_test_case.test_steps
 
           @original_test_case.with_around_hooks(around_hooks).with_steps(steps)

data/lib/cucumber/formatter/backtrace_filter.rb

@@ -0,0 +1,40 @@
+require 'cucumber/platform'
+
+
+module Cucumber
+  module Formatter
+
+    class BacktraceFilter
+      BACKTRACE_FILTER_PATTERNS = \
+      [/vendor\/rails|lib\/cucumber|bin\/cucumber:|lib\/rspec|gems\/|minitest|test\/unit|.gem\/ruby|lib\/ruby/]
+      if(::Cucumber::JRUBY)
+        BACKTRACE_FILTER_PATTERNS << /org\/jruby/
+      end
+      PWD_PATTERN = /#{::Regexp.escape(::Dir.pwd)}\//m
+
+      def initialize(exception)
+        @exception = exception
+      end
+
+      def exception
+        return @exception if ::Cucumber.use_full_backtrace
+        @exception.backtrace.each{|line| line.gsub!(PWD_PATTERN, "./")}
+
+        filtered = (@exception.backtrace || []).reject do |line|
+          BACKTRACE_FILTER_PATTERNS.detect { |p| line =~ p }
+        end
+
+        if ::ENV['CUCUMBER_TRUNCATE_OUTPUT']
+          # Strip off file locations
+          filtered = filtered.map do |line|
+            line =~ /(.*):in `/ ? $1 : line
+          end
+        end
+
+        @exception.set_backtrace(filtered)
+        @exception
+      end
+    end
+
+  end
+end

data/lib/cucumber/formatter/console.rb

@@ -76,7 +76,7 @@ module Cucumber
         end
       end
 
-      def print_stats(features, options)
+      def print_stats(duration, options)
         failures = collect_failing_scenarios(runtime)
         if !failures.empty?
           print_failing_scenarios(failures, options.custom_profiles, options[:source])
@@ -84,8 +84,7 @@ module Cucumber
 
         @io.puts scenario_summary(runtime) {|status_count, status| format_string(status_count, status)}
         @io.puts step_summary(runtime) {|status_count, status| format_string(status_count, status)}
-
-        @io.puts(format_duration(features.duration)) if features && features.duration
+        @io.puts(format_duration(duration)) if duration && options[:duration]
 
         if runtime.configuration.randomize?
           @io.puts

data/lib/cucumber/formatter/cucumber.css

@@ -197,6 +197,7 @@ body {
   background: #e0ffff;
   color: #001111;
   margin-left: 10px;
+  white-space: pre;
 }
 .cucumber #summary, td #summary, th #summary {
   margin: 0px;

data/lib/cucumber/formatter/duration_extractor.rb

@@ -0,0 +1,28 @@
+module Cucumber
+  module Formatter
+
+    class DurationExtractor
+      attr_reader :result_duration
+      def initialize(result)
+        @result_duration = 0
+        result.describe_to(self)
+      end
+
+      def passed(*) end
+
+      def failed(*) end
+
+      def undefined(*) end
+
+      def skipped(*) end
+
+      def pending(*) end
+
+      def exception(*) end
+
+      def duration(duration, *)
+        duration.tap { |duration| @result_duration = duration.nanoseconds / 10**9.0 }
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/hook_query_visitor.rb

@@ -0,0 +1,40 @@
+module Cucumber
+  module Formatter
+    class HookQueryVisitor
+      attr_reader :type
+
+      def initialize(test_step)
+        @hook = false
+        @type = :no_hook
+        test_step.source.last.describe_to(self)
+      end
+
+      def hook?
+        @hook
+      end
+
+      def step(*)
+      end
+
+      def before_hook(*)
+        @hook = true
+        @type = :before
+      end
+
+      def after_hook(*)
+        @hook = true
+        @type = :after
+      end
+
+      def after_step_hook(*)
+        @hook = true
+        @type = :after_step
+      end
+
+      def around_hook(*)
+        @hook = true
+        @type = :around
+      end
+    end
+  end
+end

data/lib/cucumber/formatter/html.rb

@@ -206,7 +206,13 @@ module Cucumber
           @builder << file_colon_line
         end
         @listing_background = false
-        @builder.h3(:id => "scenario_#{@scenario_number}") do
+        scenario_id = "scenario_#{@scenario_number}"
+        if @inside_outline
+          @outline_row += 1
+          scenario_id += "_#{@outline_row}"
+          @scenario_red = false
+        end
+        @builder.h3(:id => scenario_id) do
           @builder.span(keyword + ':', :class => 'keyword')
           @builder.text!(' ')
           @builder.span(name, :class => 'val')
@@ -414,6 +420,12 @@ module Cucumber
         @delayed_messages = []
       end
 
+      def after_test_case(test_case, result)
+        if result.failed? and not @scenario_red
+          set_scenario_color_failed
+        end
+      end
+
       protected
 
       def build_exception_detail(exception)
@@ -462,6 +474,9 @@ module Cucumber
           scenario_or_background = @in_background ? "background" : "scenario"
           @builder.text!("makeRed('#{scenario_or_background}_#{@scenario_number}');") unless @scenario_red
           @scenario_red = true
+          if @options[:expand] and @inside_outline
+            @builder.text!("makeRed('#{scenario_or_background}_#{@scenario_number}_#{@outline_row}');")
+          end
         end
       end
 

data/lib/cucumber/formatter/json.rb

@@ -1,19 +1,298 @@
-require 'cucumber/formatter/gherkin_formatter_adapter'
+require 'multi_json'
+require 'base64'
 require 'cucumber/formatter/io'
-require 'gherkin/formatter/argument'
-require 'gherkin/formatter/json_formatter'
+require 'cucumber/formatter/hook_query_visitor'
 
 module Cucumber
   module Formatter
     # The formatter used for <tt>--format json</tt>
-    class Json < GherkinFormatterAdapter
+    class Json
       include Io
 
-      def initialize(runtime, io, options)
-        @io = ensure_io(io, "json")
-        super(Gherkin::Formatter::JSONFormatter.new(@io), false, options)
+      def initialize(runtime, io, _options)
+        @runtime = runtime
+        @io = ensure_io(io, 'json')
+        @feature_hashes = []
       end
+
+      def before_test_case(test_case)
+        builder = Builder.new(test_case)
+        unless same_feature_as_previous_test_case?(test_case.feature)
+          @feature_hash = builder.feature_hash
+          @feature_hashes << @feature_hash
+        end
+        @test_case_hash = builder.test_case_hash
+        if builder.background?
+          feature_elements << builder.background_hash
+          @element_hash = builder.background_hash
+        else
+          feature_elements << @test_case_hash
+          @element_hash = @test_case_hash
+        end
+      end
+
+      def before_test_step(test_step)
+        return if internal_hook?(test_step)
+        hook_query = HookQueryVisitor.new(test_step)
+        if hook_query.hook?
+          @step_or_hook_hash = {}
+          hooks_of_type(hook_query) << @step_or_hook_hash
+          return
+        end
+        if first_step_after_background?(test_step)
+          feature_elements << @test_case_hash
+          @element_hash = @test_case_hash
+        end
+        @step_or_hook_hash = create_step_hash(test_step.source.last)
+        steps << @step_or_hook_hash
+        @step_hash = @step_or_hook_hash
+      end
+
+      def after_test_step(test_step, result)
+        return if internal_hook?(test_step)
+        add_match_and_result(test_step, result)
+      end
+
+      def done
+        @io.write(MultiJson.dump(@feature_hashes, pretty: true))
+      end
+
+      def puts(message)
+        test_step_output << message
+      end
+
+      def embed(src, mime_type, _label)
+        if File.file?(src)
+          content = File.open(src, 'rb') { |f| f.read }
+          data = encode64(content)
+        else
+          if mime_type =~ /;base64$/
+            mime_type = mime_type[0..-8]
+            data = src
+          else
+            data = encode64(src)
+          end
+        end
+        test_step_embeddings << { mime_type: mime_type, data: data }
+      end
+
+      private
+
+      def same_feature_as_previous_test_case?(feature)
+        current_feature[:uri] == feature.file && current_feature[:line] == feature.location.line
+      end
+
+      def first_step_after_background?(test_step)
+        test_step.source[1].name != @element_hash[:name]
+      end
+
+      def internal_hook?(test_step)
+        test_step.source.last.location.file.include?('lib/cucumber/')
+      end
+
+      def current_feature
+        @feature_hash ||= {}
+      end
+
+      def feature_elements
+        @feature_hash[:elements] ||= []
+      end
+
+      def steps
+        @element_hash[:steps] ||= []
+      end
+
+      def hooks_of_type(hook_query)
+        case hook_query.type
+        when :before
+          return before_hooks
+        when :after
+          return after_hooks
+        when :after_step
+          return after_step_hooks
+        else
+          fail 'Unkown hook type ' + hook_query.type.to_s
+        end
+      end
+
+      def before_hooks
+        @element_hash[:before] ||= []
+      end
+
+      def after_hooks
+        @element_hash[:after] ||= []
+      end
+
+      def after_step_hooks
+        @step_hash[:after] ||= []
+      end
+
+      def test_step_output
+        @step_or_hook_hash[:output] ||= []
+      end
+
+      def test_step_embeddings
+        @step_or_hook_hash[:embeddings] ||= []
+      end
+
+      def create_step_hash(step_source)
+        step_hash = {
+          keyword: step_source.keyword,
+          name: step_source.name,
+          line: step_source.location.line
+        }
+        step_hash[:comments] = Formatter.create_comments_array(step_source.comments) unless step_source.comments.empty?
+        step_hash[:doc_string] = create_doc_string_hash(step_source.multiline_arg) if step_source.multiline_arg.doc_string?
+        step_hash
+      end
+
+      def create_doc_string_hash(doc_string)
+        {
+          value: doc_string.content,
+          content_type: doc_string.content_type,
+          line: doc_string.location.line
+        }
+      end
+
+      def add_match_and_result(test_step, result)
+        @step_or_hook_hash[:match] = create_match_hash(test_step, result)
+        @step_or_hook_hash[:result] = create_result_hash(result)
+      end
+
+      def create_match_hash(test_step, result)
+        { location: test_step.action_location }
+      end
+
+      def create_result_hash(result)
+        result_hash = {
+          status: result.to_sym
+        }
+        result_hash[:error_message] = create_error_message(result) if result.failed? || result.pending?
+        result.duration.tap { |duration| result_hash[:duration] = duration.nanoseconds }
+        result_hash
+      end
+
+      def create_error_message(result)
+        message_element = result.failed? ? result.exception : result
+        message = "#{message_element.message} (#{message_element.class})"
+        ([message] + message_element.backtrace).join("\n")
+      end
+
+      def encode64(data)
+        # strip newlines from the encoded data
+        Base64.encode64(data).gsub(/\n/, '')
+      end
+
+      class Builder
+        attr_reader :feature_hash, :background_hash, :test_case_hash
+
+        def initialize(test_case)
+          @background_hash = nil
+          test_case.describe_source_to(self)
+          test_case.feature.background.describe_to(self)
+        end
+
+        def background?
+          @background_hash != nil
+        end
+
+        def feature(feature)
+          @feature_hash = {
+            uri: feature.file,
+            id: create_id(feature),
+            keyword: feature.keyword,
+            name: feature.name,
+            description: feature.description,
+            line: feature.location.line
+          }
+          unless feature.tags.empty?
+            @feature_hash[:tags] = create_tags_array(feature.tags)
+            if @test_case_hash[:tags]
+              @test_case_hash[:tags] = @feature_hash[:tags] + @test_case_hash[:tags]
+            else
+              @test_case_hash[:tags] = @feature_hash[:tags]
+            end
+          end
+          @feature_hash[:comments] = Formatter.create_comments_array(feature.comments) unless feature.comments.empty?
+          @test_case_hash[:id].insert(0, @feature_hash[:id] + ';')
+        end
+
+        def background(background)
+          @background_hash = {
+            keyword: background.keyword,
+            name: background.name,
+            description: background.description,
+            line: background.location.line,
+            type: 'background'
+          }
+          @background_hash[:comments] = Formatter.create_comments_array(background.comments) unless background.comments.empty?
+        end
+
+        def scenario(scenario)
+          @test_case_hash = {
+            id: create_id(scenario),
+            keyword: scenario.keyword,
+            name: scenario.name,
+            description: scenario.description,
+            line: scenario.location.line,
+            type: 'scenario'
+          }
+          @test_case_hash[:tags] = create_tags_array(scenario.tags) unless scenario.tags.empty?
+          @test_case_hash[:comments] = Formatter.create_comments_array(scenario.comments) unless scenario.comments.empty?
+        end
+
+        def scenario_outline(scenario)
+          @test_case_hash = {
+            id: create_id(scenario) + ';' + @example_id,
+            keyword: scenario.keyword,
+            name: scenario.name,
+            description: scenario.description,
+            line: @row.location.line,
+            type: 'scenario'
+          }
+          tags = []
+          tags += create_tags_array(scenario.tags) unless scenario.tags.empty?
+          tags += @examples_table_tags if @examples_table_tags
+          @test_case_hash[:tags] = tags unless tags.empty?
+          comments = []
+          comments += Formatter.create_comments_array(scenario.comments) unless scenario.comments.empty?
+          comments += @examples_table_comments if @examples_table_comments
+          comments += @row_comments if @row_comments
+          @test_case_hash[:comments] =  comments unless comments.empty?
+        end
+
+        def examples_table(examples_table)
+          # the json file have traditionally used the header row as row 1,
+          # wheras cucumber-ruby-core used the first example row as row 1.
+          @example_id = create_id(examples_table) + ";#{@row.number + 1}"
+
+          @examples_table_tags = create_tags_array(examples_table.tags) unless examples_table.tags.empty?
+          @examples_table_comments = Formatter.create_comments_array(examples_table.comments) unless examples_table.comments.empty?
+        end
+
+        def examples_table_row(row)
+          @row = row
+          @row_comments = Formatter.create_comments_array(row.comments) unless row.comments.empty?
+        end
+
+        private
+
+        def create_id(element)
+          element.name.downcase.gsub(/ /, '-')
+        end
+
+        def create_tags_array(tags)
+          tags_array = []
+          tags.each { |tag| tags_array << { name: tag.name, line: tag.location.line } }
+          tags_array
+        end
+      end
+    end
+
+    def self.create_comments_array(comments)
+      comments_array = []
+      comments.each { |comment| comments_array << { value: comment.to_s.strip, line: comment.location.line } }
+      comments_array
     end
   end
 end
-