rspec-support 3.0.4 → 3.12.1

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,94 @@
+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 equals_operator?
+          type == :on_op && string == '='
+        end
+
+        def opening?
+          opening_delimiter? || opening_keyword?
+        end
+
+        def closed_by?(other)
+          delimiter_closed_by?(other) || keyword_closed_by?(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 delimiter_closed_by?(other)
+          other.type == CLOSING_TYPES_BY_OPENING_TYPE[type]
+        end
+
+        def keyword_closed_by?(other)
+          return false unless keyword?
+          return true if other.string == CLOSING_KEYWORDS_BY_OPENING_KEYWORD[string]
+
+          # Ruby 3's `end`-less method definition: `def method_name = body`
+          string == 'def' && other.equals_operator? && location.line == other.location.line
+        end
+      end
+    end
+  end
+end

data/lib/rspec/support/source.rb

@@ -0,0 +1,85 @@
+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
+
+      # This class protects us against having File read and expand_path
+      # stubbed out within tests.
+      class File
+        class << self
+          [:read, :expand_path].each do |method_name|
+            define_method(method_name, &::File.method(method_name))
+          end
+        end
+      end
+
+      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/spec/deprecation_helpers.rb

@@ -1,36 +1,22 @@
 module RSpecHelpers
-
-  def expect_no_deprecation
-    expect(RSpec.configuration.reporter).not_to receive(:deprecation)
-  end
-
   def expect_deprecation_with_call_site(file, line, snippet=//)
-    expect(RSpec.configuration.reporter).to receive(:deprecation) do |options|
-      expect(options[:call_site]).to include([file, line].join(':'))
-      expect(options[:deprecated]).to match(snippet)
-    end
+    expect(RSpec.configuration.reporter).to receive(:deprecation).
+      with(include(:deprecated => match(snippet), :call_site => include([file, line].join(':'))))
   end
 
   def expect_deprecation_without_call_site(snippet=//)
-    expect(RSpec.configuration.reporter).to receive(:deprecation) do |options|
-      expect(options[:call_site]).to eq nil
-      expect(options[:deprecated]).to match(snippet)
-    end
+    expect(RSpec.configuration.reporter).to receive(:deprecation).
+      with(include(:deprecated => match(snippet), :call_site => eq(nil)))
   end
 
   def expect_warn_deprecation_with_call_site(file, line, snippet=//)
-    expect(RSpec.configuration.reporter).to receive(:deprecation) do |options|
-      message = options[:message]
-      expect(message).to match(snippet)
-      expect(message).to include([file, line].join(':'))
-    end
+    expect(RSpec.configuration.reporter).to receive(:deprecation).
+      with(include(:message => match(snippet), :call_site => include([file, line].join(':'))))
   end
 
   def expect_warn_deprecation(snippet=//)
-    expect(RSpec.configuration.reporter).to receive(:deprecation) do |options|
-      message = options[:message]
-      expect(message).to match(snippet)
-    end
+    expect(RSpec.configuration.reporter).to receive(:deprecation).
+      with(include(:message => match(snippet)))
   end
 
   def allow_deprecation
@@ -40,19 +26,20 @@ module RSpecHelpers
   def expect_no_deprecations
     expect(RSpec.configuration.reporter).not_to receive(:deprecation)
   end
+  alias expect_no_deprecation expect_no_deprecations
+
+  def expect_warning_without_call_site(expected=//)
+    expect(::Kernel).to receive(:warn).
+      with(match(expected).and(satisfy { |message| !(/Called from/ =~ message) }))
+  end
 
-  def expect_warning_without_call_site(expected = //)
-    expect(::Kernel).to receive(:warn) do |message|
-      expect(message).to match expected
-      expect(message).to_not match(/Called from/)
-    end
+  def expect_warning_with_call_site(file, line, expected=//)
+    expect(::Kernel).to receive(:warn).
+      with(match(expected).and(match(/Called from #{file}:#{line}/)))
   end
 
-  def expect_warning_with_call_site(file, line, expected = //)
-    expect(::Kernel).to receive(:warn) do |message|
-      expect(message).to match expected
-      expect(message).to match(/Called from #{file}:#{line}/)
-    end
+  def expect_no_warnings
+    expect(::Kernel).not_to receive(:warn)
   end
 
   def allow_warning

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

@@ -0,0 +1,31 @@
+require 'diff/lcs'
+
+module RSpec
+  module Support
+    module Spec
+      module DiffHelpers
+        # In the updated version of diff-lcs several diff headers change format slightly
+        # compensate for this and change minimum version in RSpec 4
+        if ::Diff::LCS::VERSION.to_f < 1.4
+          def one_line_header(line_number=2)
+            "-1,#{line_number} +1,#{line_number}"
+          end
+        else
+          def one_line_header(_=2)
+            "-1 +1"
+          end
+        end
+
+        if Diff::LCS::VERSION.to_f < 1.4 || Diff::LCS::VERSION >= "1.4.4"
+          def removing_two_line_header
+            "-1,3 +1"
+          end
+        else
+          def removing_two_line_header
+            "-1,3 +1,5"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,39 +1,66 @@
 module RSpec
   module Support
     module InSubProcess
-      if Process.respond_to?(:fork) && !(RUBY_PLATFORM == 'java' && RUBY_VERSION == '1.8.7')
+      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.
-        def in_sub_process
-          readme, writeme = IO.pipe
+
+        def in_sub_process(prevent_warnings=true) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+          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
-            rescue Exception => e
-              exception = e
+              result = yield
+              warning_preventer.verify_no_warnings! if prevent_warnings
+              # 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
+        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, " +
+        def in_sub_process(*)
+          skip "This spec requires forking to work properly, " \
                "and your platform does not support forking"
         end
+
+        def in_sub_process_if_possible(*)
+          yield
+        end
       end
     end
   end

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

@@ -0,0 +1,150 @@
+require 'rspec/support/spec/shell_out'
+
+module RSpec
+  module Support
+    module WhitespaceChecks
+      # This malformed whitespace detection logic has been borrowed from bundler:
+      # https://github.com/bundler/bundler/blob/v1.8.0/spec/quality_spec.rb
+      def check_for_tab_characters(filename)
+        failing_lines = []
+        File.readlines(filename).each_with_index do |line, number|
+          failing_lines << number + 1 if line =~ /\t/
+        end
+
+        return if failing_lines.empty?
+        "#{filename} has tab characters on lines #{failing_lines.join(', ')}"
+      end
+
+      def check_for_extra_spaces(filename)
+        failing_lines = []
+        File.readlines(filename).each_with_index do |line, number|
+          next if line =~ /^\s+#.*\s+\n$/
+          failing_lines << number + 1 if line =~ /\s+\n$/
+        end
+
+        return if failing_lines.empty?
+        "#{filename} has spaces on the EOL on lines #{failing_lines.join(', ')}"
+      end
+    end
+  end
+end
+
+RSpec.shared_examples_for "library wide checks" do |lib, options|
+  consider_a_test_env_file = options.fetch(:consider_a_test_env_file, /MATCHES NOTHING/)
+  allowed_loaded_feature_regexps = options.fetch(:allowed_loaded_feature_regexps, [])
+  preamble_for_lib = options[:preamble_for_lib]
+  preamble_for_spec = "require 'rspec/core'; require 'spec_helper'"
+  skip_spec_files = options.fetch(:skip_spec_files, /MATCHES NOTHING/)
+
+  include RSpec::Support::ShellOut
+  include RSpec::Support::WhitespaceChecks
+
+  define_method :files_to_require_for do |sub_dir|
+    slash         = File::SEPARATOR
+    lib_path_re   = /#{slash + lib}[^#{slash}]*#{slash}lib/
+    load_path     = $LOAD_PATH.grep(lib_path_re).first
+    directory     = load_path.sub(/lib$/, sub_dir)
+    files         = Dir["#{directory}/**/*.rb"]
+    extract_regex = /#{Regexp.escape(directory) + File::SEPARATOR}(.+)\.rb$/
+
+    # We sort to ensure the files are loaded in a consistent order, regardless
+    # of OS. Otherwise, it could load in a different order on Travis than
+    # locally, and potentially trigger a "circular require considered harmful"
+    # warning or similar.
+    files.sort.map { |file| file[extract_regex, 1] }
+  end
+
+  def command_from(code_lines)
+    code_lines.join("\n")
+  end
+
+  def load_all_files(files, preamble, postamble=nil)
+    requires = files.map { |f| "require '#{f}'" }
+    command  = command_from(Array(preamble) + requires + Array(postamble))
+
+    stdout, stderr, status = with_env 'NO_COVERAGE' => '1' do
+      options = %w[ -w ]
+      options << "--disable=gem" if RUBY_VERSION.to_f >= 1.9 && RSpec::Support::Ruby.mri?
+      run_ruby_with_current_load_path(command, *options)
+    end
+
+    [stdout, strip_known_warnings(stderr), status.exitstatus]
+  end
+
+  define_method :load_all_lib_files do
+    files = all_lib_files - lib_test_env_files
+    preamble  = ['orig_loaded_features = $".dup', preamble_for_lib]
+    postamble = ['puts(($" - orig_loaded_features).join("\n"))']
+
+    @loaded_feature_lines, stderr, exitstatus = load_all_files(files, preamble, postamble)
+    ["", stderr, exitstatus]
+  end
+
+  define_method :load_all_spec_files do
+    files = files_to_require_for("spec") + lib_test_env_files
+    files = files.reject { |f| f =~ skip_spec_files }
+    load_all_files(files, preamble_for_spec)
+  end
+
+  attr_reader :all_lib_files, :lib_test_env_files,
+              :lib_file_results, :spec_file_results
+
+  before(:context) do
+    @all_lib_files           = files_to_require_for("lib")
+    @lib_test_env_files      = all_lib_files.grep(consider_a_test_env_file)
+
+    @lib_file_results, @spec_file_results = [
+      # Load them in parallel so it's faster...
+      Thread.new { load_all_lib_files  },
+      Thread.new { load_all_spec_files }
+    ].map(&:join).map(&:value)
+  end
+
+  def have_successful_no_warnings_output
+    eq ["", "", 0]
+  end
+
+  it "issues no warnings when loaded", :slow do
+    expect(lib_file_results).to have_successful_no_warnings_output
+  end
+
+  it "issues no warnings when the spec files are loaded", :slow do
+    expect(spec_file_results).to have_successful_no_warnings_output
+  end
+
+  it 'only loads a known set of stdlibs so gem authors are forced ' \
+     'to load libs they use to have passing specs', :slow do
+    loaded_features = @loaded_feature_lines.split("\n")
+    if RUBY_VERSION == '1.8.7'
+      # On 1.8.7, $" returns the relative require path if that was used
+      # to require the file. LIB_REGEX will not match the relative version
+      # since it has a `/lib` prefix. Here we deal with this by expanding
+      # relative files relative to the $LOAD_PATH dir (lib).
+      Dir.chdir("lib") { loaded_features.map! { |f| File.expand_path(f) } }
+    end
+
+    loaded_features.reject! { |feature| RSpec::CallerFilter::LIB_REGEX =~ feature }
+    loaded_features.reject! { |feature| allowed_loaded_feature_regexps.any? { |r| r =~ feature } }
+
+    expect(loaded_features).to eq([])
+  end
+
+  RSpec::Matchers.define :be_well_formed do
+    match do |actual|
+      actual.empty?
+    end
+
+    failure_message do |actual|
+      actual.join("\n")
+    end
+  end
+
+  it "has no malformed whitespace", :slow do
+    error_messages = []
+    `git ls-files -z`.split("\x0").each do |filename|
+      error_messages << check_for_tab_characters(filename)
+      error_messages << check_for_extra_spaces(filename)
+    end
+    expect(error_messages.compact).to be_well_formed
+  end
+end