rbhint 0.8.5.rc1

data/lib/rubocop/rspec/cop_helper.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'tempfile'
+
+# This module provides methods that make it easier to test Cops.
+module CopHelper
+  extend RSpec::SharedContext
+
+  let(:ruby_version) { 2.4 }
+  let(:rails_version) { false }
+
+  def inspect_source_file(source)
+    Tempfile.open('tmp') { |f| inspect_source(source, f) }
+  end
+
+  def inspect_source(source, file = nil)
+    RuboCop::Formatter::DisabledConfigFormatter.config_to_allow_offenses = {}
+    RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
+    processed_source = parse_source(source, file)
+    raise 'Error parsing example code' unless processed_source.valid_syntax?
+
+    _investigate(cop, processed_source)
+  end
+
+  def parse_source(source, file = nil)
+    if file&.respond_to?(:write)
+      file.write(source)
+      file.rewind
+      file = file.path
+    end
+
+    RuboCop::ProcessedSource.new(source, ruby_version, file)
+  end
+
+  def autocorrect_source_file(source)
+    Tempfile.open('tmp') { |f| autocorrect_source(source, f) }
+  end
+
+  def autocorrect_source(source, file = nil)
+    RuboCop::Formatter::DisabledConfigFormatter.config_to_allow_offenses = {}
+    RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
+    cop.instance_variable_get(:@options)[:auto_correct] = true
+    processed_source = parse_source(source, file)
+    _investigate(cop, processed_source)
+
+    corrector =
+      RuboCop::Cop::Corrector.new(processed_source.buffer, cop.corrections)
+    corrector.rewrite
+  end
+
+  def _investigate(cop, processed_source)
+    team = RuboCop::Cop::Team.new([cop], nil, raise_error: true)
+    team.inspect_file(processed_source)
+  end
+end
+
+module RuboCop
+  module Cop
+    # Monkey-patch Cop for tests to provide easy access to messages and
+    # highlights.
+    class Cop
+      def messages
+        offenses.sort.map(&:message)
+      end
+
+      def highlights
+        offenses.sort.map { |o| o.location.source }
+      end
+    end
+  end
+end

