cucumber 2.0.0.rc.4 → 4.0.0.rc.2

data/lib/cucumber/cli/profile_loader.rb

@@ -1,81 +1,97 @@
+# frozen_string_literal: true
+
 require 'yaml'
 
 module Cucumber
   module Cli
-
     class ProfileLoader
-
       def initialize
         @cucumber_yml = nil
       end
 
       def args_from(profile)
-        unless cucumber_yml.has_key?(profile)
+        unless cucumber_yml.key?(profile)
           raise(ProfileNotFound, <<-END_OF_ERROR)
 Could not find profile: '#{profile}'
 
 Defined profiles in cucumber.yml:
   * #{cucumber_yml.keys.sort.join("\n  * ")}
-        END_OF_ERROR
+          END_OF_ERROR
         end
 
         args_from_yml = cucumber_yml[profile] || ''
 
-        case(args_from_yml)
-          when String
-            raise YmlLoadError, "The '#{profile}' profile in cucumber.yml was blank.  Please define the command line arguments for the '#{profile}' profile in cucumber.yml.\n" if args_from_yml =~ /^\s*$/
-            if(Cucumber::WINDOWS)
-              #Shellwords treats backslash as an escape character so here's a rudimentary approximation of the same code
-              args_from_yml = args_from_yml.split
-              args_from_yml = args_from_yml.collect {|x| x.gsub(/^\"(.*)\"/,'\1') }
-            else
-              require 'shellwords'
-              args_from_yml = Shellwords.shellwords(args_from_yml)
-            end
-          when Array
-            raise YmlLoadError, "The '#{profile}' profile in cucumber.yml was empty.  Please define the command line arguments for the '#{profile}' profile in cucumber.yml.\n" if args_from_yml.empty?
-          else
-            raise YmlLoadError, "The '#{profile}' profile in cucumber.yml was a #{args_from_yml.class}. It must be a String or Array"
+        case args_from_yml
+        when String
+          if args_from_yml =~ /^\s*$/
+            raise YmlLoadError, "The '#{profile}' profile in cucumber.yml was blank." \
+            "  Please define the command line arguments for the '#{profile}' profile in cucumber.yml.\n"
+          end
+
+          args_from_yml = processed_shellwords(args_from_yml)
+        when Array
+          raise YmlLoadError, "The '#{profile}' profile in cucumber.yml was empty.  Please define the command line arguments for the '#{profile}' profile in cucumber.yml.\n" if args_from_yml.empty?
+        else
+          raise YmlLoadError, "The '#{profile}' profile in cucumber.yml was a #{args_from_yml.class}. It must be a String or Array"
         end
+
         args_from_yml
       end
 
-      def has_profile?(profile)
-        cucumber_yml.has_key?(profile)
+      def profile?(profile)
+        cucumber_yml.key?(profile)
       end
 
       def cucumber_yml_defined?
         cucumber_file && File.exist?(cucumber_file)
       end
 
-    private
+      private
 
       # Loads the profile, processing it through ERB and YAML, and returns it as a hash.
       def cucumber_yml
         return @cucumber_yml if @cucumber_yml
-        unless cucumber_yml_defined?
-          raise(ProfilesNotDefinedError,"cucumber.yml was not found.  Current directory is #{Dir.pwd}.  Please refer to cucumber's documentation on defining profiles in cucumber.yml.  You must define a 'default' profile to use the cucumber command without any arguments.\nType 'cucumber --help' for usage.\n")
+
+        ensure_configuration_file_exists
+        process_configuration_file_with_erb
+        load_configuration
+
+        if @cucumber_yml.nil? || !@cucumber_yml.is_a?(Hash)
+          raise(YmlLoadError, 'cucumber.yml was found, but was blank or malformed. ' \
+          "Please refer to cucumber's documentation on correct profile usage.\n")
         end
 
+        @cucumber_yml
+      end
+
+      def ensure_configuration_file_exists
+        return if cucumber_yml_defined?
+
+        raise(ProfilesNotDefinedError, "cucumber.yml was not found.  Current directory is #{Dir.pwd}." \
+                                       "Please refer to cucumber's documentation on defining profiles in cucumber.yml.  You must define" \
+                                       "a 'default' profile to use the cucumber command without any arguments.\nType 'cucumber --help' for usage.\n")
+      end
+
+      def process_configuration_file_with_erb
         require 'erb'
-        require 'yaml'
         begin
-          @cucumber_erb = ERB.new(IO.read(cucumber_file), nil, '%').result(binding)
-        rescue Exception => e
-          raise(YmlLoadError,"cucumber.yml was found, but could not be parsed with ERB.  Please refer to cucumber's documentation on correct profile usage.\n#{$!.inspect}")
+          @cucumber_erb = if RUBY_VERSION >= '2.6'
+                            ERB.new(IO.read(cucumber_file), trim_mode: '%').result(binding)
+                          else
+                            ERB.new(IO.read(cucumber_file), nil, '%').result(binding)
+                          end
+        rescue StandardError
+          raise(YmlLoadError, "cucumber.yml was found, but could not be parsed with ERB.  Please refer to cucumber's documentation on correct profile usage.\n#{$ERROR_INFO.inspect}")
         end
+      end
 
+      def load_configuration
+        require 'yaml'
         begin
-          @cucumber_yml = YAML::load(@cucumber_erb)
-        rescue StandardError => e
-          raise(YmlLoadError,"cucumber.yml was found, but could not be parsed. Please refer to cucumber's documentation on correct profile usage.\n")
-        end
-
-        if @cucumber_yml.nil? || !@cucumber_yml.is_a?(Hash)
-          raise(YmlLoadError,"cucumber.yml was found, but was blank or malformed. Please refer to cucumber's documentation on correct profile usage.\n")
+          @cucumber_yml = YAML.load(@cucumber_erb) # rubocop:disable Security/YAMLLoad
+        rescue StandardError
+          raise(YmlLoadError, "cucumber.yml was found, but could not be parsed. Please refer to cucumber's documentation on correct profile usage.\n")
         end
-
-        return @cucumber_yml
       end
 
       # Locates cucumber.yml file. The file can end in .yml or .yaml,
@@ -85,7 +101,17 @@ Defined profiles in cucumber.yml:
         @cucumber_file ||= Dir.glob('{,.config/,config/}cucumber{.yml,.yaml}').first
       end
 
+      def processed_shellwords(args_from_yml)
+        require 'shellwords'
+
+        return Shellwords.shellwords(args_from_yml) unless Cucumber::WINDOWS
+
+        # Shellwords treats backslash as an escape character so we have to mask it out temporarily
+        placeholder = 'pseudo_unique_backslash_placeholder'
+        sanitized_line = args_from_yml.gsub('\\', placeholder)
+
+        Shellwords.shellwords(sanitized_line).collect { |argument| argument.gsub(placeholder, '\\') }
+      end
     end
   end
 end
-

data/lib/cucumber/cli/rerun_file.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+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/configuration.rb

@@ -1,43 +1,122 @@
+# frozen_string_literal: true
+
+require 'cucumber/constantize'
+require 'cucumber/cli/rerun_file'
+require 'cucumber/events'
+require 'cucumber/core/event_bus'
+require 'cucumber/core/test/result'
+require 'forwardable'
+require 'cucumber'
+
 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
+    # 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 the event occurs
+    # @method on_event
+    def_instance_delegator :event_bus, :on, :on_event
+
+    # @private
+    def notify(message, *args)
+      event_bus.send(message, *args)
     end
 
     def initialize(user_options = {})
-      @options = default_options.merge(user_options)
+      @options = default_options.merge(Hash(user_options))
+    end
+
+    def with_options(new_options)
+      self.class.new(@options.merge(new_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
+      @options[:seed]
     end
 
     def dry_run?
       @options[:dry_run]
     end
 
+    def fail_fast?
+      @options[:fail_fast]
+    end
+
+    def retry_attempts
+      @options[:retry]
+    end
+
     def guess?
       @options[:guess]
     end
 
-    def strict?
+    def strict
       @options[:strict]
     end
 
+    def wip?
+      @options[:wip]
+    end
+
     def expand?
       @options[:expand]
     end
 
+    def source?
+      @options[:source]
+    end
+
+    def duration?
+      @options[:duration]
+    end
+
+    def snippets?
+      @options[:snippets]
+    end
+
+    def skip_profile_information?
+      @options[:skip_profile_information]
+    end
+
+    def profiles
+      @options[:profiles] || []
+    end
+
+    def custom_profiles
+      profiles - [@options[:default_profile]]
+    end
+
     def paths
       @options[:paths]
     end
 
+    def formats
+      @options[:formats]
+    end
+
     def autoload_code_paths
       @options[:autoload_code_paths]
     end
@@ -46,12 +125,165 @@ module Cucumber
       @options[:snippet_type]
     end
 
-  private
+    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
+
+    def tag_limits
+      @options[:tag_limits]
+    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.tr('\\', '/') # 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 are separated from other_files so we can ensure env files
+      # load first.
+      #
+      env_files = support_files.select { |f| f =~ %r{/support/env\..*} }
+      other_files = support_files - env_files
+      env_files.reverse + other_files.reverse
+    end
+
+    def all_files_to_load
+      files = require_dirs.map do |path|
+        path = path.tr('\\', '/') # In case we're on windows. Globs don't work with backslashes.
+        path = path.gsub(/\/$/, '') # Strip trailing slash. # rubocop:disable Style/RegexpLiteral
+        File.directory?(path) ? Dir["#{path}/**/*"] : path
+      end.flatten.uniq
+      remove_excluded_files_from(files)
+      files.select! { |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
+      formats.map do |format, formatter_options, path_or_io|
+        begin
+          factory = formatter_class(format)
+          yield factory,
+                formatter_options,
+                path_or_io
+        rescue Exception => e # rubocop:disable Lint/RescueException
+          raise e, "#{e.message}\nError creating formatter: #{format}", e.backtrace
+        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
+
+    # An array of procs that can generate snippets for undefined steps. These procs may be called if a
+    # formatter wants to display snippets to the user.
+    #
+    # Each proc should take the following arguments:
+    #
+    #  - keyword
+    #  - step text
+    #  - multiline argument
+    #  - snippet type
+    #
+    def snippet_generators
+      @options[:snippet_generators] ||= []
+    end
+
+    def register_snippet_generator(generator)
+      snippet_generators << generator
+      self
+    end
+
+    def event_bus
+      @options[:event_bus]
+    end
+
+    private
 
     def default_options
       {
-        :autoload_code_paths => ['features/support', 'features/step_definitions']
+        autoload_code_paths: ['features/support', 'features/step_definitions'],
+        filters: [],
+        strict: Cucumber::Core::Test::Result::StrictConfiguration.new,
+        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: Cucumber::Events.make_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