cucumber 2.0.2 → 2.1.0

data/lib/cucumber/cli/configuration.rb

@@ -2,7 +2,7 @@ require 'logger'
 require 'cucumber/cli/options'
 require 'cucumber/cli/rerun_file'
 require 'cucumber/constantize'
-require 'gherkin/tag_expression'
+require 'cucumber/core/gherkin/tag_expression'
 
 module Cucumber
   module Cli
@@ -27,7 +27,7 @@ module Cucumber
         arrange_formats
         raise("You can't use both --strict and --wip") if strict? && wip?
         # todo: remove
-        @options[:tag_expression] = Gherkin::TagExpression.new(@options[:tag_expressions])
+        @options[:tag_expression] = Cucumber::Core::Gherkin::TagExpression.new(@options[:tag_expressions])
         set_environment_variables
       end
 
@@ -63,63 +63,12 @@ module Cucumber
         @options[:expand]
       end
 
-      def snippet_type
-        @options[:snippet_type] || :regexp
-      end
-
-      def formatter_class(format)
-        if(builtin = Options::BUILTIN_FORMATS[format])
-          constantize(builtin[0])
-        else
-          constantize(format)
-        end
-      end
-
-      def all_files_to_load
-        files = require_dirs.map do |path|
-          path = path.gsub(/\\/, '/') # In case we're on windows. Globs don't work with backslashes.
-          path = path.gsub(/\/$/, '') # Strip trailing slash.
-          File.directory?(path) ? Dir["#{path}/**/*"] : path
-        end.flatten.uniq
-        remove_excluded_files_from(files)
-        files.reject! {|f| !File.file?(f)}
-        files.reject! {|f| File.extname(f) == '.feature' }
-        files.reject! {|f| f =~ /^http/}
-        files.sort
-      end
-
-      def step_defs_to_load
-        all_files_to_load.reject {|f| f =~ %r{/support/} }
-      end
-
-      def support_to_load
-        support_files = all_files_to_load.select {|f| f =~ %r{/support/} }
-        env_files = support_files.select {|f| f =~ %r{/support/env\..*} }
-        other_files = support_files - env_files
-        @options[:dry_run] ? other_files : env_files + other_files
-      end
-
-      def feature_files
-        potential_feature_files = with_default_features_path(paths).map do |path|
-          path = path.gsub(/\\/, '/') # In case we're on windows. Globs don't work with backslashes.
-          path = path.chomp('/')
-          if File.directory?(path)
-            Dir["#{path}/**/*.feature"].sort
-          elsif RerunFile.can_read?(path)
-            RerunFile.new(path).features
-          else
-            path
-          end
-        end.flatten.uniq
-        remove_excluded_files_from(potential_feature_files)
-        potential_feature_files
+      def fail_fast?
+        !!@options[:fail_fast]
       end
 
-
-      def feature_dirs
-        dirs = paths.map { |f| File.directory?(f) ? f : File.dirname(f) }.uniq
-        dirs.delete('.') unless paths.include?('.')
-        with_default_features_path(dirs)
+      def snippet_type
+        @options[:snippet_type] || :regexp
       end
 
       def log
@@ -132,7 +81,7 @@ module Cucumber
 
       # todo: remove
       def tag_expression
-        Gherkin::TagExpression.new(@options[:tag_expressions])
+        Cucumber::Core::Gherkin::TagExpression.new(@options[:tag_expressions])
       end
 
       def tag_limits
@@ -164,31 +113,12 @@ module Cucumber
         @options[:paths]
       end
 
-      def formatter_factories
-        @options[:formats].map do |format_and_out|
-          format = format_and_out[0]
-          path_or_io = format_and_out[1]
-          begin
-            factory = formatter_class(format)
-            yield factory, path_or_io, @options
-          rescue Exception => e
-            e.message << "\nError creating formatter: #{format}"
-            raise e
-          end
-        end
+      def to_hash
+        Hash.try_convert(@options).merge(out_stream: @out_stream, error_stream: @error_stream)
       end
 
       private
 
