rspec-core 2.99.0 → 3.0.0

data/lib/rspec/core/configuration_options.rb

@@ -1,76 +1,104 @@
 require 'erb'
 require 'shellwords'
+require 'set'
 
 module RSpec
   module Core
-    # @private
+    # Responsible for utilizing externally provided configuration options,
+    # whether via the command line, `.rspec`, `~/.rspec`, `.rspec-local`
+    # or a custom options file.
     class ConfigurationOptions
-      attr_reader :options
-
+      # @param args [Array<String>] command line arguments
       def initialize(args)
         @args = args.dup
-        if @args.include?("--default_path")
-          @args[@args.index("--default_path")] = "--default-path"
-        end
-
-        if @args.include?("--line_number")
-          @args[@args.index("--line_number")] = "--line-number"
-        end
+        organize_options
       end
 
+      # Updates the provided {Configuration} instance based on the provided
+      # external configuration options.
+      #
+      # @param config [Configuration] the configuration instance to update
       def configure(config)
-        config.filter_manager = filter_manager
-
-        config.libs = options[:libs] || []
-        config.setup_load_path_and_require(options[:requires] || [])
-
         process_options_into config
+        configure_filter_manager config.filter_manager
         load_formatters_into config
       end
 
-      def parse_options
-        @options ||= extract_filters_from(*all_configs).inject do |merged, pending|
-          merged.merge(pending) { |key, oldval, newval|
-            MERGED_OPTIONS.include?(key) ? oldval + newval : newval
-          }
-        end
-      end
-
-      def drb_argv
-        DrbOptions.new(options, filter_manager).options
+      # @api private
+      # Updates the provided {FilterManager} based on the filter options.
+      # @param filter_manager [FilterManager] instance to update
+      def configure_filter_manager(filter_manager)
+        @filter_manager_inclusions.each { |val| filter_manager.include(val) }
+        @filter_manager_exclusions.each { |val| filter_manager.exclude(val) }
       end
 
-      def filter_manager
-        @filter_manager ||= RSpec::configuration.filter_manager
-      end
+      # @return [Hash] the final merged options, drawn from all external sources
+      attr_reader :options
 
     private
 
-      NON_FORCED_OPTIONS = [
-        :debug, :requires, :profile, :drb, :libs, :files_or_directories_to_run,
-        :line_numbers, :full_description, :full_backtrace, :tty
-      ].to_set
+      def organize_options
+        @filter_manager_inclusions = []
+        @filter_manager_exclusions = []
 
-      MERGED_OPTIONS = [:requires, :libs].to_set
+        @options = (file_options << command_line_options << env_options).each { |opts|
+          @filter_manager_inclusions << opts.delete(:inclusion_filter) if opts.key?(:inclusion_filter)
+          @filter_manager_exclusions << opts.delete(:exclusion_filter) if opts.key?(:exclusion_filter)
+        }.inject(:libs => [], :requires => []) { |hash, opts|
+          hash.merge(opts) { |key, oldval, newval|
+            [:libs, :requires].include?(key) ? oldval + newval : newval
+          }
+        }
+      end
+
+      UNFORCED_OPTIONS = [
+        :requires, :profile, :drb, :libs, :files_or_directories_to_run,
+        :full_description, :full_backtrace, :tty
+      ].to_set
 
-      UNPROCESSABLE_OPTIONS = [:libs, :formatters, :requires].to_set
+      UNPROCESSABLE_OPTIONS = [:formatters].to_set
 
       def force?(key)
-        !NON_FORCED_OPTIONS.include?(key)
+        !UNFORCED_OPTIONS.include?(key)
       end
 
-      def order(keys, *ordered)
-        ordered.reverse.each do |key|
+      def order(keys)
+        OPTIONS_ORDER.reverse.each do |key|
           keys.unshift(key) if keys.delete(key)
         end
         keys
       end
 
+      OPTIONS_ORDER = [
+        # It's important to set this before anything that might issue a
+        # deprecation (or otherwise access the reporter).
+        :deprecation_stream,
+
+        # load paths depend on nothing, but must be set before `requires`
+        # to support load-path-relative requires.
+        :libs,
+
+        # `files_or_directories_to_run` uses `default_path` so it must be
+        # set before it.
+        :default_path,
+
+        # must be set before `requires` to support checking `config.files_to_run`
+        # from within `spec_helper.rb` when a `-rspec_helper` option is used.
+        :files_or_directories_to_run,
+
+        # In general, we want to require the specified files as early as possible.
+        # The `--require` option is specifically intended to allow early requires.
+        # For later requires, they can just put the require in their spec files, but
+        # `--require` provides a unique opportunity for users to instruct RSpec to
+        # load an extension file early for maximum flexibility.
+        :requires
+      ]
+
       def process_options_into(config)
         opts = options.reject { |k, _| UNPROCESSABLE_OPTIONS.include? k }
 
