cucumber 1.3.10 → 2.0.0

data/lib/cucumber/filters/tag_limits/test_case_index.rb

@@ -0,0 +1,31 @@
+module Cucumber
+  module Filters
+    class TagLimits
+
+      class TestCaseIndex
+        def initialize
+          @index = Hash.new { |hash, key| hash[key] = [] }
+        end
+
+        def add(test_case)
+          test_case.tags.map(&:name).each do |tag_name|
+            index[tag_name] << test_case
+          end
+        end
+
+        def count_by_tag_name(tag_name)
+          index[tag_name].count
+        end
+
+        def locations_of_tag_name(tag_name)
+          index[tag_name].map(&:location)
+        end
+
+        private
+
+        attr_accessor :index
+      end
+
+    end
+  end
+end

data/lib/cucumber/filters/tag_limits/verifier.rb

@@ -0,0 +1,59 @@
+module Cucumber
+  module Filters
+    class TagLimits
+
+      class Verifier
+        def initialize(tag_limits)
+          @tag_limits = tag_limits
+        end
+
+        def verify!(test_case_index)
+          breaches = collect_breaches(test_case_index)
+          raise TagLimitExceededError.new(*breaches) unless breaches.empty?
+        end
+
+        private
+
+        def collect_breaches(test_case_index)
+          tag_limits.reduce([]) do |breaches, (tag_name, limit)|
+            breaches.tap do |breaches|
+              if test_case_index.count_by_tag_name(tag_name) > limit
+                breaches << Breach.new(tag_name, limit, test_case_index.locations_of_tag_name(tag_name))
+              end
+            end
+          end
+        end
+
+        attr_reader :tag_limits
+
+        class Breach
+          INDENT = (" " * 2).freeze
+
+          def initialize(tag_name, limit, locations)
+            @tag_name = tag_name
+            @limit = limit
+            @locations = locations
+          end
+
+          def to_s
+            [
+              "#{tag_name} occurred #{tag_count} times, but the limit was set to #{limit}",
+              *locations.map(&:to_s)
+            ].join("\n#{INDENT}")
+          end
+
+          private
+
+          def tag_count
+            locations.count
+          end
+
+          attr_reader :tag_name
+          attr_reader :limit
+          attr_reader :locations
+        end
+
+      end
+    end
+  end
+end

data/lib/cucumber/filters/tag_limits.rb

@@ -0,0 +1,45 @@
+require "cucumber/filters/gated_receiver"
+require "cucumber/filters/tag_limits/test_case_index"
+require "cucumber/filters/tag_limits/verifier"
+
+module Cucumber
+  module Filters
+    class TagLimitExceededError < StandardError
+      def initialize(*limit_breaches)
+        super(limit_breaches.map(&:to_s).join("\n"))
+      end
+    end
+
+    class TagLimits
+      def initialize(tag_limits, receiver=nil)
+        @tag_limits = tag_limits
+        @gated_receiver = GatedReceiver.new(receiver)
+        @test_case_index = TestCaseIndex.new
+        @verifier = Verifier.new(@tag_limits)
+      end
+
+      def test_case(test_case)
+        gated_receiver.test_case(test_case)
+        test_case_index.add(test_case)
+        self
+      end
+
+      def done
+        verifier.verify!(test_case_index)
+        gated_receiver.done
+        self
+      end
+
+      def with_receiver(receiver)
+        self.class.new(@tag_limits, receiver)
+      end
+
+      private
+
+      attr_reader :gated_receiver
+      attr_reader :test_case_index
+      attr_reader :verifier
+    end
+
+  end
+end

data/lib/cucumber/filters.rb

@@ -0,0 +1,9 @@
+require 'cucumber/filters/activate_steps'
+require 'cucumber/filters/apply_after_step_hooks'
+require 'cucumber/filters/apply_before_hooks'
+require 'cucumber/filters/apply_after_hooks'
+require 'cucumber/filters/apply_around_hooks'
+require 'cucumber/filters/prepare_world'
+require 'cucumber/filters/quit'
+require 'cucumber/filters/randomizer'
+require 'cucumber/filters/tag_limits'

data/lib/cucumber/formatter/ansicolor.rb

@@ -1,14 +1,6 @@
 require 'cucumber/platform'
 require 'cucumber/term/ansicolor'
 
