rspec-support 3.5.0 → 3.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: bd9a51bb43733eb4eddd9869ad64d04870dcea8d
-  data.tar.gz: ce2037102c6fa6d0fba4bce9e5060c8843b98d2a
+SHA256:
+  metadata.gz: 27ddd84c490aacfced87a3d772c93cf8391484030d28f78789ff5e9263811d42
+  data.tar.gz: 515eecb4064c04ac636b6171ad1308532596a13d9b132ac4689893ab76f43bfe
 SHA512:
-  metadata.gz: 133de5b6bf306bcc7aad2eaab37e189bd41c74ae110a26f638f05baa5060f57f4e3df7a870f8db00c02c4b8d51f5d3ffccd9192479b6076338d8e767d1de26a8
-  data.tar.gz: 674f9df382ca7c4a9433197f9cfdf0b845a031b0f1a5c2e7bb6e993d289a1d69d85dcefda2aec4b62c59c6515a6048b80ed5a5c63d8ad04b240720762ed06037
+  metadata.gz: 3755a83a18dcd1326ac122e8250b0abbe0c50af2e630748478c8dfbf0c0f64f65d59725db3ae5370e382f49409b8f7d1639aa09a75c143d4186a8bfeda36a9e3
+  data.tar.gz: 6a41a8e6f905e1c2a37a776a2438d461859aab8434b1cd20c0aa4ca50fb17d898465535710018c8c01c199fde6e179ffef35feb1cd118dc4b71894a0a12d960b

data/Changelog.md