data/lib/rubocop/rspec/expect_offense.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module RSpec
+    # Mixin for `expect_offense` and `expect_no_offenses`
+    #
+    # This mixin makes it easier to specify strict offense expectations
+    # in a declarative and visual fashion. Just type out the code that
+    # should generate a offense, annotate code by writing '^'s
+    # underneath each character that should be highlighted, and follow
+    # the carets with a string (separated by a space) that is the
+    # message of the offense. You can include multiple offenses in
+    # one code snippet.
+    #
+    # @example Usage
+    #
+    #     expect_offense(<<~RUBY)
+    #       a do
+    #         b
+    #       end.c
+    #       ^^^^^ Avoid chaining a method call on a do...end block.
+    #     RUBY
+    #
+    # @example Equivalent assertion without `expect_offense`
+    #
+    #     inspect_source(<<~RUBY)
+    #       a do
+    #         b
+    #       end.c
+    #     RUBY
+    #
+    #     expect(cop.offenses.size).to be(1)
+    #
+    #     offense = cop.offenses.first
+    #     expect(offense.line).to be(3)
+    #     expect(offense.column_range).to be(0...5)
+    #     expect(offense.message).to eql(
+    #       'Avoid chaining a method call on a do...end block.'
+    #     )
+    #
+    # Auto-correction can be tested using `expect_correction` after
+    # `expect_offense`.
+    #
+    # @example `expect_offense` and `expect_correction`
+    #
+    #   expect_offense(<<~RUBY)
+    #     x % 2 == 0
+    #     ^^^^^^^^^^ Replace with `Integer#even?`.
+    #   RUBY
+    #
+    #   expect_correction(<<~RUBY)
+    #     x.even?
+    #   RUBY
+    #
+    # If you do not want to specify an offense then use the
+    # companion method `expect_no_offenses`. This method is a much
+    # simpler assertion since it just inspects the source and checks
+    # that there were no offenses. The `expect_offense` method has
+    # to do more work by parsing out lines that contain carets.
+    #
+    # If the code produces an offense that could not be auto-corrected, you can
+    # use `expect_no_corrections` after `expect_offense`.
+    #
+    # @example `expect_offense` and `expect_no_corrections`
+    #
+    #   expect_offense(<<~RUBY)
+    #     a do
+    #       b
+    #     end.c
+    #     ^^^^^ Avoid chaining a method call on a do...end block.
+    #   RUBY
+    #
+    #   expect_no_corrections
+    #
+    # If your code has variables of different lengths, you can use `%{foo}`
+    # and `^{foo}` to format your template:
+    #
+    #   %w[raise fail].each do |keyword|
+    #     expect_offense(<<~RUBY, keyword: keyword)
+    #       %{keyword}(RuntimeError, msg)
+    #       ^{keyword}^^^^^^^^^^^^^^^^^^^ Redundant `RuntimeError` argument can be removed.
+    #     RUBY
+    module ExpectOffense
+      def format_offense(source, **replacements)
+        replacements.each do |keyword, value|
+          source = source.gsub("%{#{keyword}}", value)
+                         .gsub("^{#{keyword}}", '^' * value.size)
+        end
+        source
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+      def expect_offense(source, file = nil, **replacements)
+        source = format_offense(source, **replacements)
+        RuboCop::Formatter::DisabledConfigFormatter
+          .config_to_allow_offenses = {}
+        RuboCop::Formatter::DisabledConfigFormatter.detected_styles = {}
+        cop.instance_variable_get(:@options)[:auto_correct] = true
+
+        expected_annotations = AnnotatedSource.parse(source)
+
+        if expected_annotations.plain_source == source
+          raise 'Use `expect_no_offenses` to assert that no offenses are found'
+        end
+
+        @processed_source = parse_source(expected_annotations.plain_source,
+                                         file)
+
+        raise 'Error parsing example code' unless @processed_source.valid_syntax?
+
+        _investigate(cop, @processed_source)
+        actual_annotations =
+          expected_annotations.with_offense_annotations(cop.offenses)
+
+        expect(actual_annotations.to_s).to eq(expected_annotations.to_s)
+      end
+
+      def expect_correction(correction, loop: true)
+        raise '`expect_correction` must follow `expect_offense`' unless @processed_source
+
+        iteration = 0
+        new_source = loop do
+          iteration += 1
+
+          corrector =
+            RuboCop::Cop::Corrector.new(@processed_source.buffer, cop.corrections)
+          corrected_source = corrector.rewrite
+
+          break corrected_source unless loop
+          break corrected_source if cop.corrections.empty?
+          break corrected_source if corrected_source == @processed_source.buffer.source
+
+          if iteration > RuboCop::Runner::MAX_ITERATIONS
+            raise RuboCop::Runner::InfiniteCorrectionLoop.new(@processed_source.path, [])
+          end
+
+          # Prepare for next loop
+          cop.instance_variable_set(:@corrections, [])
+          # Cache invalidation. This is bad!
+          cop.instance_variable_set(:@token_table, nil)
+          @processed_source = parse_source(corrected_source,
+                                           @processed_source.path)
+          _investigate(cop, @processed_source)
+        end
+
+        expect(new_source).to eq(correction)
+      end
+      # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
+
+      def expect_no_corrections
+        raise '`expect_no_corrections` must follow `expect_offense`' unless @processed_source
+
+        return if cop.corrections.empty?
+
+        # In order to print a nice diff, e.g. what source got corrected to,
+        # we need to run the actual corrections
+
+        corrector =
+          RuboCop::Cop::Corrector.new(@processed_source.buffer, cop.corrections)
+        new_source = corrector.rewrite
+
+        expect(new_source).to eq(@processed_source.buffer.source)
+      end
+
+      def expect_no_offenses(source, file = nil)
+        inspect_source(source, file)
+
+        expected_annotations = AnnotatedSource.parse(source)
+        actual_annotations =
+          expected_annotations.with_offense_annotations(cop.offenses)
+        expect(actual_annotations.to_s).to eq(source)
+      end
+
+      # Parsed representation of code annotated with the `^^^ Message` style
+      class AnnotatedSource
+        ANNOTATION_PATTERN = /\A\s*\^+ /.freeze
+
+        # @param annotated_source [String] string passed to the matchers
+        #
+        # Separates annotation lines from source lines. Tracks the real
+        # source line number that each annotation corresponds to.
+        #
+        # @return [AnnotatedSource]
+        def self.parse(annotated_source)
+          source      = []
+          annotations = []
+
+          annotated_source.each_line do |source_line|
+            if ANNOTATION_PATTERN.match?(source_line)
+              annotations << [source.size, source_line]
+            else
+              source << source_line
+            end
+          end
+
+          new(source, annotations)
+        end
+
+        # @param lines [Array<String>]
+        # @param annotations [Array<(Integer, String)>]
+        #   each entry is the annotated line number and the annotation text
+        #
+        # @note annotations are sorted so that reconstructing the annotation
+        #   text via {#to_s} is deterministic
+        def initialize(lines, annotations)
+          @lines       = lines.freeze
+          @annotations = annotations.sort.freeze
+        end
+
+        # Construct annotated source string (like what we parse)
+        #
+        # Reconstruct a deterministic annotated source string. This is
+        # useful for eliminating semantically irrelevant annotation
+        # ordering differences.
+        #
+        # @example standardization
+        #
+        #     source1 = AnnotatedSource.parse(<<-RUBY)
+        #     line1
+        #     ^ Annotation 1
+        #      ^^ Annotation 2
+        #     RUBY
+        #
+        #     source2 = AnnotatedSource.parse(<<-RUBY)
+        #     line1
+        #      ^^ Annotation 2
+        #     ^ Annotation 1
+        #     RUBY
+        #
+        #     source1.to_s == source2.to_s # => true
+        #
+        # @return [String]
+        def to_s
+          reconstructed = lines.dup
+
+          annotations.reverse_each do |line_number, annotation|
+            reconstructed.insert(line_number, annotation)
+          end
+
+          reconstructed.join
+        end
+
+        # Return the plain source code without annotations
+        #
+        # @return [String]
+        def plain_source
+          lines.join
+        end
+
+        # Annotate the source code with the RuboCop offenses provided
+        #
+        # @param offenses [Array<RuboCop::Cop::Offense>]
+        #
+        # @return [self]
+        def with_offense_annotations(offenses)
+          offense_annotations =
+            offenses.map do |offense|
+              indent     = ' ' * offense.column
+              carets     = '^' * offense.column_length
+
+              [offense.line, "#{indent}#{carets} #{offense.message}\n"]
+            end
+
+          self.class.new(lines, offense_annotations)
+        end
+
+        private
+
+        attr_reader :lines, :annotations
+      end
+    end
+  end
+end

