rubocop 0.42.0 → 0.52.1

data/lib/rubocop/remote_config.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 require 'net/http'
@@ -7,6 +6,8 @@ require 'time'
 module RuboCop
   # Common methods and behaviors for dealing with remote config files.
   class RemoteConfig
+    attr_reader :uri
+
     CACHE_LIFETIME = 24 * 60 * 60
 
     def initialize(url, base_dir)
@@ -17,25 +18,51 @@ module RuboCop
     def file
       return cache_path unless cache_path_expired?
 
-      http = Net::HTTP.new(@uri.hostname, @uri.port)
-      http.use_ssl = true if @uri.instance_of? URI::HTTPS
+      request do |response|
+        next if response.is_a?(Net::HTTPNotModified)
+        next if response.is_a?(SocketError)
+        open cache_path, 'w' do |io|
+          io.write response.body
+        end
+      end
+
+      cache_path
+    end
+
+    def inherit_from_remote(file, path)
+      new_uri = @uri.dup
+      new_uri.path.gsub!(%r{/[^/]*$}, "/#{file}")
+      RemoteConfig.new(new_uri.to_s, File.dirname(path))
+    end
+
+    private
+
+    def request(uri = @uri, limit = 10, &block)
+      raise ArgumentError, 'HTTP redirect too deep' if limit.zero?
 
-      request = Net::HTTP::Get.new(@uri.request_uri)
+      http = Net::HTTP.new(uri.hostname, uri.port)
+      http.use_ssl = true if uri.instance_of? URI::HTTPS
+
+      request = Net::HTTP::Get.new(uri.request_uri)
       if cache_path_exists?
         request['If-Modified-Since'] = File.stat(cache_path).mtime.rfc2822
       end
-      response = http.request(request)
 
-      cache_path.tap do |f|
-        if response.is_a?(Net::HTTPSuccess)
-          open f, 'w' do |io|
-            io.write response.body
-          end
-        end
-      end
+      handle_response(http.request(request), limit, &block)
+    rescue SocketError => err
+      handle_response(err, limit, &block)
     end
 
-    private
+    def handle_response(response, limit, &block)
+      case response
+      when Net::HTTPSuccess, Net::HTTPNotModified, SocketError
+        yield response
+      when Net::HTTPRedirection
+        request(URI.parse(response['location']), limit - 1, &block)
+      else
+        response.error!
+      end
+    end
 
     def cache_path
       File.expand_path(".rubocop-#{cache_name_from_uri}", @base_dir)

data/lib/rubocop/result_cache.rb

@@ -1,16 +1,14 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 require 'digest/md5'
 require 'find'
-require 'tmpdir'
 require 'etc'
 
 module RuboCop
   # Provides functionality for caching rubocop runs.
   class ResultCache
-    NON_CHANGING = [:color, :format, :formatters, :out, :debug, :fail_level,
-                    :cache, :fail_fast, :stdin].freeze
+    NON_CHANGING = %i[color format formatters out debug fail_level
+                      cache fail_fast stdin parallel].freeze
 
     # Remove old files so that the cache doesn't grow too big. When the
     # threshold MaxFilesInCache has been exceeded, the oldest 50% of all the
@@ -24,8 +22,20 @@ module RuboCop
       return unless File.exist?(cache_root)
 
       files, dirs = Find.find(cache_root).partition { |path| File.file?(path) }
-      if files.length > config_store.for('.').for_all_cops['MaxFilesInCache'] &&
-         files.length > 1
+      return unless requires_file_removal?(files.length, config_store)
+
+      remove_oldest_files(files, dirs, cache_root, verbose)
+    end
+
+    class << self
+      private
+
+      def requires_file_removal?(file_count, config_store)
+        file_count > 1 &&
+          file_count > config_store.for('.').for_all_cops['MaxFilesInCache']
+      end
+
+      def remove_oldest_files(files, dirs, cache_root, verbose)
         # Add 1 to half the number of files, so that we remove the file if
         # there's only 1 left.
         remove_count = 1 + files.length / 2
@@ -33,34 +43,32 @@ module RuboCop
           puts "Removing the #{remove_count} oldest files from #{cache_root}"
         end
         sorted = files.sort_by { |path| File.mtime(path) }
-        remove_files(sorted, dirs, remove_count, verbose)
+        remove_files(sorted, dirs, remove_count)
+      rescue Errno::ENOENT
+        # This can happen if parallel RuboCop invocations try to remove the
+        # same files. No problem.
+        puts $ERROR_INFO if verbose
       end
