cucumber 1.3.20 → 2.0.0.beta.1

data/lib/cucumber/runtime.rb

@@ -1,3 +1,4 @@
+# -*- coding: utf-8 -*-
 require 'fileutils'
 require 'multi_json'
 require 'multi_test'
@@ -7,16 +8,41 @@ require 'cucumber/configuration'
 require 'cucumber/load_path'
 require 'cucumber/language_support/language_methods'
 require 'cucumber/formatter/duration'
-require 'cucumber/runtime/user_interface'
-require 'cucumber/runtime/features_loader'
-require 'cucumber/runtime/results'
-require 'cucumber/runtime/support_code'
+require 'cucumber/file_specs'
 
 module Cucumber
-  # This is the meaty part of Cucumber that ties everything together.
+  module FixRuby21Bug9285
+    def message
+      String(super).gsub("@ rb_sysopen ", "")
+    end
+  end
+
+  class FileException < Exception
+    attr :path
+
+    def initialize(original_exception, path)
+      super(original_exception)
+      @path = path
+    end
+  end
+
+  class FileNotFoundException < FileException
+  end
+
+  class FeatureFolderNotFoundException < FileException
+    include FixRuby21Bug9285 if Cucumber::RUBY_2_1
+  end
+
+  require 'cucumber/core'
+  require 'cucumber/runtime/user_interface'
+  require 'cucumber/runtime/features_loader'
+  require 'cucumber/runtime/results'
+  require 'cucumber/runtime/support_code'
+  require 'cucumber/runtime/tag_limits'
   class Runtime
-    attr_reader :results
+    attr_reader :results, :support_code, :configuration
 
+    include Cucumber::Core
     include Formatter::Duration
     include Runtime::UserInterface
 
@@ -40,19 +66,20 @@ module Cucumber
 
     def run!
       load_step_definitions
-      disable_minitest_test_unit_autorun
       fire_after_configuration_hook
+      self.visitor = report
 
-      tree_walker = @configuration.build_tree_walker(self)
-      self.visitor = tree_walker # Ugly circular dependency, but needed to support World#puts
-
-      tree_walker.visit_features(features)
+      execute features, mappings, report, filters
     end
 
     def features_paths
       @configuration.paths
     end
 
+    def dry_run?
+      @configuration.dry_run?
+    end
+
     def step_visited(step) #:nodoc:
       @results.step_visited(step)
     end
@@ -73,8 +100,8 @@ module Cucumber
       @support_code.unmatched_step_definitions
     end
 
-    def snippet_text(step_keyword, step_name, multiline_arg_class) #:nodoc:
-      @support_code.snippet_text(Gherkin::I18n.code_keyword_for(step_keyword), step_name, multiline_arg_class)
+    def snippet_text(step_keyword, step_name, multiline_arg) #:nodoc:
+      @support_code.snippet_text(::Gherkin::I18n.code_keyword_for(step_keyword), step_name, multiline_arg)
     end
 
     def with_hooks(scenario, skip_hooks=false)
@@ -98,23 +125,31 @@ module Cucumber
       before(scenario) unless skip_hooks
       yield scenario
       after(scenario) unless skip_hooks
+      record_result scenario
+    end
+
+    def record_result(scenario)
       @results.scenario_visited(scenario)
     end
 
+    def begin_scenario(scenario)
+      @support_code.fire_hook(:begin_scenario, scenario)
+    end
+
     def before(scenario) #:nodoc:
-      return if @configuration.dry_run? || @current_scenario
+      return if dry_run? || @current_scenario
       @current_scenario = scenario
       @support_code.fire_hook(:before, scenario)
     end
 
     def after(scenario) #:nodoc:
       @current_scenario = nil
-      return if @configuration.dry_run?
+      return if dry_run?
       @support_code.fire_hook(:after, scenario)
     end
 
     def after_step #:nodoc:
-      return if @configuration.dry_run?
+      return if dry_run?
       @support_code.fire_hook(:execute_after_step, @current_scenario)
     end
 
@@ -122,6 +157,7 @@ module Cucumber
       @support_code.unknown_programming_language?
     end
 
+    # TODO: this code is untested
     def write_stepdefs_json
       if(@configuration.dotcucumber)
         stepdefs = []
@@ -162,7 +198,9 @@ module Cucumber
     # Returns Ast::DocString for +string_without_triple_quotes+.
     #
     def doc_string(string_without_triple_quotes, content_type='', line_offset=0)
-      Ast::DocString.new(string_without_triple_quotes,content_type)
+      file, line = *caller[0].split(':')[0..1]
+      location = Core::Ast::Location.new(file, line)
+      Core::Ast::DocString.new(string_without_triple_quotes, content_type, location)
     end
 
   private