data/lib/rubocop/rspec/host_environment_simulation_helper.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# RuboCop can be run in contexts where unexpected other libraries are included,
+# which may interfere with its normal behavior. In order to test those
+# situations, it may be necessary to require another library for the duration
+# of one spec
+module HostEnvironmentSimulatorHelper
+  def in_its_own_process_with(*files)
+    if ::Process.respond_to?(:fork)
+      pid = ::Process.fork do
+        # Need to write coverage result under different name
+        if defined?(SimpleCov)
+          SimpleCov.command_name "rspec-fork-#{Process.pid}"
+          SimpleCov.pid = Process.pid
+        end
+
+        files.each { |file| require file }
+        yield
+      end
+      ::Process.wait(pid)
+
+      # assert that the block did not fail
+      expect($CHILD_STATUS).to be_success
+    else
+      warn 'Process.fork is not available.'
+    end
+  end
+end

data/lib/rubocop/rspec/shared_contexts.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require 'tmpdir'
+require 'fileutils'
+
+RSpec.shared_context 'isolated environment', :isolated_environment do
+  around do |example|
+    Dir.mktmpdir do |tmpdir|
+      original_home = ENV['HOME']
+      original_xdg_config_home = ENV['XDG_CONFIG_HOME']
+
+      # Make sure to expand all symlinks in the path first. Otherwise we may
+      # get mismatched pathnames when loading config files later on.
+      tmpdir = File.realpath(tmpdir)
+
+      # Make upwards search for .rubocop.yml files stop at this directory.
+      RuboCop::FileFinder.root_level = tmpdir
+
+      begin
+        virtual_home = File.expand_path(File.join(tmpdir, 'home'))
+        Dir.mkdir(virtual_home)
+        ENV['HOME'] = virtual_home
+        ENV.delete('XDG_CONFIG_HOME')
+
+        working_dir = File.join(tmpdir, 'work')
+        Dir.mkdir(working_dir)
+
+        RuboCop::PathUtil.chdir(working_dir) do
+          example.run
+        end
+      ensure
+        ENV['HOME'] = original_home
+        ENV['XDG_CONFIG_HOME'] = original_xdg_config_home
+
+        RuboCop::FileFinder.root_level = nil
+      end
+    end
+  end
+end
+
+# This context assumes nothing and defines `cop`, among others.
+RSpec.shared_context 'config', :config do # rubocop:disable Metrics/BlockLength
+  ### Meant to be overridden at will
+
+  let(:source) { 'code = {some: :ruby}' }
+
+  let(:cop_class) do
+    if described_class.is_a?(Class) && described_class < RuboCop::Cop::Cop
+      described_class
+    else
+      RuboCop::Cop::Cop
+    end
+  end
+
+  let(:cop_config) { {} }
+
+  let(:other_cops) { {} }
+
+  let(:cop_options) { {} }
+
+  ### Utilities
+
+  def source_range(range, buffer: source_buffer)
+    Parser::Source::Range.new(buffer, range.begin,
+                              range.exclude_end? ? range.end : range.end + 1)
+  end
+
+  ### Useful intermediary steps (less likely to be overridden)
+
+  let(:processed_source) { parse_source(source, 'test') }
+
+  let(:source_buffer) { processed_source.buffer }
+
+  let(:all_cops_config) do
+    rails = { 'TargetRubyVersion' => ruby_version }
+    rails['TargetRailsVersion'] = rails_version if rails_version
+    rails
+  end
+
+  let(:cur_cop_config) do
+    RuboCop::ConfigLoader
+      .default_configuration.for_cop(cop_class)
+      .merge({
+               'Enabled' => true, # in case it is 'pending'
+               'AutoCorrect' => true # in case defaults set it to false
+             })
+      .merge(cop_config)
+  end
+
+  let(:config) do
+    hash = { 'AllCops' => all_cops_config,
+             cop_class.cop_name => cur_cop_config }.merge!(other_cops)
+
+    RuboCop::Config.new(hash, "#{Dir.pwd}/.rubocop.yml")
+  end
+
+  let(:cop) do
+    cop_class.new(config, cop_options)
+             .tap { |cop| cop.processed_source = processed_source }
+  end
+end
+
+RSpec.shared_context 'mock console output' do
+  before do
+    $stdout = StringIO.new
+    $stderr = StringIO.new
+  end
+
+  after do
+    $stdout = STDOUT
+    $stderr = STDERR
+  end
+end
+
+RSpec.shared_context 'ruby 2.4', :ruby24 do
+  let(:ruby_version) { 2.4 }
+end
+
+RSpec.shared_context 'ruby 2.5', :ruby25 do
+  let(:ruby_version) { 2.5 }
+end
+
+RSpec.shared_context 'ruby 2.6', :ruby26 do
+  let(:ruby_version) { 2.6 }
+end
+
+RSpec.shared_context 'ruby 2.7', :ruby27 do
+  let(:ruby_version) { 2.7 }
+end