-    end
-
-    class << self
-      private
 
-      def remove_files(files, dirs, remove_count, verbose)
+      def remove_files(files, dirs, remove_count)
         # Batch file deletions, deleting over 130,000+ files will crash
         # File.delete.
         files[0, remove_count].each_slice(10_000).each do |files_slice|
           File.delete(*files_slice)
         end
         dirs.each { |dir| Dir.rmdir(dir) if Dir["#{dir}/*"].empty? }
-      rescue Errno::ENOENT
-        # This can happen if parallel RuboCop invocations try to remove the
-        # same files. No problem.
-        puts $ERROR_INFO if verbose
       end
     end
 
     def self.cache_root(config_store)
       root = config_store.for('.').for_all_cops['CacheRootDirectory']
-      if root == '/tmp'
-        tmpdir = File.realpath(Dir.tmpdir)
-        # Include user ID in the path to make sure the user has write access.
-        root = File.join(tmpdir, Process.uid.to_s)
-      end
+      root ||= if ENV.key?('XDG_CACHE_HOME')
+                 # Include user ID in the path to make sure the user has write
+                 # access.
+                 File.join(ENV['XDG_CACHE_HOME'], Process.uid.to_s)
+               else
+                 File.join(ENV['HOME'], '.cache')
+               end
       File.join(root, 'rubocop_cache')
     end
 
@@ -83,7 +91,7 @@ module RuboCop
     end
 
     def load
-      @cached_data.from_json(IO.binread(@path))
+      @cached_data.from_json(IO.read(@path, encoding: Encoding::UTF_8))
     end
 
     def save(offenses)
@@ -95,7 +103,7 @@ module RuboCop
       # indication that a symlink attack is being waged.
       return if symlink_protection_triggered?(dir)
 
-      File.open(preliminary_path, 'wb') do |f|
+      File.open(preliminary_path, 'w', encoding: Encoding::UTF_8) do |f|
         f.write(@cached_data.to_json(offenses))
       end
       # The preliminary path is used so that if there are multiple RuboCop
@@ -125,6 +133,7 @@ module RuboCop
 
     def file_checksum(file, config_store)
       Digest::MD5.hexdigest(Dir.pwd + file + IO.read(file) +
+                            File.stat(file).mode.to_s +
                             config_store.for(file).to_s)
     rescue Errno::ENOENT
       # Spurious files that come and go should not cause a crash, at least not
@@ -150,7 +159,7 @@ module RuboCop
           sources = source_files
                     .select { |path| File.file?(path) }
                     .sort
-                    .map { |path| IO.read(path) }
+                    .map { |path| IO.read(path, encoding: Encoding::UTF_8) }
           Digest::MD5.hexdigest(sources.join)
         end
     end

data/lib/rubocop/rspec/cop_helper.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 require 'tempfile'
@@ -8,12 +7,18 @@ module CopHelper
   extend RSpec::SharedContext
 
   let(:ruby_version) { 2.2 }
+  let(:enabled_rails) { false }
+  let(:rails_version) { false }
 
-  def inspect_source_file(cop, source)
-    Tempfile.open('tmp') { |f| inspect_source(cop, source, f) }
+  def inspect_source_file(source)
+    Tempfile.open('tmp') { |f| inspect_source(source, f) }
   end
 
-  def inspect_source(cop, source, file = nil)
+  def inspect_gemfile(source)
+    inspect_source(source, 'Gemfile')
+  end
+
+  def inspect_source(source, file = nil)
     if source.is_a?(Array) && source.size == 1
       raise "Don't use an array for a single line of code: #{source}"
     end
@@ -36,11 +41,11 @@ module CopHelper
     RuboCop::ProcessedSource.new(source, ruby_version, file)
   end
 
-  def autocorrect_source_file(cop, source)
-    Tempfile.open('tmp') { |f| autocorrect_source(cop, source, f) }
+  def autocorrect_source_file(source)
+    Tempfile.open('tmp') { |f| autocorrect_source(source, f) }
   end
 
-  def autocorrect_source(cop, source, file = nil)
+  def autocorrect_source(source, file = nil)
     cop.instance_variable_get(:@options)[:auto_correct] = true
     processed_source = parse_source(source, file)
     _investigate(cop, processed_source)