-        order(opts.keys, :default_path, :pattern).each do |key|
-          force?(key) ? config.force(key => opts[key]) : config.send("#{key}=", opts[key])
+        order(opts.keys).each do |key|
+          force?(key) ? config.force(key => opts[key]) : config.__send__("#{key}=", opts[key])
         end
       end
 
@@ -78,27 +106,16 @@ module RSpec
         options[:formatters].each { |pair| config.add_formatter(*pair) } if options[:formatters]
       end
 
-      def extract_filters_from(*configs)
-        configs.compact.each do |config|
-          filter_manager.include config.delete(:inclusion_filter) if config.has_key?(:inclusion_filter)
-          filter_manager.exclude config.delete(:exclusion_filter) if config.has_key?(:exclusion_filter)
-        end
-      end
-
-      def all_configs
-        @all_configs ||= file_options << command_line_options << env_options
-      end
-
       def file_options
         custom_options_file ? [custom_options] : [global_options, project_options, local_options]
       end
 
       def env_options
-        ENV["SPEC_OPTS"] ? Parser.parse!(Shellwords.split(ENV["SPEC_OPTS"])) : {}
+        ENV["SPEC_OPTS"] ? Parser.parse(Shellwords.split(ENV["SPEC_OPTS"])) : {}
       end
 
       def command_line_options
-        @command_line_options ||= Parser.parse!(@args).merge :files_or_directories_to_run => @args
+        @command_line_options ||= Parser.parse(@args).merge :files_or_directories_to_run => @args
       end
 
       def custom_options
@@ -124,7 +141,7 @@ module RSpec
       def args_from_options_file(path)
         return [] unless path && File.exist?(path)
         config_string = options_file_as_erb_string(path)
-        config_string.split(/\n+/).map {|l| Shellwords.shellwords(l) }.flatten
+        FlatMap.flat_map(config_string.split(/\n+/), &:shellsplit)
       end
 
       def options_file_as_erb_string(path)
@@ -147,7 +164,7 @@ module RSpec
         begin
           File.join(File.expand_path("~"), ".rspec")
         rescue ArgumentError
-          warn "Unable to find ~/.rspec because the HOME environment variable is not set"
+          RSpec.warning "Unable to find ~/.rspec because the HOME environment variable is not set"
           nil
         end
       end

data/lib/rspec/core/drb.rb

@@ -0,0 +1,111 @@
+require 'drb/drb'
+
+module RSpec
+  module Core
+    # @private
+    class DRbRunner
+      def initialize(options, configuration=RSpec.configuration)
+        @options       = options
+        @configuration = configuration
+      end
+
+      def drb_port
+        @options.options[:drb_port] || ENV['RSPEC_DRB'] || 8989
+      end
+
+      def run(err, out)
+        begin
+          DRb.start_service("druby://localhost:0")
+        rescue SocketError, Errno::EADDRNOTAVAIL
+          DRb.start_service("druby://:0")
+        end
+        spec_server = DRbObject.new_with_uri("druby://127.0.0.1:#{drb_port}")
+        spec_server.run(drb_argv, err, out)
+      end
+
+      def drb_argv
+        @drb_argv ||= begin
+          @options.configure_filter_manager(@configuration.filter_manager)
+          DRbOptions.new(@options.options, @configuration.filter_manager).options
+        end
+      end
+    end
+
+    # @private
+    class DRbOptions
+      def initialize(submitted_options, filter_manager)
+        @submitted_options = submitted_options
+        @filter_manager = filter_manager
+      end
+
+      def options
+        argv = []
+        argv << "--color"        if @submitted_options[:color]
+        argv << "--profile"      if @submitted_options[:profile_examples]
+        argv << "--backtrace"    if @submitted_options[:full_backtrace]
+        argv << "--tty"          if @submitted_options[:tty]
+        argv << "--fail-fast"    if @submitted_options[:fail_fast]
+        argv << "--options"      << @submitted_options[:custom_options_file] if @submitted_options[:custom_options_file]
+        argv << "--order"        << @submitted_options[:order]               if @submitted_options[:order]
+
+        add_failure_exit_code(argv)
+        add_full_description(argv)
+        add_filter(argv, :inclusion, @filter_manager.inclusions)
+        add_filter(argv, :exclusion, @filter_manager.exclusions)
+        add_formatters(argv)
+        add_libs(argv)
+        add_requires(argv)
+
+        argv + @submitted_options[:files_or_directories_to_run]
+      end
+
+      def add_failure_exit_code(argv)
+        if @submitted_options[:failure_exit_code]
+          argv << "--failure-exit-code" << @submitted_options[:failure_exit_code].to_s
+        end
+      end
+
+      def add_full_description(argv)
+        if @submitted_options[:full_description]
+          # The argument to --example is regexp-escaped before being stuffed
+          # into a regexp when received for the first time (see OptionParser).
+          # Hence, merely grabbing the source of this regexp will retain the
+          # backslashes, so we must remove them.
+          @submitted_options[:full_description].each do |description|
+            argv << "--example" << description.source.delete('\\')
+          end
+        end
+      end
+
+      CONDITIONAL_FILTERS = [:if, :unless]
+
+      def add_filter(argv, name, hash)
+        hash.each_pair do |k, v|
+          next if CONDITIONAL_FILTERS.include?(k)
+          tag = name == :inclusion ? k.to_s : "~#{k}"
+          tag << ":#{v}" if v.is_a?(String)
+          argv << "--tag" << tag
+        end unless hash.empty?
+      end
+
+      def add_formatters(argv)
+        @submitted_options[:formatters].each do |pair|
+          argv << "--format" << pair[0]
+          argv << "--out" << pair[1] if pair[1]
+        end if @submitted_options[:formatters]
+      end
+
+      def add_libs(argv)
+        @submitted_options[:libs].each do |path|
+          argv << "-I" << path
+        end if @submitted_options[:libs]
+      end
+
+      def add_requires(argv)
+        @submitted_options[:requires].each do |path|
+          argv << "--require" << path
+        end if @submitted_options[:requires]
+      end
+    end
+  end
+end