-      def default_features_paths
-        ["features"]
-      end
-
-      def with_default_features_path(paths)
-        return default_features_paths if paths.empty?
-        paths
-      end
-
       class LogFormatter < ::Logger::Formatter
         def call(severity, time, progname, msg)
           msg
@@ -207,18 +137,6 @@ module Cucumber
         @options[:formats].uniq!
         @options.check_formatter_stream_conflicts()
       end
-
-      def remove_excluded_files_from(files)
-        files.reject! {|path| @options[:excludes].detect {|pattern| path =~ pattern } }
-      end
-
-      def require_dirs
-        if @options[:require].empty?
-          default_features_paths + Dir['vendor/{gems,plugins}/*/cucumber']
-        else
-          @options[:require]
-        end
-      end
     end
   end
-end
+end

data/lib/cucumber/cli/main.rb

@@ -1,9 +1,3 @@
-begin
-  require 'gherkin'
-rescue LoadError
-  require 'rubygems'
-  require 'gherkin'
-end
 require 'optparse'
 require 'cucumber'
 require 'logger'
@@ -102,4 +96,4 @@ module Cucumber
       end
     end
   end
-end
+end

data/lib/cucumber/cli/options.rb

@@ -43,6 +43,7 @@ module Cucumber
       NO_PROFILE_SHORT_FLAG = '-P'
       PROFILE_LONG_FLAG = '--profile'
       NO_PROFILE_LONG_FLAG = '--no-profile'
+      FAIL_FAST_FLAG = '--fail-fast'
       OPTIONS_WITH_ARGS = ['-r', '--require', '--i18n', '-f', '--format', '-o', '--out',
                                   '-t', '--tags', '-n', '--name', '-e', '--exclude',
                                   PROFILE_SHORT_FLAG, PROFILE_LONG_FLAG,
@@ -59,9 +60,9 @@ module Cucumber
         @error_stream = error_stream
 
         @default_profile = options[:default_profile]
-        @profiles = []
+        @profiles = options[:profiles] || []
         @overridden_paths = []
-        @options = default_options
+        @options = default_options.merge(options)
         @profile_loader = options[:profile_loader]
         @options[:skip_profile_information] = options[:skip_profile_information]
 
@@ -116,16 +117,19 @@ 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'
+            require 'gherkin3/dialect'
 
             if lang == 'help'
               list_languages_and_exit
-            elsif !Gherkin::I18n::LANGUAGES.keys.include? lang
+            elsif !::Gherkin3::DIALECTS.keys.include? lang
               indicate_invalid_language_and_exit(lang)
             else
               list_keywords_and_exit(lang)
             end
           end
+          opts.on(FAIL_FAST_FLAG, "Exit immediately following the first failing scenario") do |v|
+            options[:fail_fast] = true
+          end
           opts.on("-f FORMAT", "--format FORMAT",
             "How to format features (Default: pretty). Available formats:",
             *FORMAT_HELP) do |v|
@@ -289,6 +293,10 @@ TEXT
         end
       end
 
+      def to_hash
+        Hash.try_convert(@options)
+      end
+
     protected
 
       attr_reader :options, :profiles, :expanded_args
@@ -384,24 +392,51 @@ TEXT
       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)
+        list_languages_and_exit
       end
 
       def list_keywords_and_exit(lang)
-        require 'gherkin/i18n'
-        @out_stream.write(Gherkin::I18n.get(lang).keyword_table)
+        require 'gherkin3/dialect'
+        language = ::Gherkin3::Dialect.for(lang)
+        data = Cucumber::MultilineArgument::DataTable.from(
+          [["feature", to_keywords_string(language.feature_keywords)],
+          ["background", to_keywords_string(language.background_keywords)],
+          ["scenario", to_keywords_string(language.scenario_keywords)],
+          ["scenario_outline", to_keywords_string(language.scenario_outline_keywords)],
+          ["examples", to_keywords_string(language.examples_keywords)],
+          ["given", to_keywords_string(language.given_keywords)],
+          ["when", to_keywords_string(language.when_keywords)],
+          ["then", to_keywords_string(language.then_keywords)],
+          ["and", to_keywords_string(language.and_keywords)],
+          ["but", to_keywords_string(language.but_keywords)],
+          ["given (code)", to_code_keywords_string(language.given_keywords)],
+          ["when (code)", to_code_keywords_string(language.when_keywords)],
+          ["then (code)", to_code_keywords_string(language.then_keywords)],
+          ["and (code)", to_code_keywords_string(language.and_keywords)],
+          ["but (code)", to_code_keywords_string(language.but_keywords)]])
+        @out_stream.write(data.to_s({ color: false, prefixes: Hash.new('') }))
         Kernel.exit(0)
       end
 
       def list_languages_and_exit