@@ -171,12 +209,127 @@ module Cucumber
       @support_code.fire_hook(:after_configuration, @configuration)
     end
 
+    require 'cucumber/core/gherkin/document'
     def features
-      @loader ||= Runtime::FeaturesLoader.new(
-        @configuration.feature_files,
-        @configuration.filters,
-        @configuration.tag_expression)
-      @loader.features
+      @features ||= feature_files.map do |path|
+        source = NormalisedEncodingFile.read(path)
+        Cucumber::Core::Gherkin::Document.new(path, source)
+      end
+    end
+
+    def feature_files
+      filespecs.files
+    end
+
+    def filespecs
+      @filespecs ||= FileSpecs.new(@configuration.feature_files)
+    end
+
+    class NormalisedEncodingFile
+      COMMENT_OR_EMPTY_LINE_PATTERN = /^\s*#|^\s*$/ #:nodoc:
+      ENCODING_PATTERN = /^\s*#\s*encoding\s*:\s*([^\s]+)/ #:nodoc:
+
+      def self.read(path)
+        new(path).read
+      end
+
+      def initialize(path)
+        begin
+          @file = File.new(path)
+          set_encoding
+        rescue Errno::EACCES => e
+          raise FileNotFoundException.new(e, File.expand_path(path))
+        rescue Errno::ENOENT => e
+          raise FeatureFolderNotFoundException.new(e, path)
+        end
+      end
+
+      def read
+        @file.read.encode("UTF-8")
+      end
+
+      private
+
+      def set_encoding
+        @file.each do |line|
+          if ENCODING_PATTERN =~ line
+            @file.set_encoding $1
+            break
+          end
+          break unless COMMENT_OR_EMPTY_LINE_PATTERN =~ line
+        end
+        @file.rewind
+      end
+    end
+
+    require 'cucumber/mappings'
+    def mappings
+      @mappings = Mappings.for(self)
+    end
+
+    require 'cucumber/reports/legacy_formatter'
+    def report
+      @report ||= Cucumber::Reports::LegacyFormatter.new(self, @configuration.formatters(self))
+    end
+
+    require 'cucumber/core/test/filters'
+    def filters
+      tag_expressions = @configuration.tag_expressions
+      name_regexps = @configuration.name_regexps
+      tag_limits = @configuration.tag_limits
+      [].tap do |filters|
+        filters << [Cucumber::Runtime::Randomizer, [@configuration.seed]] if @configuration.randomize?
+        filters << [Cucumber::Runtime::TagLimits::Filter, [tag_limits]] if tag_limits.any?
+        filters << [Cucumber::Core::Test::TagFilter, [tag_expressions]]
+        filters << [Cucumber::Core::Test::NameFilter, [name_regexps]]
+        filters << [Cucumber::Core::Test::LocationsFilter, [filespecs.locations]]
+        filters << [Quit, []]
+      end
+    end
+
+    class Randomizer
+      def initialize(seed, receiver)
+        @receiver = receiver
+        @test_cases = []
+        @seed = seed
+      end
+
+      def test_case(test_case)
+        @test_cases << test_case
+      end
+
+      def done
+        shuffled_test_cases.each do |test_case|
+          test_case.describe_to(@receiver)
+        end
+        @receiver.done
+      end
+
+      private
+
+      def shuffled_test_cases
+        @test_cases.shuffle(random: Random.new(seed))
+      end
+
+      attr_reader :seed
+      private :seed
+    end
+
+    class Quit
+      def initialize(receiver)
+        @receiver = receiver
+      end
+
+      def test_case(test_case)
+        unless Cucumber.wants_to_quit
+          test_case.describe_to @receiver
+        end
+      end
+
+      def done
+        @receiver.done
+        self
+      end
     end
 
     def load_step_definitions
@@ -184,13 +337,10 @@ module Cucumber
       @support_code.load_files!(files)
     end
 
-    def disable_minitest_test_unit_autorun
-      MultiTest.disable_autorun
-    end
-
     def log
       Cucumber.logger
     end
+
   end
 
 end

data/lib/cucumber/runtime/for_programming_languages.rb

@@ -1,4 +1,6 @@
 require 'forwardable'
+require 'cucumber/core/ast/doc_string'
+require 'cucumber/core/ast/data_table'
 
 module Cucumber
   class Runtime
@@ -25,7 +27,7 @@ module Cucumber
         :invoke,
         :load_programming_language
 
-      # Returns a Cucumber::Ast::Table for +text_or_table+, which can either
+      # Returns a Cucumber::Core::Ast::DataTable for +text_or_table+, which can either
       # be a String:
       #
       #   table(%{