-if Cucumber::IRONRUBY
-  begin
-    require 'iron-term-ansicolor'
-  rescue LoadError
-    STDERR.puts %{*** WARNING: You must "igem install iron-term-ansicolor" to get coloured ouput in on IronRuby}
-  end
-end
-
 if Cucumber::WINDOWS_MRI
   unless ENV['ANSICON']
     STDERR.puts %{*** WARNING: You must use ANSICON 1.31 or higher (https://github.com/adoxa/ansicon/) to get coloured output on Windows}

data/lib/cucumber/formatter/console.rb

@@ -32,7 +32,7 @@ module Cucumber
 
       def format_step(keyword, step_match, status, source_indent)
         comment = if source_indent
-          c = (' # ' + step_match.file_colon_line).indent(source_indent)
+          c = ('# ' + step_match.file_colon_line).indent(source_indent)
           format_string(c, :comment)
         else
           ''
@@ -77,17 +77,9 @@ module Cucumber
       end
 
       def print_stats(features, options)
-        @failures = runtime.scenarios(:failed).select { |s| s.is_a?(Cucumber::Ast::Scenario) || s.is_a?(Cucumber::Ast::OutlineTable::ExampleRow) }
-        @failures.collect! { |s| (s.is_a?(Cucumber::Ast::OutlineTable::ExampleRow)) ? s.scenario_outline : s }
-
-        if !@failures.empty?
-          @io.puts format_string("Failing Scenarios:", :failed)
-          @failures.each do |failure|
-            profiles_string = options.custom_profiles.empty? ? '' : (options.custom_profiles.map{|profile| "-p #{profile}" }).join(' ') + ' '
-            source = options[:source] ? format_string(" # Scenario: " + failure.name, :comment) : ''
-            @io.puts format_string("cucumber #{profiles_string}" + failure.file_colon_line, :failed) + source
-          end
-          @io.puts
+        failures = collect_failing_scenarios(runtime)
+        if !failures.empty?
+          print_failing_scenarios(failures, options.custom_profiles, options[:source])
         end
 
         @io.puts scenario_summary(runtime) {|status_count, status| format_string(status_count, status)}
@@ -95,11 +87,38 @@ module Cucumber
 
         @io.puts(format_duration(features.duration)) if features && features.duration
 
+        if runtime.configuration.randomize?
+          @io.puts
+          @io.puts "Randomized with seed #{runtime.configuration.seed}"
+        end
+
         @io.flush
       end
 
+      def collect_failing_scenarios(runtime)
+        # TODO: brittle - stop coupling to types
+        scenario_class = LegacyApi::Ast::Scenario
+        example_table_class = Core::Ast::ExamplesTable
+
+        runtime.scenarios(:failed).select do |s|
+          [scenario_class, example_table_class].include?(s.class)
+        end.map do |s|
+          s.is_a?(example_table_class)? s.scenario_outline : s
+        end
+      end
+
+      def print_failing_scenarios(failures, custom_profiles, given_source)
+        @io.puts format_string("Failing Scenarios:", :failed)
+        failures.each do |failure|
+          profiles_string = custom_profiles.empty? ? '' : (custom_profiles.map{|profile| "-p #{profile}" }).join(' ') + ' '
+          source = given_source ? format_string(" # " + failure.name, :comment) : ''
+          @io.puts format_string("cucumber #{profiles_string}" + failure.location, :failed) + source
+        end
+        @io.puts
+      end
+
       def print_exception(e, status, indent)
-        message = "#{e.message} (#{e.class})"
+        message = "#{e.message} (#{e.class})".force_encoding("UTF-8")
         if ENV['CUCUMBER_TRUNCATE_OUTPUT']
           message = linebreaks(message, ENV['CUCUMBER_TRUNCATE_OUTPUT'].to_i)
         end
@@ -113,29 +132,29 @@ module Cucumber
         s.gsub(/.{1,#{max}}(?:\s|\Z)/){($& + 5.chr).gsub(/\n\005/,"\n").gsub(/\005/,"\n")}.rstrip
       end
 
+      def collect_snippet_data(test_step, result)
+        # collect snippet data for undefined steps
+        unless hook?(test_step)
+          keyword = test_step.source.last.actual_keyword(@previous_step_keyword)
+          @previous_step_keyword = keyword
+          if result.undefined?
+            @snippets_input << Console::SnippetData.new(keyword, test_step.source.last)
+          end
+        end
+      end
+
       def print_snippets(options)
         return unless options[:snippets]
-        undefined = runtime.steps(:undefined)
-        return if undefined.empty?
+        return if runtime.steps(:undefined).empty?
 
-        unknown_programming_language = runtime.unknown_programming_language?
-        snippets = undefined.map do |step|
-          step_name = Undefined === step.exception ? step.exception.step_name : step.name
-          step_multiline_class = step.multiline_arg ? step.multiline_arg.class : nil
-          snippet = @runtime.snippet_text(step.actual_keyword, step_name, step_multiline_class)
-          snippet
-        end.compact.uniq
+        snippets = @snippets_input.map do |data|
+          @runtime.snippet_text(data.actual_keyword, data.step.name, data.step.multiline_arg)
+        end.uniq
 
         text = "\nYou can implement step definitions for undefined steps with these snippets:\n\n"
         text += snippets.join("\n\n")
         @io.puts format_string(text, :undefined)
 
-        if unknown_programming_language
-          @io.puts format_string("\nIf you want snippets in a different programming language," +
-                                 "\njust make sure a file with the appropriate file extension" +
-                                 "\nexists where cucumber looks for step definitions.", :failed)
-        end
-
         @io.puts
         @io.flush
       end
@@ -202,16 +221,27 @@ module Cucumber
         @io.puts "Using the #{profiles_sentence} profile#{'s' if profiles.size> 1}..."
       end
 
-    private
+      private
 
-    FORMATS = Hash.new{ |hash, format| hash[format] = method(format).to_proc }
+      FORMATS = Hash.new{ |hash, format| hash[format] = method(format).to_proc }
 
-    def format_for(*keys)
-      key = keys.join('_').to_sym
-      fmt = FORMATS[key]
-      raise "No format for #{key.inspect}: #{FORMATS.inspect}" if fmt.nil?
-      fmt
-    end
+      def format_for(*keys)
+        key = keys.join('_').to_sym
+        fmt = FORMATS[key]
+        raise "No format for #{key.inspect}: #{FORMATS.inspect}" if fmt.nil?
+        fmt
+      end
+
+      def hook?(test_step)
+        not test_step.source.last.respond_to?(:actual_keyword)
+      end
+
+      class SnippetData
+        attr_reader :actual_keyword, :step
+        def initialize(actual_keyword, step)
+          @actual_keyword, @step = actual_keyword, step
+        end
+      end
 
     end
   end

data/lib/cucumber/formatter/debug.rb

@@ -6,7 +6,11 @@ module Cucumber
     class Debug
       def initialize(runtime, io, options)
         @io = io
-        @indent = 0
+      end
+
+      def log(message)
+        return unless ENV['DEBUG']
+        @io.puts "* #{message}"
       end
 
       def respond_to?(*args)
@@ -14,19 +18,17 @@ module Cucumber
       end
 
       def method_missing(name, *args)
-        @indent -= 2 if name.to_s =~ /^after/
         print(name)
-        @indent += 2 if name.to_s =~ /^before/
+      end
+
+      def puts(*args)
+        print("puts")
       end
 
     private
 
       def print(text)
-        @io.puts "#{indent}#{text}"
-      end
-
-      def indent
-        (' ' * @indent)
+        @io.puts text
       end
     end
   end

data/lib/cucumber/formatter/fanout.rb

@@ -0,0 +1,27 @@
+module Cucumber
+  module Formatter
+
+    # Forwards any messages sent to this object to all recipients
+    # that respond to that message.
+    class Fanout < BasicObject
+      attr_reader :recipients
+      private :recipients
+
+      def initialize(recipients)
+        @recipients = recipients
+      end
+
+      def method_missing(message, *args)
+        recipients.each do |recipient|
+          recipient.send(message, *args) if recipient.respond_to?(message)
+        end
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        recipients.any? { |recipient| recipient.respond_to?(name, include_private) }
+      end
+
+    end
+
+  end
+end

data/lib/cucumber/formatter/gherkin_formatter_adapter.rb

@@ -6,9 +6,12 @@ module Cucumber
     # Adapts Cucumber formatter events to Gherkin formatter events
     # This class will disappear when Cucumber is based on Gherkin's model.
     class GherkinFormatterAdapter
-      def initialize(gherkin_formatter, print_empty_match)
+      def initialize(gherkin_formatter, print_empty_match, options)
         @gf = gherkin_formatter
         @print_empty_match = print_empty_match
+        @options = options
+        @delayed_messages = []
+        @delayed_embeddings = []
       end
 
       def before_feature(feature)
@@ -23,19 +26,59 @@ module Cucumber
 
       def before_feature_element(feature_element)
         case(feature_element)
-        when Ast::Scenario
+        when Core::Ast::Scenario
           @outline = false
           @gf.scenario(feature_element.gherkin_statement)
-        when Ast::ScenarioOutline
+        when Core::Ast::ScenarioOutline
           @outline = true
-          @gf.scenario_outline(feature_element.gherkin_statement)
+          if @options[:expand]
+            @in_instantiated_scenario = false
+            @current_scenario_hash = to_hash(feature_element.gherkin_statement)
+          else
+            @gf.scenario_outline(feature_element.gherkin_statement)
+          end
         else
           raise "Bad type: #{feature_element.class}"
         end
       end
 
+      def before_test_case(test_case)
+        @delay_output = true
+      end
+
+      def scenario_name(keyword, name, file_colon_line, source_indent)
+        if @outline and @options[:expand]
+          return if not @in_instantiated_scenario
+          if @new_example_table
+            @example_row = 1
+            @new_example_table = false
+          else
+            @example_row += 1
+          end
+          example_row_hash = @current_example_rows[@example_row].to_hash
+          scenario = Gherkin::Formatter::Model::Scenario.new(
+              @current_scenario_hash['comments'],
+              @current_scenario_hash['tags'],
+              @current_scenario_hash['keyword'],
+              @current_scenario_hash['name'],
+              @current_scenario_hash['description'],
+              example_row_hash['line'],
+              example_row_hash['id'])
+          @gf.scenario(scenario)
+        end
+      end
+
       def before_step(step)
-        @gf.step(step.gherkin_statement)
+        unless @outline and @options[:expand]
+          @gf.step(step.gherkin_statement)
+          pass_delayed_output
+          @delay_output = false
+        else 
+          if @in_instantiated_scenario
+            @current_step_hash = to_hash(step.gherkin_statement)
+            @delay_output = true
+          end
+        end
         if @print_empty_match
           if(@outline)
             match = Gherkin::Formatter::Model::Match.new(step.gherkin_statement.outline_args, nil)
@@ -44,7 +87,6 @@ module Cucumber
           end
           @gf.match(match)
         end
-        @step_time = Time.now
       end
 
       def before_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background, file_colon_line)
@@ -55,23 +97,53 @@ module Cucumber
           # Trick the formatter to believe that's what was printed previously so we get arg highlights on #result
           @gf.instance_variable_set('@match', match)
         else
-          @gf.match(match)
+          unless @outline and @options[:expand]
+            @gf.match(match)
+          end
         end
 
         error_message = exception ? "#{exception.message} (#{exception.class})\n#{exception.backtrace.join("\n")}" : nil
         unless @outline
           @gf.result(Gherkin::Formatter::Model::Result.new(status, nil, error_message))
+        else
+          if @options[:expand] and @in_instantiated_scenario
+            @current_match = match
+            @current_result = Gherkin::Formatter::Model::Result.new(status, nil, error_message)
+          end
+        end
+      end
+
+      def step_name(keyword, step_match, status, source_indent, background, file_colon_line)
+        if @outline and @options[:expand] and @in_instantiated_scenario
+          @gf.step(Gherkin::Formatter::Model::Step.new(
+              @current_step_hash['comments'],
+              @current_step_hash['keyword'],
+              step_match.format_args(),
+              file_colon_line.split(':')[1].to_i,
+              @current_step_hash['rows'],
+              @current_step_hash['doc_string']))
+          pass_delayed_output
+          @delay_output = false
+          @gf.match(@current_match)
+          @gf.result(@current_result)
         end
       end
 
       def before_examples(examples)
-        @gf.examples(examples.gherkin_statement)
+        unless @options[:expand]
+          @gf.examples(examples.gherkin_statement)
+        else
+          @in_instantiated_scenario = true
+          @new_example_table = true
+          @current_example_rows = to_hash(examples.gherkin_statement)['rows']
+        end
       end
 
       #used for capturing duration
       def after_step(step)
-        step_finish = (Time.now - @step_time)
-        @gf.append_duration(step_finish)
+        unless @outline and @options[:expand] and not @in_instantiated_scenario
+          step.duration.tap { |duration| @gf.append_duration(duration.nanoseconds / 10 ** 9.0) }
+        end
       end
 
       def after_feature(feature)
@@ -83,11 +155,49 @@ module Cucumber
       end
 
       def embed(file, mime_type, label)
-        data = File.open(file, 'rb') { |f| f.read }
+        if File.file?(file)
+          data = File.open(file, 'rb') { |f| f.read }
+        else
+          if mime_type =~ /;base64$/
+            mime_type = mime_type[0..-8]
+            data = Base64.decode64(file)
+          else
+            data = file
+          end
+        end
         if defined?(JRUBY_VERSION)
           data = data.to_java_bytes
         end
-        @gf.embedding(mime_type, data)
+        unless @delay_output
+          @gf.embedding(mime_type, data)
+        else
+          @delayed_embeddings.push [mime_type, data]
+        end
+      end
+
+      def puts(message)
+        unless @delay_output
+          @gf.write(message)
+        else
+          @delayed_messages.push message
+        end
+      end
+
+      private
+
+      def to_hash(gherkin_statement)
+        if defined?(JRUBY_VERSION)
+          gherkin_statement.toMap()
+        else
+          gherkin_statement.to_hash
+        end
+      end
+
+      def pass_delayed_output
+        @delayed_messages.each { |message| @gf.write(message) }
+        @delayed_embeddings.each { |embed_data| @gf.embedding(embed_data[0], embed_data[1]) }
+        @delayed_messages = []
+        @delayed_embeddings = []
       end
     end
   end