@@ -1,7 +1,90 @@
+### 3.9.0 / 2019-10-07
+
+*NO CHANGES*
+
+Version 3.9.0 was released to allow other RSpec gems to release 3.9.0.
+
+### 3.8.3 / 2019-10-02
+
+Bug Fixes:
+
+* Escape \r when outputting strings inside arrays.
+  (Tomita Masahiro, Jon Rowe, #378)
+* Ensure that optional hash arguments are recognised correctly vs keyword
+  arguments. (Evgeni Dzhelyov, #366)
+
+### 3.8.2 / 2019-06-10
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.8.1...v3.8.2)
+
+Bug Fixes:
+
+* Ensure that an empty hash is recognised as empty keyword arguments when
+  applicable. (Thomas Walpole, #375)
+* Ensure that diffing truthy values produce diffs consistently.
+  (Lucas Nestor, #377)
+
+### 3.8.1 / 2019-03-03
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.8.0...v3.8.1)
+
+Bug Fixes:
+
+* Ensure that inspecting a `SimpleDelegator` based object works regardless of
+  visibilty of the `__getobj__` method. (Jon Rowe, #369)
+
+### 3.8.0 / 2018-08-04
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.7.1...v3.8.0)
+
+Bug Fixes:
+
+* Order hash keys before diffing to improve diff accuracy when using mocked calls.
+  (James Crisp, #334)
+
+### 3.7.1 / 2018-01-29
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.7.0...v3.7.1)
+
+Bug Fixes:
+
+* Fix source extraction logic so that it does not trigger a `SystemStackError`
+  when processing deeply nested example groups. (Craig Bass, #343)
+
+### 3.7.0 / 2017-10-17
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.6.0...v3.7.0)
+
+Enhancements:
+
+* Improve compatibility with `--enable-frozen-string-literal` option
+  on Ruby 2.3+. (Pat Allan, #320)
+* Add `Support.class_of` for extracting class of any object.
+  (Yuji Nakayama, #325)
+
+Bug Fixes:
+
+* Fix recursive const support to not blow up when given buggy classes
+  that raise odd errors from `#to_str`. (Myron Marston, #317)
+
+### 3.6.0 / 2017-05-04
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.6.0.beta2...3.6.0)
+
+Enhancements:
+
+* Import `Source` classes from rspec-core. (Yuji Nakayama, #315)
+
+### 3.6.0.beta2 / 2016-12-12
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.6.0.beta1...v3.6.0.beta2)
+
+No user-facing changes.
+
+### 3.6.0.beta1 / 2016-10-09
+[Full Changelog](http://github.com/rspec/rspec-support/compare/v3.5.0...v3.6.0.beta1)
+
+Bug Fixes:
+
+* Prevent truncated formatted object output from mangling console codes. (#294, Anson Kelly)
+
 ### 3.5.0 / 2016-07-01
 [Full Changelog](http://github.com/rspec/rspec-support/compare/v3.5.0.beta4...v3.5.0)
 
-**No user facing changes since beat4**
+**No user facing changes since beta4**
 
 ### 3.5.0.beta4 / 2016-06-05
 [Full Changelog](http://github.com/rspec/rspec-support/compare/v3.5.0.beta3...v3.5.0.beta4)

data/README.md

@@ -13,7 +13,7 @@ RSpec repos as well. Add the following to your `Gemfile`:
 
 ```ruby
 %w[rspec-core rspec-expectations rspec-mocks rspec-support].each do |lib|
-  gem lib, :git => "git://github.com/rspec/#{lib}.git", :branch => 'master'
+  gem lib, :git => "https://github.com/rspec/#{lib}.git", :branch => 'master'
 end
 ```
 

data/lib/rspec/support.rb

@@ -73,6 +73,16 @@ module RSpec
       end
     end
 
+    # @api private
+    #
+    # Used internally to get a class of a given object, even if it does not respond to #class.
+    def self.class_of(object)
+      object.class
+    rescue NoMethodError
+      singleton_class = class << object; self; end
+      singleton_class.ancestors.find { |ancestor| !ancestor.equal?(singleton_class) }
+    end
+
     # A single thread local variable so we don't excessively pollute that namespace.
     def self.thread_local_data
       Thread.current[:__rspec] ||= {}
@@ -129,7 +139,7 @@ module RSpec
       end
     end
 
-    # The Differ is only needed when a a spec fails with a diffable failure.
+    # The Differ is only needed when a spec fails with a diffable failure.
     # In the more common case of all specs passing or the only failures being
     # non-diffable, we can avoid the extra cost of loading the differ, diff-lcs,
     # pp, etc by avoiding an unnecessary require. Instead, autoload will take

data/lib/rspec/support/differ.rb

@@ -11,7 +11,7 @@ module RSpec
       def diff(actual, expected)
         diff = ""
 
-        if actual && expected
+        unless actual.nil? || expected.nil?
           if all_strings?(actual, expected)
             if any_multiline_strings?(actual, expected)
               diff = diff_as_string(coerce_to_string(actual), coerce_to_string(expected))
@@ -97,7 +97,7 @@ module RSpec
           if Array === entry
             entry.inspect
           else
-            entry.to_s.gsub("\n", "\\n")
+            entry.to_s.gsub("\n", "\\n").gsub("\r", "\\r")
           end
         end
       end
@@ -181,19 +181,19 @@ module RSpec
         when Hash
           hash_to_string(object)
         when Array
-          PP.pp(ObjectFormatter.prepare_for_inspection(object), "")
+          PP.pp(ObjectFormatter.prepare_for_inspection(object), "".dup)
         when String
           object =~ /\n/ ? object : object.inspect
         else
-          PP.pp(object, "")
+          PP.pp(object, "".dup)
         end
       end
 
       def hash_to_string(hash)
         formatted_hash = ObjectFormatter.prepare_for_inspection(hash)
         formatted_hash.keys.sort_by { |k| k.to_s }.map do |key|
-          pp_key   = PP.singleline_pp(key, "")
-          pp_value = PP.singleline_pp(formatted_hash[key], "")
+          pp_key   = PP.singleline_pp(key, "".dup)
+          pp_value = PP.singleline_pp(formatted_hash[key], "".dup)
 
           "#{pp_key} => #{pp_value},"
         end.join("\n")

data/lib/rspec/support/method_signature_verifier.rb

@@ -33,6 +33,18 @@ module RSpec
           optional_max_arg_count <= max_non_kw_args
       end
 
+      def classify_arity(arity=@method.arity)
+        if arity < 0
+          # `~` inverts the one's complement and gives us the
+          # number of required args
+          @min_non_kw_args = ~arity
+          @max_non_kw_args = INFINITY
+        else
+          @min_non_kw_args = arity
+          @max_non_kw_args = arity
+        end
+      end
+
       if RubyFeatures.optional_and_splat_args_supported?
         def description
           @description ||= begin
@@ -65,14 +77,19 @@ module RSpec
           given_kw_args - @allowed_kw_args
         end
 
+        # If the last argument is Hash, Ruby will treat only symbol keys as keyword arguments
+        # the rest will be grouped in another Hash and passed as positional argument.
         def has_kw_args_in?(args)
-          Hash === args.last && could_contain_kw_args?(args)
+          Hash === args.last &&
+            could_contain_kw_args?(args) &&
+            (args.last.empty? || args.last.keys.any? { |x| x.is_a?(Symbol) })
         end
 
         # Without considering what the last arg is, could it
         # contain keyword arguments?
         def could_contain_kw_args?(args)
           return false if args.count <= min_non_kw_args
+
           @allows_any_kw_args || @allowed_kw_args.any?
         end
 
@@ -137,36 +154,58 @@ module RSpec
           false
         end
 
-        def classify_parameters
-          arity = @method.arity
-          if arity < 0
-            # `~` inverts the one's complement and gives us the
-            # number of required args
-            @min_non_kw_args = ~arity
-            @max_non_kw_args = INFINITY
-          else
-            @min_non_kw_args = arity
-            @max_non_kw_args = arity
-          end
-        end
+        alias_method :classify_parameters, :classify_arity
       end
 
       INFINITY = 1 / 0.0
     end
 
-    # Some versions of JRuby have a nasty bug we have to work around :(.
-    # https://github.com/jruby/jruby/issues/2816
-    if RSpec::Support::Ruby.jruby? &&
-       RubyFeatures.optional_and_splat_args_supported? &&
-       Class.new { attr_writer :foo }.instance_method(:foo=).parameters == []
+    if RSpec::Support::Ruby.jruby?
+      # JRuby has only partial support for UnboundMethod#parameters, so we fall back on using #arity
+      # https://github.com/jruby/jruby/issues/2816 and https://github.com/jruby/jruby/issues/2817
+      if RubyFeatures.optional_and_splat_args_supported? &&
+         Java::JavaLang::String.instance_method(:char_at).parameters == []
 
-      class MethodSignature < remove_const(:MethodSignature)
-      private
+        class MethodSignature < remove_const(:MethodSignature)
+        private
 
-        def classify_parameters
-          super
-          return unless @method.parameters == [] && @method.arity == 1
-          @max_non_kw_args = @min_non_kw_args = 1
+          def classify_parameters
+            super
+            if (arity = @method.arity) != 0 && @method.parameters.empty?
+              classify_arity(arity)
+            end
+          end
+        end
+      end
+
+      # JRuby used to always report -1 arity for Java proxy methods.
+      # The workaround essentially makes use of Java's introspection to figure
+      # out matching methods (which could be more than one partly because Java
+      # supports multiple overloads, and partly because JRuby introduces
+      # aliases to make method names look more Rubyesque). If there is only a
+      # single match, we can use that methods arity directly instead of the
+      # default -1 arity.
+      #
+      # This workaround only works for Java proxy methods, and in order to
+      # support regular methods and blocks, we need to be careful about calling
+      # owner and java_class as they might not be available
+      if Java::JavaLang::String.instance_method(:char_at).arity == -1
+        class MethodSignature < remove_const(:MethodSignature)
+        private
+
+          def classify_parameters
+            super
+            return unless @method.arity == -1
+            return unless @method.respond_to?(:owner)
+            return unless @method.owner.respond_to?(:java_class)
+            java_instance_methods = @method.owner.java_class.java_instance_methods
+            compatible_overloads = java_instance_methods.select do |java_method|
+              @method == @method.owner.instance_method(java_method.name)
+            end
+            if compatible_overloads.size == 1
+              classify_arity(compatible_overloads.first.arity)
+            end
+          end
         end
       end
     end
@@ -323,7 +362,14 @@ module RSpec
 
       def split_args(*args)
         kw_args = if @signature.has_kw_args_in?(args)
-                    args.pop.keys
+                    last = args.pop
+                    non_kw_args = last.reject { |k, _| k.is_a?(Symbol) }
+                    if non_kw_args.empty?
+                      last.keys
+                    else
+                      args << non_kw_args
+                      last.select { |k, _| k.is_a?(Symbol) }.keys
+                    end
                   else
                     []
                   end

data/lib/rspec/support/object_formatter.rb

@@ -5,7 +5,7 @@ module RSpec
     # Provide additional output details beyond what `inspect` provides when
     # printing Time, DateTime, or BigDecimal
     # @api private
-    class ObjectFormatter # rubocop:disable Style/ClassLength
+    class ObjectFormatter # rubocop:disable Metrics/ClassLength
       ELLIPSIS = "..."
 
       attr_accessor :max_formatted_output_length
@@ -31,15 +31,15 @@ module RSpec
 
       def format(object)
         if max_formatted_output_length.nil?
-          return prepare_for_inspection(object).inspect
+          prepare_for_inspection(object).inspect
         else
           formatted_object = prepare_for_inspection(object).inspect
           if formatted_object.length < max_formatted_output_length
-            return formatted_object
+            formatted_object
           else
-            beginning = formatted_object[0 .. max_formatted_output_length / 2]
-            ending = formatted_object[-max_formatted_output_length / 2 ..-1]
-            return beginning + ELLIPSIS + ending
+            beginning = truncate_string formatted_object, 0, max_formatted_output_length / 2
+            ending = truncate_string formatted_object, -max_formatted_output_length / 2, -1
+            beginning + ELLIPSIS + ending
           end
         end
       end
@@ -73,7 +73,7 @@ module RSpec
 
       def prepare_hash(input_hash)
         with_entering_structure(input_hash) do
-          input_hash.inject({}) do |output_hash, key_and_value|
+          sort_hash_keys(input_hash).inject({}) do |output_hash, key_and_value|
             key, value = key_and_value.map { |element| prepare_element(element) }
             output_hash[key] = value
             output_hash
@@ -81,6 +81,14 @@ module RSpec
         end
       end
 
+      def sort_hash_keys(input_hash)
+        if input_hash.keys.all? { |k| k.is_a?(String) || k.is_a?(Symbol) }
+          Hash[input_hash.sort_by { |k, _v| k.to_s }]
+        else
+          input_hash
+        end
+      end
+
       def prepare_element(element)
         if recursive_structure?(element)
           case element
@@ -199,8 +207,7 @@ module RSpec
         end
 
         def klass
-          singleton_class = class << object; self; end
-          singleton_class.ancestors.find { |ancestor| !ancestor.equal?(singleton_class) }
+          Support.class_of(object)
         end
 
         # http://stackoverflow.com/a/2818916
@@ -218,7 +225,7 @@ module RSpec
         end
 
         def inspect
-          "#<#{object.class}(#{formatter.format(object.__getobj__)})>"
+          "#<#{object.class}(#{formatter.format(object.send(:__getobj__))})>"
         end
       end
 
@@ -243,7 +250,26 @@ module RSpec
         DescribableMatcherInspector,
         DelegatorInspector,
         InspectableObjectInspector
-      ]
+      ].tap do |classes|
+        # 2.4 has improved BigDecimal formatting so we do not need
+        # to provide our own.
+        # https://github.com/ruby/bigdecimal/pull/42
+        classes.delete(BigDecimalInspector) if RUBY_VERSION >= '2.4'
+      end
+
+    private
+
+      # Returns the substring defined by the start_index and end_index
+      # If the string ends with a partial ANSI code code then that
+      # will be removed as printing partial ANSI
+      # codes to the terminal can lead to corruption
+      def truncate_string(str, start_index, end_index)
+        cut_str = str[start_index..end_index]
+
+        # ANSI color codes are like: \e[33m so anything with \e[ and a
+        # number without a 'm' is an incomplete color code
+        cut_str.sub(/\e\[\d+$/, '')
+      end
     end
   end
 end

data/lib/rspec/support/recursive_const_methods.rb

@@ -64,7 +64,7 @@ module RSpec
         parts.inject([Object, '']) do |(mod, full_name), name|
           yield(full_name, name) if block_given? && !(Module === mod)
           return false unless const_defined_on?(mod, name)
-          [get_const_defined_on(mod, name), [mod, name].join('::')]
+          [get_const_defined_on(mod, name), [mod.name, name].join('::')]
         end
       end
 

data/lib/rspec/support/ruby_features.rb

@@ -28,6 +28,14 @@ module RSpec
         RUBY_PLATFORM == 'java'
       end
 
+      def jruby_version
+        @jruby_version ||= ComparableVersion.new(JRUBY_VERSION)
+      end
+
+      def jruby_9000?
+        jruby? && JRUBY_VERSION >= '9.0.0.0'
+      end
+
       def rbx?
         defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
       end
@@ -48,6 +56,22 @@ module RSpec
     module RubyFeatures
       module_function
 
+      if Ruby.jruby?
+        # On JRuby 1.7 `--1.8` mode, `Process.respond_to?(:fork)` returns true,
+        # but when you try to fork, it raises an error:
+        #   NotImplementedError: fork is not available on this platform
+        #
+        # When we drop support for JRuby 1.7 and/or Ruby 1.8, we can drop
+        # this special case.
+        def fork_supported?
+          false
+        end
+      else
+        def fork_supported?
+          Process.respond_to?(:fork)
+        end
+      end
+
       def optional_and_splat_args_supported?
         Method.method_defined?(:parameters)
       end
@@ -71,9 +95,10 @@ module RSpec
       ripper_requirements.push(false) if Ruby.rbx?
 
       if Ruby.jruby?
-        ripper_requirements.push(ComparableVersion.new(JRUBY_VERSION) >= '1.7.5')
-        # Ripper on JRuby 9.0.0.0.rc1 or later reports wrong line number.
-        ripper_requirements.push(ComparableVersion.new(JRUBY_VERSION) < '9.0.0.0.rc1')
+        ripper_requirements.push(Ruby.jruby_version >= '1.7.5')
+        # Ripper on JRuby 9.0.0.0.rc1 - 9.1.8.0 reports wrong line number
+        # or cannot parse source including `:if`.
+        ripper_requirements.push(!Ruby.jruby_version.between?('9.0.0.0.rc1', '9.1.8.0'))
       end
 
       if ripper_requirements.all?
@@ -100,7 +125,6 @@ module RSpec
         end
       else
         # RBX / JRuby et al support is unknown for keyword arguments
-        # rubocop:disable Lint/Eval
         begin
           eval("o = Object.new; def o.m(a: 1); end;"\
                " raise SyntaxError unless o.method(:m).parameters.include?([:key, :a])")
@@ -138,7 +162,10 @@ module RSpec
             false
           end
         end
-        # rubocop:enable Lint/Eval
+      end
+
+      def module_refinement_supported?
+        Module.method_defined?(:refine) || Module.private_method_defined?(:refine)
       end
 
       def module_prepends_supported?

data/lib/rspec/support/source.rb

@@ -0,0 +1,75 @@
+RSpec::Support.require_rspec_support 'encoded_string'
+RSpec::Support.require_rspec_support 'ruby_features'
+
+module RSpec
+  module Support
+    # @private
+    # Represents a Ruby source file and provides access to AST and tokens.
+    class Source
+      attr_reader :source, :path
+
+      def self.from_file(path)
+        source = File.read(path)
+        new(source, path)
+      end
+
+      if String.method_defined?(:encoding)
+        def initialize(source_string, path=nil)
+          @source = RSpec::Support::EncodedString.new(source_string, Encoding.default_external)
+          @path = path ? File.expand_path(path) : '(string)'
+        end
+      else # for 1.8.7
+        # :nocov:
+        def initialize(source_string, path=nil)
+          @source = RSpec::Support::EncodedString.new(source_string)
+          @path = path ? File.expand_path(path) : '(string)'
+        end
+        # :nocov:
+      end
+
+      def lines
+        @lines ||= source.split("\n")
+      end
+
+      def inspect
+        "#<#{self.class} #{path}>"
+      end
+
+      if RSpec::Support::RubyFeatures.ripper_supported?
+        RSpec::Support.require_rspec_support 'source/node'
+        RSpec::Support.require_rspec_support 'source/token'
+
+        def ast
+          @ast ||= begin
+            require 'ripper'
+            sexp = Ripper.sexp(source)
+            raise SyntaxError unless sexp
+            Node.new(sexp)
+          end
+        end
+
+        def tokens
+          @tokens ||= begin
+            require 'ripper'
+            tokens = Ripper.lex(source)
+            Token.tokens_from_ripper_tokens(tokens)
+          end
+        end
+
+        def nodes_by_line_number
+          @nodes_by_line_number ||= begin
+            nodes_by_line_number = ast.select(&:location).group_by { |node| node.location.line }
+            Hash.new { |hash, key| hash[key] = [] }.merge(nodes_by_line_number)
+          end
+        end
+
+        def tokens_by_line_number
+          @tokens_by_line_number ||= begin
+            nodes_by_line_number = tokens.group_by { |token| token.location.line }
+            Hash.new { |hash, key| hash[key] = [] }.merge(nodes_by_line_number)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/support/source/location.rb

@@ -0,0 +1,21 @@
+module RSpec
+  module Support
+    class Source
+      # @private
+      # Represents a source location of node or token.
+      Location = Struct.new(:line, :column) do
+        include Comparable
+
+        def self.location?(array)
+          array.is_a?(Array) && array.size == 2 && array.all? { |e| e.is_a?(Integer) }
+        end
+
+        def <=>(other)
+          line_comparison = (line <=> other.line)
+          return line_comparison unless line_comparison == 0
+          column <=> other.column
+        end
+      end
+    end
+  end
+end

data/lib/rspec/support/source/node.rb

@@ -0,0 +1,110 @@
+RSpec::Support.require_rspec_support 'source/location'
+
+module RSpec
+  module Support
+    class Source
+      # @private
+      # A wrapper for Ripper AST node which is generated with `Ripper.sexp`.
+      class Node
+        include Enumerable
+
+        attr_reader :sexp, :parent
+
+        def self.sexp?(array)
+          array.is_a?(Array) && array.first.is_a?(Symbol)
+        end
+
+        def initialize(ripper_sexp, parent=nil)
+          @sexp = ripper_sexp.freeze
+          @parent = parent
+        end
+
+        def type
+          sexp[0]
+        end
+
+        def args
+          @args ||= raw_args.map do |raw_arg|
+            if Node.sexp?(raw_arg)
+              Node.new(raw_arg, self)
+            elsif Location.location?(raw_arg)
+              Location.new(*raw_arg)
+            elsif raw_arg.is_a?(Array)
+              ExpressionSequenceNode.new(raw_arg, self)
+            else
+              raw_arg
+            end
+          end.freeze
+        end
+
+        def children
+          @children ||= args.select { |arg| arg.is_a?(Node) }.freeze
+        end
+
+        def location
+          @location ||= args.find { |arg| arg.is_a?(Location) }
+        end
+
+        # We use a loop here (instead of recursion) to prevent SystemStackError
+        def each
+          return to_enum(__method__) unless block_given?
+
+          node_queue = []
+          node_queue << self
+
+          while (current_node = node_queue.shift)
+            yield current_node
+            node_queue.concat(current_node.children)
+          end
+        end
+
+        def each_ancestor
+          return to_enum(__method__) unless block_given?
+
+          current_node = self
+
+          while (current_node = current_node.parent)
+            yield current_node
+          end
+        end
+
+        def inspect
+          "#<#{self.class} #{type}>"
+        end
+
+      private
+
+        def raw_args
+          sexp[1..-1] || []
+        end
+      end
+
+      # @private
+      # Basically `Ripper.sexp` generates arrays whose first element is a symbol (type of sexp),
+      # but it exceptionally generates typeless arrays for expression sequence:
+      #
+      # Ripper.sexp('foo; bar')
+      # => [
+      #      :program,
+      #      [ # Typeless array
+      #        [:vcall, [:@ident, "foo", [1, 0]]],
+      #        [:vcall, [:@ident, "bar", [1, 5]]]
+      #      ]
+      #    ]
+      #
+      # We wrap typeless arrays in this pseudo type node
+      # so that it can be handled in the same way as other type node.
+      class ExpressionSequenceNode < Node
+        def type
+          :_expression_sequence
+        end
+
+      private
+
+        def raw_args
+          sexp
+        end
+      end
+    end
+  end
+end

data/lib/rspec/support/source/token.rb

@@ -0,0 +1,87 @@
+RSpec::Support.require_rspec_support 'source/location'
+
+module RSpec
+  module Support
+    class Source
+      # @private
+      # A wrapper for Ripper token which is generated with `Ripper.lex`.
+      class Token
+        CLOSING_TYPES_BY_OPENING_TYPE = {
+          :on_lbracket    => :on_rbracket,
+          :on_lparen      => :on_rparen,
+          :on_lbrace      => :on_rbrace,
+          :on_heredoc_beg => :on_heredoc_end
+        }.freeze
+
+        CLOSING_KEYWORDS_BY_OPENING_KEYWORD = {
+          'def' => 'end',
+          'do'  => 'end',
+        }.freeze
+
+        attr_reader :token
+
+        def self.tokens_from_ripper_tokens(ripper_tokens)
+          ripper_tokens.map { |ripper_token| new(ripper_token) }.freeze
+        end
+
+        def initialize(ripper_token)
+          @token = ripper_token.freeze
+        end
+
+        def location
+          @location ||= Location.new(*token[0])
+        end
+
+        def type
+          token[1]
+        end
+
+        def string
+          token[2]
+        end
+
+        def ==(other)
+          token == other.token
+        end
+
+        alias_method :eql?, :==
+
+        def inspect
+          "#<#{self.class} #{type} #{string.inspect}>"
+        end
+
+        def keyword?
+          type == :on_kw
+        end
+
+        def opening?
+          opening_delimiter? || opening_keyword?
+        end
+
+        def closed_by?(other)
+          closed_by_delimiter?(other) || closed_by_keyword?(other)
+        end
+
+      private
+
+        def opening_delimiter?
+          CLOSING_TYPES_BY_OPENING_TYPE.key?(type)
+        end
+
+        def opening_keyword?
+          return false unless keyword?
+          CLOSING_KEYWORDS_BY_OPENING_KEYWORD.key?(string)
+        end
+
+        def closed_by_delimiter?(other)
+          other.type == CLOSING_TYPES_BY_OPENING_TYPE[type]
+        end
+
+        def closed_by_keyword?(other)
+          return false unless other.keyword?
+          other.string == CLOSING_KEYWORDS_BY_OPENING_KEYWORD[string]
+        end
+      end
+    end
+  end
+end

data/lib/rspec/support/spec/in_sub_process.rb

@@ -3,40 +3,57 @@ module RSpec
     module InSubProcess
       if Process.respond_to?(:fork) && !(Ruby.jruby? && RUBY_VERSION == '1.8.7')
 
+        UnmarshableObject = Struct.new(:error)
+
         # Useful as a way to isolate a global change to a subprocess.
 
         # rubocop:disable MethodLength
         def in_sub_process(prevent_warnings=true)
-          readme, writeme = IO.pipe
+          exception_reader, exception_writer = IO.pipe
+          result_reader, result_writer = IO.pipe
 
           pid = Process.fork do
-            exception = nil
             warning_preventer = $stderr = RSpec::Support::StdErrSplitter.new($stderr)
 
             begin
-              yield
+              result = yield
               warning_preventer.verify_no_warnings! if prevent_warnings
-            rescue Support::AllExceptionsExceptOnesWeMustNotRescue => e
-              exception = e
+              # rubocop:disable Lint/HandleExceptions
+            rescue Support::AllExceptionsExceptOnesWeMustNotRescue => exception
+              # rubocop:enable Lint/HandleExceptions
             end
 
-            writeme.write Marshal.dump(exception)
+            exception_writer.write marshal_dump_with_unmarshable_object_handling(exception)
+            exception_reader.close
+            exception_writer.close
+
+            result_writer.write marshal_dump_with_unmarshable_object_handling(result)
+            result_reader.close
+            result_writer.close
 
-            readme.close
-            writeme.close
             exit! # prevent at_exit hooks from running (e.g. minitest)
           end
 
-          writeme.close
+          exception_writer.close
+          result_writer.close
           Process.waitpid(pid)
 
-          exception = Marshal.load(readme.read)
-          readme.close
-
+          exception = Marshal.load(exception_reader.read)
+          exception_reader.close
           raise exception if exception
+
+          result = Marshal.load(result_reader.read)
+          result_reader.close
+          result
         end
         # rubocop:enable MethodLength
         alias :in_sub_process_if_possible :in_sub_process
+
+        def marshal_dump_with_unmarshable_object_handling(object)
+          Marshal.dump(object)
+        rescue TypeError => error
+          Marshal.dump(UnmarshableObject.new(error))
+        end
       else
         def in_sub_process(*)
           skip "This spec requires forking to work properly, " \

data/lib/rspec/support/spec/shell_out.rb

@@ -59,8 +59,15 @@ module RSpec
           l =~ %r{bundler/source/rubygems} ||
           # Ignore bundler + rubygems warning.
           l =~ %r{site_ruby/\d\.\d\.\d/rubygems} ||
+          l =~ %r{jruby-\d\.\d\.\d\.\d/lib/ruby/stdlib/rubygems} ||
           # This is required for windows for some reason
-          l =~ %r{lib/bundler/rubygems}
+          l =~ %r{lib/bundler/rubygems} ||
+          # This is a JRuby file that generates warnings on 9.0.3.0
+          l =~ %r{lib/ruby/stdlib/jar} ||
+          # This is a JRuby file that generates warnings on 9.1.7.0
+          l =~ %r{org/jruby/RubyKernel\.java} ||
+          # Remove blank lines
+          l == "" || l.nil?
         end.join("\n")
       end
 

data/lib/rspec/support/version.rb

@@ -1,7 +1,7 @@
 module RSpec
   module Support
     module Version
-      STRING = '3.5.0'
+      STRING = '3.9.0'
     end
   end
 end

data/lib/rspec/support/warnings.rb

@@ -28,8 +28,8 @@ module RSpec
       # Used internally to print longer warnings
       def warn_with(message, options={})
         call_site = options.fetch(:call_site) { CallerFilter.first_non_rspec_line }
-        message << " Use #{options[:replacement]} instead." if options[:replacement]
-        message << " Called from #{call_site}." if call_site
+        message += " Use #{options[:replacement]} instead." if options[:replacement]
+        message += " Called from #{call_site}." if call_site
         Support.warning_notifier.call message
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rspec-support
 version: !ruby/object:Gem::Version
-  version: 3.5.0
+  version: 3.9.0
 platform: ruby
 authors:
 - David Chelimsky
@@ -48,22 +48,8 @@ cert_chain:
   ZsVDj6a7lH3cNqtWXZxrb2wO38qV5AkYj8SQK7Hj3/Yui9myUX3crr+PdetazSqQ
   F3MdtaDehhjC
   -----END CERTIFICATE-----
-date: 2016-07-01 00:00:00.000000000 Z
+date: 2019-10-07 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.3'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -116,6 +102,10 @@ files:
 - lib/rspec/support/recursive_const_methods.rb
 - lib/rspec/support/reentrant_mutex.rb
 - lib/rspec/support/ruby_features.rb
+- lib/rspec/support/source.rb
+- lib/rspec/support/source/location.rb
+- lib/rspec/support/source/node.rb
+- lib/rspec/support/source/token.rb
 - lib/rspec/support/spec.rb
 - lib/rspec/support/spec/deprecation_helpers.rb
 - lib/rspec/support/spec/formatting_support.rb
@@ -131,7 +121,12 @@ files:
 homepage: https://github.com/rspec/rspec-support
 licenses:
 - MIT
-metadata: {}
+metadata:
+  bug_tracker_uri: https://github.com/rspec/rspec-support/issues
+  changelog_uri: https://github.com/rspec/rspec-support/blob/v3.9.0/Changelog.md
+  documentation_uri: https://rspec.info/documentation/
+  mailing_list_uri: https://groups.google.com/forum/#!forum/rspec
+  source_code_uri: https://github.com/rspec/rspec-support
 post_install_message: 
 rdoc_options:
 - "--charset=UTF-8"
@@ -148,9 +143,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
-summary: rspec-support-3.5.0
+summary: rspec-support-3.9.0
 test_files: []