@@ -43,17 +45,21 @@ module Cucumber
       #   ])
       #
       def table(text_or_table, file=nil, line_offset=0)
+        file, line = *caller[0].split(':')[0..1]
+        location = Core::Ast::Location.new(file, line)
         if Array === text_or_table
-          Ast::Table.new(text_or_table)
+          Core::Ast::DataTable.new(text_or_table, location)
         else
-          Ast::Table.parse(text_or_table, file, line_offset)
+          Core::Ast::DataTable.parse(text_or_table, file, location)
         end
       end
 
       # Returns Ast::DocString for +string_without_triple_quotes+.
       #
       def doc_string(string_without_triple_quotes, content_type='', line_offset=0)
-        Ast::DocString.new(string_without_triple_quotes,content_type)
+        file, line = *caller[0].split(':')[0..1]
+        location = Core::Ast::Location.new(file, line)
+        Core::Ast::DocString.new(string_without_triple_quotes,content_type, location)
       end
     end
   end

data/lib/cucumber/runtime/gated_receiver.rb

@@ -0,0 +1,21 @@
+module Cucumber
+  class Runtime
+    class GatedReceiver
+      def initialize(receiver)
+        @receiver = receiver
+        @test_cases = []
+      end
+
+      def test_case(test_case)
+        @test_cases << test_case
+      end
+
+      def done
+        @test_cases.map do |test_case|
+          test_case.describe_to(@receiver)
+        end
+        @receiver.done
+      end
+    end
+  end
+end

data/lib/cucumber/runtime/support_code.rb

@@ -1,5 +1,5 @@
 require 'cucumber/constantize'
-require 'cucumber/ast/multiline_argument'
+require 'cucumber/core/ast/multiline_argument'
 require 'cucumber/runtime/for_programming_languages'
 
 module Cucumber
@@ -20,7 +20,9 @@ module Cucumber
         end
 
         def step(step)
-          @support_code.invoke(step.name, Ast::MultilineArgument.from(step.doc_string || step.rows))
+          location = Cucumber::Core::Ast::Location.new(*caller[0].split(':')[0..1])
+          core_multiline_arg = Core::Ast::MultilineArgument.from(step.doc_string || step.rows, location)
+          @support_code.invoke(step.name, MultilineArgument.from(core_multiline_arg))
         end
 
         def eof
@@ -53,9 +55,9 @@ module Cucumber
         parser.parse(steps_text, file, line.to_i)
       end
 
-      def invoke(step_name, multiline_argument=nil)
-        multiline_argument = Cucumber::Ast::MultilineArgument.from(multiline_argument)
-        # It is very important to leave multiline_argument=nil as a vararg. Cuke4Duke needs it that way.
+      def invoke(step_name, multiline_argument)
+        file, line = *caller[2].split(':')[0..1]
+        location = Core::Ast::Location.new(file, line)
         begin
           step_match(step_name).invoke(multiline_argument)
         rescue Exception => e
@@ -96,10 +98,10 @@ module Cucumber
         end.flatten
       end
 
-      def snippet_text(step_keyword, step_name, multiline_arg_class) #:nodoc:
+      def snippet_text(step_keyword, step_name, multiline_arg) #:nodoc:
         load_programming_language('rb') if unknown_programming_language?
         @programming_languages.map do |programming_language|
-          programming_language.snippet_text(step_keyword, step_name, multiline_arg_class, @configuration.snippet_type)
+          programming_language.snippet_text(step_keyword, step_name, multiline_arg, @configuration.snippet_type)
         end.join("\n")
       end
 

data/lib/cucumber/runtime/tag_limits.rb

@@ -0,0 +1,15 @@
+require "cucumber/runtime/tag_limits/test_case_index"
+require "cucumber/runtime/tag_limits/filter"
+require "cucumber/runtime/tag_limits/verifier"
+
+module Cucumber
+  class Runtime
+    module TagLimits
+      class TagLimitExceededError < StandardError
+        def initialize(*limit_breaches)
+          super(limit_breaches.map(&:to_s).join("\n"))
+        end
+      end
+    end
+  end
+end

data/lib/cucumber/runtime/tag_limits/filter.rb

@@ -0,0 +1,31 @@
+require "cucumber/runtime/gated_receiver"
+
+module Cucumber
+  class Runtime
+    module TagLimits
+      class Filter
+        def initialize(tag_limits, receiver)
+          @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)
+        end
+
+        def done
+          verifier.verify!(test_case_index)
+          gated_receiver.done
+        end
+
+        private
+
+        attr_reader :gated_receiver
+        attr_reader :test_case_index
+        attr_reader :verifier
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Cucumber
+  class Runtime
+    module 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