-        require 'gherkin/i18n'
-        @out_stream.write(Gherkin::I18n.language_table)
+        require 'gherkin3/dialect'
+        data = Cucumber::MultilineArgument::DataTable.from(
+          ::Gherkin3::DIALECTS.keys.map do |key|
+            [key, ::Gherkin3::DIALECTS[key].fetch('name'), ::Gherkin3::DIALECTS[key].fetch('native')]
+          end)
+        @out_stream.write(data.to_s({ color: false, prefixes: Hash.new('') }))
         Kernel.exit(0)
       end
 
+      def to_keywords_string(list)
+        list.map { |item| "\"#{item}\"" }.join(', ')
+      end
+
+      def to_code_keywords_string(list)
+        to_keywords_string(Cucumber::Gherkin::I18n.code_keywords_for(list))
+      end
+
       def default_options
         {
           :strict       => false,
@@ -421,4 +456,4 @@ TEXT
     end
 
   end
-end
+end

data/lib/cucumber/configuration.rb

@@ -1,27 +1,70 @@
+require 'cucumber/constantize'
+require 'cucumber/cli/rerun_file'
+require 'cucumber/events'
+require 'forwardable'
+require 'cucumber/core/gherkin/tag_expression'
+
 module Cucumber
   # The base class for configuring settings for a Cucumber run.
   class Configuration
+    include Constantize
+    extend Forwardable
+
     def self.default
       new
     end
 
-    def self.parse(argument)
-      return new(argument) if argument.is_a?(Hash)
-      argument
-    end
+    # Subscribe to an event.
+    #
+    # See {Cucumber::Events} for the list of possible events.
+    #
+    # @param event_id [Symbol, Class, String] Identifier for the type of event to subscribe to
+    # @param handler_object [Object optional] an object to be called when the event occurs
+    # @yield [Object] Block to be called when th event occurs
+    # @method on_event
+    def_instance_delegator :event_bus, :register, :on_event
+
+    # @private
+    def_instance_delegator :event_bus, :notify
 
     def initialize(user_options = {})
-      @options = default_options.merge(user_options)
+      @options = default_options.merge(Hash.try_convert(user_options))
+    end
+
+    def with_options(new_options)
+      self.class.new(new_options.merge(@options))
+    end
+
+    # TODO: Actually Deprecate???
+    def options
+      warn("Deprecated: Configuration#options will be removed from the next release of Cucumber. Please use the configuration object directly instead.")
+      Marshal.load(Marhal.dump(@options))
+    end
+
+    def out_stream
+      @options[:out_stream]
+    end
+
+    def error_stream
+      @options[:error_stream]
     end
 
     def randomize?
-      @options[:randomize]
+      @options[:order] == 'random'
+    end
+
+    def seed
+      Integer(@options[:seed] || rand(0xFFFF))
     end
 
     def dry_run?
       @options[:dry_run]
     end
 
+    def fail_fast?
+      @options[:fail_fast]
+    end
+
     def guess?
       @options[:guess]
     end
@@ -30,6 +73,10 @@ module Cucumber
       @options[:strict]
     end
 
+    def wip?
+      @options[:wip]
+    end
+
     def expand?
       @options[:expand]
     end
@@ -38,6 +85,10 @@ module Cucumber
       @options[:paths]
     end
 
+    def formats
+      @options[:formats]
+    end
+
     def autoload_code_paths
       @options[:autoload_code_paths]
     end
@@ -46,12 +97,149 @@ module Cucumber
       @options[:snippet_type]
     end
 
+    def feature_dirs
+      dirs = paths.map { |f| File.directory?(f) ? f : File.dirname(f) }.uniq
+      dirs.delete('.') unless paths.include?('.')
+      with_default_features_path(dirs)
+    end
+
+    # todo: remove
+    def tag_expression
+      Cucumber::Core::Gherkin::TagExpression.new(@options[:tag_expressions])
+    end
+
+    def tag_limits
+      tag_expression.limits.to_hash
+    end
+
+    def tag_expressions
+      @options[:tag_expressions]
+    end
+
+    def name_regexps
+      @options[:name_regexps]
+    end
+
+    def filters
+      @options[:filters]
+    end
+
+    def feature_files
+      potential_feature_files = with_default_features_path(paths).map do |path|
+        path = path.gsub(/\\/, '/') # In case we're on windows. Globs don't work with backslashes.
+        path = path.chomp('/')
+
+        # TODO: Move to using feature loading strategies stored in
+        # options[:feature_loaders]
+        if File.directory?(path)
+          Dir["#{path}/**/*.feature"].sort
+        elsif Cli::RerunFile.can_read?(path)
+          Cli::RerunFile.new(path).features
+        else
+          path
+        end
+      end.flatten.uniq
+      remove_excluded_files_from(potential_feature_files)
+      potential_feature_files
+    end
+
+    def support_to_load
+      support_files = all_files_to_load.select {|f| f =~ %r{/support/} }
+      env_files = support_files.select {|f| f =~ %r{/support/env\..*} }
+      other_files = support_files - env_files
+      @options[:dry_run] ? other_files : env_files + other_files
+    end
+
+    def all_files_to_load
+      files = require_dirs.map do |path|
+        path = path.gsub(/\\/, '/') # In case we're on windows. Globs don't work with backslashes.
+        path = path.gsub(/\/$/, '') # Strip trailing slash.
+        File.directory?(path) ? Dir["#{path}/**/*"] : path
+      end.flatten.uniq
+      remove_excluded_files_from(files)
+      files.reject! {|f| !File.file?(f)}
+      files.reject! {|f| File.extname(f) == '.feature' }
+      files.reject! {|f| f =~ /^http/}
+      files.sort
+    end
+
+    def step_defs_to_load
+      all_files_to_load.reject {|f| f =~ %r{/support/} }
+    end
+
+    def formatter_factories
+      @options[:formats].map do |format_and_out|
+        format = format_and_out[0]
+        path_or_io = format_and_out[1]
+        begin
+          factory = formatter_class(format)
+          yield factory, path_or_io, Cli::Options.new(STDOUT, STDERR, @options)
+        rescue Exception => e
+          e.message << "\nError creating formatter: #{format}"
+          raise e
+        end
+      end
+    end
+
+    def formatter_class(format)
+      if(builtin = Cli::Options::BUILTIN_FORMATS[format])
+        constantize(builtin[0])
+      else
+        constantize(format)
+      end
+    end
+
+    def to_hash
+      @options
+    end
+
   private
 
     def default_options
       {
-        :autoload_code_paths => ['features/support', 'features/step_definitions']
+        :autoload_code_paths => ['features/support', 'features/step_definitions'],
+        :filters             => [],
+        :strict              => false,
+        :require             => [],
+        :dry_run             => false,
+        :fail_fast           => false,
+        :formats             => [],
+        :excludes            => [],
+        :tag_expressions     => [],
+        :name_regexps        => [],
+        :env_vars            => {},
+        :diff_enabled        => true,
+        :snippets            => true,
+        :source              => true,
+        :duration            => true,
+        :event_bus           => Events::Bus.new(Cucumber::Events)
       }
     end
+
+    def event_bus
+      @options[:event_bus]
+    end
+
+
+    def default_features_paths
+      ["features"]
+    end
+
+    def with_default_features_path(paths)
+      return default_features_paths if paths.empty?
+      paths
+    end
+
+    def remove_excluded_files_from(files)
+      files.reject! {|path| @options[:excludes].detect {|pattern| path =~ pattern } }
+    end
+
+    def require_dirs
+      if @options[:require].empty?
+        default_features_paths + Dir['vendor/{gems,plugins}/*/cucumber']
+      else
+        @options[:require]
+      end
+    end
   end
 end