@@ -50,6 +55,15 @@ module CopHelper
     corrector.rewrite
   end
 
+  def autocorrect_source_with_loop(source, file = nil)
+    loop do
+      cop.instance_variable_set(:@corrections, [])
+      new_source = autocorrect_source(source, file)
+      return new_source if new_source == source
+      source = new_source
+    end
+  end
+
   def _investigate(cop, processed_source)
     forces = RuboCop::Cop::Force.all.each_with_object([]) do |klass, instances|
       next unless cop.join_force?(klass)

data/lib/rubocop/rspec/expect_offense.rb

@@ -0,0 +1,165 @@
+# 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
+    # and 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.strip_indent)
+    #       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.strip_indent)
+    #       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.'
+    #     )
+    #
+    # 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_offenses` method has
+    # to do more work by parsing out lines that contain carets.
+    module ExpectOffense
+      def expect_offense(source, file = nil)
+        expected_annotations = AnnotatedSource.parse(source)
+
+        if expected_annotations.plain_source == source
+          raise 'Use expect_no_offenses to assert that no offenses are found'
+        end
+
+        inspect_source(expected_annotations.plain_source, file)
+        actual_annotations =
+          expected_annotations.with_offense_annotations(cop.offenses)
+        expect(actual_annotations.to_s).to eq(expected_annotations.to_s)
+      end
+
+      def expect_no_offenses(source, file = nil)
+        inspect_source(source, file)
+
+        expect(cop.offenses).to be_empty
+      end
+
+      # Parsed representation of code annotated with the `^^^ Message` style
+      class AnnotatedSource
+        ANNOTATION_PATTERN = /\A\s*\^+ /
+
+        # @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 source_line =~ ANNOTATION_PATTERN
+              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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 # RuboCop can be run in contexts where unexpected other libraries are included,
@@ -11,7 +10,7 @@ module HostEnvironmentSimulatorHelper
       pid = ::Process.fork do
         # Need to write coverage result under different name
         if defined?(SimpleCov)
-          SimpleCov.command_name "rspec_#{Process.pid}"
+          SimpleCov.coverage_dir "coverage/ignored_results_#{Process.pid}"
           SimpleCov.pid = Process.pid
         end
 

data/lib/rubocop/rspec/shared_contexts.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 require 'tmpdir'
@@ -43,6 +42,8 @@ shared_context 'config', :config do
     end
 
     hash = { 'AllCops' => { 'TargetRubyVersion' => ruby_version } }
+    hash['Rails'] = { 'Enabled' => true } if enabled_rails
+    hash['AllCops']['TargetRailsVersion'] = rails_version if rails_version
     if respond_to?(:cop_config)
       cop_name = described_class.cop_name
       hash[cop_name] = RuboCop::ConfigLoader
@@ -50,18 +51,12 @@ shared_context 'config', :config do
                        .merge(cop_config)
     end
 
+    hash = other_cops.merge hash if respond_to?(:other_cops)
+
     RuboCop::Config.new(hash, "#{Dir.pwd}/.rubocop.yml")
   end
 end
 
-shared_context 'ruby 1.9', :ruby19 do
-  let(:ruby_version) { 1.9 }
-end
-
-shared_context 'ruby 2.0', :ruby20 do
-  let(:ruby_version) { 2.0 }
-end
-
 shared_context 'ruby 2.1', :ruby21 do
   let(:ruby_version) { 2.1 }
 end
@@ -77,3 +72,23 @@ end
 shared_context 'ruby 2.4', :ruby24 do
   let(:ruby_version) { 2.4 }
 end
+
+shared_context 'ruby 2.5', :ruby25 do
+  let(:ruby_version) { 2.5 }
+end
+
+shared_context 'with Rails', :enabled_rails do
+  let(:enabled_rails) { true }
+end
+
+shared_context 'with Rails 3', :rails3 do
+  let(:rails_version) { 3.0 }
+end
+
+shared_context 'with Rails 4', :rails4 do
+  let(:rails_version) { 4.0 }
+end
+
+shared_context 'with Rails 5', :rails5 do
+  let(:rails_version) { 5.0 }
+end

data/lib/rubocop/rspec/shared_examples.rb

@@ -1,11 +1,10 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 # `cop` and `source` must be declared with #let.
 
 shared_examples_for 'accepts' do
   it 'accepts' do
-    inspect_source(cop, source)
+    inspect_source(source)
     expect(cop.offenses).to be_empty
   end
 end