data/lib/rspec/core/dsl.rb

@@ -1,26 +1,94 @@
 module RSpec
   module Core
-    # Adds the `describe` method to the top-level namespace.
+    # DSL defines methods to group examples, most notably `describe`,
+    # and exposes them as class methods of {RSpec}. They can also be
+    # exposed globally (on `main` and instances of `Module`) through
+    # the {Configuration} option `expose_dsl_globally`.
+    #
+    # By default the methods `describe`, `context` and `example_group`
+    # are exposed. These methods define a named context for one or
+    # more examples. The given block is evaluated in the context of
+    # a generated subclass of {RSpec::Core::ExampleGroup}
+    #
+    # ## Examples:
+    #
+    #     RSpec.describe "something" do
+    #       context "when something is a certain way" do
+    #         it "does something" do
+    #           # example code goes here
+    #         end
+    #       end
+    #     end
+    #
+    # @see ExampleGroup
+    # @see ExampleGroup.example_group
     module DSL
-      # Generates a subclass of {ExampleGroup}
-      #
-      # ## Examples:
-      #
-      #     describe "something" do
-      #       it "does something" do
-      #         # example code goes here
-      #       end
-      #     end
-      #
-      # @see ExampleGroup
-      # @see ExampleGroup.describe
-      def describe(*args, &example_group_block)
-        RSpec::Core::ExampleGroup.describe(*args, &example_group_block).register
+      # @private
+      def self.example_group_aliases
+        @example_group_aliases ||= []
       end
+
+      # @private
+      def self.exposed_globally?
+        @exposed_globally ||= false
+      end
+
+      # @private
+      def self.expose_example_group_alias(name)
+        example_group_aliases << name
+
+        (class << RSpec; self; end).__send__(:define_method, name) do |*args, &example_group_block|
+          RSpec.world.register RSpec::Core::ExampleGroup.__send__(name, *args, &example_group_block)
+        end
+
+        expose_example_group_alias_globally(name) if exposed_globally?
+      end
+
+      class << self
+        # @private
+        attr_accessor :top_level
+      end
+
+      # Adds the describe method to Module and the top level binding
+      # @api private
+      def self.expose_globally!
+        return if exposed_globally?
+
+        example_group_aliases.each do |method_name|
+          expose_example_group_alias_globally(method_name)
+        end
+
+        @exposed_globally = true
+      end
+
+      # Removes the describe method from Module and the top level binding
+      # @api private
+      def self.remove_globally!
+        return unless exposed_globally?
+
+        example_group_aliases.each do |method_name|
+          change_global_dsl { undef_method method_name }
+        end
+
+        @exposed_globally = false
+      end
+
+      # @private
+      def self.expose_example_group_alias_globally(method_name)
+        change_global_dsl do
+          define_method(method_name) { |*a, &b| ::RSpec.__send__(method_name, *a, &b) }
+        end
+      end
+
+      # @private
+      def self.change_global_dsl(&changes)
+        (class << top_level; self; end).class_exec(&changes)
+        Module.class_exec(&changes)
+      end
+
     end
   end
 end
 
-extend RSpec::Core::DSL
-Module.send(:include, RSpec::Core::DSL)
-
+# capture main without an eval
+::RSpec::Core::DSL.top_level = self