@@ -13,7 +12,7 @@ end
 shared_examples_for 'mimics MRI 2.1' do |grep_mri_warning|
   if RUBY_ENGINE == 'ruby' && RUBY_VERSION.start_with?('2.1')
     it "mimics MRI #{RUBY_VERSION} built-in syntax checking" do
-      inspect_source(cop, source)
+      inspect_source(source)
       offenses_by_mri = MRISyntaxChecker.offenses_for_source(
         source, cop.name, grep_mri_warning
       )
@@ -23,7 +22,7 @@ shared_examples_for 'mimics MRI 2.1' do |grep_mri_warning|
         offense_by_mri = offenses_by_mri[index]
         # Exclude column attribute since MRI does not
         # output column number.
-        [:severity, :line, :cop_name].each do |a|
+        %i[severity line cop_name].each do |a|
           expect(offense_by_cop.send(a)).to eq(offense_by_mri.send(a))
         end
       end
@@ -39,7 +38,7 @@ shared_examples_for 'misaligned' do |prefix, alignment_base, arg, end_kw, name|
             end_kw]
 
   it "registers an offense for mismatched #{name} ... end" do
-    inspect_source(cop, source)
+    inspect_source(source)
     expect(cop.offenses.size).to eq(1)
     base_regexp = Regexp.escape(alignment_base)
     regexp = /`end` at 2, \d+ is not aligned with `#{base_regexp}` at 1,/
@@ -51,7 +50,7 @@ shared_examples_for 'misaligned' do |prefix, alignment_base, arg, end_kw, name|
     # style. In other cases, it won't match any style at all
     expect(cop.config_to_allow_offenses).to(
       eq('Enabled' => false).or(
-        satisfy { |h| other_styles.include?(h['AlignWith']) }
+        satisfy { |h| other_styles.include?(h['EnforcedStyleAlignWith']) }
       )
     )
   end
@@ -59,7 +58,7 @@ shared_examples_for 'misaligned' do |prefix, alignment_base, arg, end_kw, name|
   it "auto-corrects mismatched #{name} ... end" do
     aligned_source = ["#{prefix}#{alignment_base} #{arg}",
                       "#{' ' * prefix.length}#{end_kw.strip}"].join("\n")
-    corrected = autocorrect_source(cop, source)
+    corrected = autocorrect_source(source)
     expect(corrected).to eq(aligned_source)
   end
 end
@@ -68,34 +67,26 @@ shared_examples_for 'aligned' do |alignment_base, arg, end_kw, name|
   name ||= alignment_base
   name = name.gsub(/\n/, ' <newline>')
   it "accepts matching #{name} ... end" do
-    inspect_source(cop, ["#{alignment_base} #{arg}",
-                         end_kw])
+    inspect_source(["#{alignment_base} #{arg}",
+                    end_kw])
     expect(cop.offenses).to be_empty
   end
 end
 
 shared_examples_for 'debugger' do |name, src|
   it "reports an offense for a #{name} call" do
-    inspect_source(cop, src)
+    inspect_source(src)
     src = [src] if src.is_a? String
     expect(cop.offenses.size).to eq(src.size)
     expect(cop.messages)
       .to eq(src.map { |s| "Remove debugger entry point `#{s}`." })
     expect(cop.highlights).to eq(src)
   end
-
-  it "can autocorrect a #{name} call" do
-    lines = src.is_a?(String) ? src : src.join("\n")
-    new_source = autocorrect_source(cop, ['def a',
-                                          "  #{lines}",
-                                          'end'].join("\n"))
-    expect(new_source).to eq("def a\nend")
-  end
 end
 
 shared_examples_for 'non-debugger' do |name, src|
   it "does not report an offense for #{name}" do
-    inspect_source(cop, src)
+    inspect_source(src)
     expect(cop.offenses).to be_empty
   end
 end

data/lib/rubocop/rspec/support.rb

@@ -1,9 +1,9 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 # Require this file to load code that supports testing using RSpec.
 
-require 'rubocop/rspec/cop_helper'
-require 'rubocop/rspec/host_environment_simulation_helper'
-require 'rubocop/rspec/shared_contexts'
-require 'rubocop/rspec/shared_examples'
+require_relative 'cop_helper'
+require_relative 'host_environment_simulation_helper'
+require_relative 'shared_contexts'
+require_relative 'shared_examples'
+require_relative 'expect_offense'