rubocop 0.48.1 → 0.49.0

data/lib/rubocop/formatter/simple_text_formatter.rb

@@ -64,17 +64,6 @@ module RuboCop
         @total_correction_count += offenses.count(&:corrected?)
       end
 
-      def smart_path(path)
-        # Ideally, we calculate this relative to the project root.
-        base_dir = Dir.pwd
-
-        if path.start_with? base_dir
-          relative_path(path, base_dir)
-        else
-          path
-        end
-      end
-
       def colored_severity_code(offense)
         color = COLOR_FOR_SEVERITY[offense.severity.name]
         colorize(offense.severity.code, color)

data/lib/rubocop/node_pattern.rb

@@ -23,55 +23,55 @@ module RuboCop
   #
   # ## Pattern string format examples
   #
-  #    ':sym'              # matches a literal symbol
-  #    '1'                 # matches a literal integer
-  #    'nil'               # matches a literal nil
-  #    'send'              # matches (send ...)
-  #    '(send)'            # matches (send)
-  #    '(send ...)'        # matches (send ...)
-  #    '(op-asgn)'         # node types with hyphenated names also work
-  #    '{send class}'      # matches (send ...) or (class ...)
-  #    '({send class})'    # matches (send) or (class)
-  #    '(send const)'      # matches (send (const ...))
-  #    '(send _ :new)'     # matches (send <anything> :new)
-  #    '(send $_ :new)'    # as above, but whatever matches the $_ is captured
-  #    '(send $_ $_)'      # you can use as many captures as you want
-  #    '(send !const ...)' # ! negates the next part of the pattern
-  #    '$(send const ...)' # arbitrary matching can be performed on a capture
-  #    '(send _recv _msg)' # wildcards can be named (for readability)
-  #    '(send ... :new)'   # you can specifically match against the last child
-  #                        # (this only works for the very last)
-  #    '(send $...)'       # capture all the children as an array
-  #    '(send $... int)'   # capture all children but the last as an array
-  #    '(send _x :+ _x)'   # unification is performed on named wildcards
-  #                        # (like Prolog variables...)
-  #                        # (#== is used to see if values unify)
-  #    '(int odd?)'        # words which end with a ? are predicate methods,
-  #                        # are are called on the target to see if it matches
-  #                        # any Ruby method which the matched object supports
-  #                        # can be used
-  #                        # if a truthy value is returned, the match succeeds
-  #    '(int [!1 !2])'     # [] contains multiple patterns, ALL of which must
-  #                        # match in that position
-  #                        # in other words, while {} is pattern union (logical
-  #                        # OR), [] is intersection (logical AND)
-  #    '(send %1 _)'       # % stands for a parameter which must be supplied to
-  #                        # #match at matching time
-  #                        # it will be compared to the corresponding value in
-  #                        # the AST using #==
-  #                        # a bare '%' is the same as '%1'
-  #                        # the number of extra parameters passed to #match
-  #                        # must equal the highest % value in the pattern
-  #                        # for consistency, %0 is the 'root node' which is
-  #                        # passed as the 1st argument to #match, where the
-  #                        # matching process starts
-  #    '^^send'            # each ^ ascends one level in the AST
-  #                        # so this matches against the grandparent node
-  #    '#method'           # we call this a 'funcall'; it calls a method in the
-  #                        # context where a pattern-matching method is defined
-  #                        # if that returns a truthy value, the match succeeds
-  #    'equal?(%1)'        # predicates can be given 1 or more extra args
-  #    '#method(%0, 1)'    # funcalls can also be given 1 or more extra args
+  #     ':sym'              # matches a literal symbol
+  #     '1'                 # matches a literal integer
+  #     'nil'               # matches a literal nil
+  #     'send'              # matches (send ...)
+  #     '(send)'            # matches (send)
+  #     '(send ...)'        # matches (send ...)
+  #     '(op-asgn)'         # node types with hyphenated names also work
+  #     '{send class}'      # matches (send ...) or (class ...)
+  #     '({send class})'    # matches (send) or (class)
+  #     '(send const)'      # matches (send (const ...))
+  #     '(send _ :new)'     # matches (send <anything> :new)
+  #     '(send $_ :new)'    # as above, but whatever matches the $_ is captured
+  #     '(send $_ $_)'      # you can use as many captures as you want
+  #     '(send !const ...)' # ! negates the next part of the pattern
+  #     '$(send const ...)' # arbitrary matching can be performed on a capture
+  #     '(send _recv _msg)' # wildcards can be named (for readability)
+  #     '(send ... :new)'   # you can specifically match against the last child
+  #                         # (this only works for the very last)
+  #     '(send $...)'       # capture all the children as an array
+  #     '(send $... int)'   # capture all children but the last as an array
+  #     '(send _x :+ _x)'   # unification is performed on named wildcards
+  #                         # (like Prolog variables...)
+  #                         # (#== is used to see if values unify)
+  #     '(int odd?)'        # words which end with a ? are predicate methods,
+  #                         # are are called on the target to see if it matches
+  #                         # any Ruby method which the matched object supports
+  #                         # can be used
+  #                         # if a truthy value is returned, the match succeeds
+  #     '(int [!1 !2])'     # [] contains multiple patterns, ALL of which must
+  #                         # match in that position
+  #                         # in other words, while {} is pattern union (logical
+  #                         # OR), [] is intersection (logical AND)
+  #     '(send %1 _)'       # % stands for a parameter which must be supplied to
+  #                         # #match at matching time
+  #                         # it will be compared to the corresponding value in
+  #                         # the AST using #==
+  #                         # a bare '%' is the same as '%1'
+  #                         # the number of extra parameters passed to #match
+  #                         # must equal the highest % value in the pattern
+  #                         # for consistency, %0 is the 'root node' which is
+  #                         # passed as the 1st argument to #match, where the
+  #                         # matching process starts
+  #     '^^send'            # each ^ ascends one level in the AST
+  #                         # so this matches against the grandparent node
+  #     '#method'           # we call this a 'funcall'; it calls a method in the
+  #                         # context where a pattern-matching method is defined
+  #                         # if that returns a truthy value, the match succeeds
+  #     'equal?(%1)'        # predicates can be given 1 or more extra args
+  #     '#method(%0, 1)'    # funcalls can also be given 1 or more extra args
   #
   # You can nest arbitrarily deep:
   #
@@ -475,8 +475,8 @@ module RuboCop
               "#{compiler.emit_trailing_params});" \
               "#{compiler.emit_method_code};end"
 
-        file, lineno = *caller.first.split(':')
-        class_eval(src, file, lineno.to_i)
+        location = caller_locations(1, 1).first
+        class_eval(src, location.path, location.lineno)
       end
 
       # Define a method which recurses over the descendants of an AST node,
@@ -487,7 +487,7 @@ module RuboCop
       # yield all descendants which match.
       def def_node_search(method_name, pattern_str)
         compiler = RuboCop::NodePattern::Compiler.new(pattern_str, 'node')
-        called_from = caller.first.split(':')
+        called_from = caller(1..1).first.split(':')
 
         if method_name.to_s.end_with?('?')
           node_search_first(method_name, compiler, called_from)

data/lib/rubocop/options.rb

@@ -156,6 +156,7 @@ module RuboCop
 
       option(opts, '-v', '--version')
       option(opts, '-V', '--verbose-version')
+      option(opts, '-P', '--parallel')
     end
 
     def add_list_options(opts)
@@ -217,11 +218,33 @@ module RuboCop
         raise ArgumentError, '--no-offense-counts can only be used together ' \
                              'with --auto-gen-config.'
       end
+      validate_parallel
+
       return if incompatible_options.size <= 1
       raise ArgumentError, 'Incompatible cli options: ' \
                            "#{incompatible_options.inspect}"
     end
 
+    def validate_parallel
+      return unless @options.key?(:parallel)
+
+      if @options[:cache] == 'false'
+        raise ArgumentError, '-P/--parallel uses caching to speed up ' \
+                             'execution, so combining with --cache false is ' \
+                             'not allowed.'
+      end
+
+      combos = {
+        auto_gen_config: '-P/--parallel uses caching to speed up execution, ' \
+                         'while --auto-gen-config needs a non-cached run, ' \
+                         'so they cannot be combined.',
+        fail_fast: '-P/--parallel can not be combined with -F/--fail-fast.',
+        auto_correct: '-P/--parallel can not be combined with --auto-correct.'
+      }
+
+      combos.each { |key, msg| raise ArgumentError, msg if @options.key?(key) }
+    end
+
     def only_includes_unneeded_disable?
       @options.key?(:only) &&
         (@options[:only] & %w[Lint/UnneededDisable UnneededDisable]).any?
@@ -323,6 +346,8 @@ module RuboCop
       no_color:              'Force color output on or off.',
       version:               'Display version.',
       verbose_version:       'Display verbose version.',
+      parallel:             ['Use available CPUs to execute inspection in',
+                             'parallel.'],
       stdin:                ['Pipe source from STDIN, using FILE in offense',
                              'reports. This is useful for editor integration.']
     }.freeze

data/lib/rubocop/path_util.rb

@@ -14,12 +14,28 @@ module RuboCop
       path_name.relative_path_from(Pathname.new(base_dir)).to_s
     end
 
+    def smart_path(path)
+      # Ideally, we calculate this relative to the project root.
+      base_dir = Dir.pwd
+
+      if path.start_with? base_dir
+        relative_path(path, base_dir)
+      else
+        path
+      end
+    end
+
     def match_path?(pattern, path)
       case pattern
       when String
         File.fnmatch?(pattern, path, File::FNM_PATHNAME)
       when Regexp
-        path =~ pattern
+        begin
+          path =~ pattern
+        rescue ArgumentError => e
+          return false if e.message.start_with?('invalid byte sequence')
+          raise e
+        end
       end
     end
 

data/lib/rubocop/result_cache.rb

@@ -2,14 +2,13 @@
 
 require 'digest/md5'
 require 'find'
-require 'tmpdir'
 require 'etc'
 
 module RuboCop
   # Provides functionality for caching rubocop runs.
   class ResultCache
     NON_CHANGING = %i[color format formatters out debug fail_level
-                      cache fail_fast stdin].freeze
+                      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
@@ -63,11 +62,13 @@ module RuboCop
 
     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
 

data/lib/rubocop/rspec/expect_offense.rb

@@ -0,0 +1,167 @@
+# 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(cop, <<-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
+      DEFAULT_FILENAME = 'example.rb'.freeze
+
+      def expect_offense(source, filename = DEFAULT_FILENAME)
+        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(cop, expected_annotations.plain_source, filename)
+        actual_annotations =
+          expected_annotations.with_offense_annotations(cop.offenses)
+        expect(expected_annotations.to_s).to eq(actual_annotations.to_s)
+      end
+
+      def expect_no_offenses(source, filename = DEFAULT_FILENAME)
+        inspect_source(cop, source, filename)
+
+        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/shared_examples.rb

@@ -82,14 +82,6 @@ shared_examples_for 'debugger' do |name, src|
       .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|

data/lib/rubocop/rspec/support.rb

@@ -6,3 +6,4 @@ require 'rubocop/rspec/cop_helper'
 require 'rubocop/rspec/host_environment_simulation_helper'
 require 'rubocop/rspec/shared_contexts'
 require 'rubocop/rspec/shared_examples'
+require 'rubocop/rspec/expect_offense'

data/lib/rubocop/runner.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'parallel'
+
 module RuboCop
   # This class handles the processing of files, which includes dealing with
   # formatters and letting cops inspect the files.
@@ -33,6 +35,7 @@ module RuboCop
       if @options[:list_target_files]
         list_files(target_files)
       else
+        warm_cache(target_files) if @options[:parallel]
         inspect_files(target_files)
       end
     end
@@ -43,6 +46,13 @@ module RuboCop
 
     private
 
+    # Warms up the RuboCop cache by forking a suitable number of rubocop
+    # instances that each inspects its alotted group of files.
+    def warm_cache(target_files)
+      puts 'Running parallel inspection'
+      Parallel.each(target_files, &method(:file_offenses))
+    end
+
     def find_target_files(paths)
       target_finder = TargetFinder.new(@config_store, @options)
       target_files = target_finder.find(paths)
@@ -116,7 +126,7 @@ module RuboCop
     end
 
     def add_unneeded_disables(file, offenses, source)
-      if check_for_unneded_disables?(source)
+      if check_for_unneeded_disables?(source)
         config = @config_store.for(file)
         if config.for_cop(Cop::Lint::UnneededDisable).fetch('Enabled')
           cop = Cop::Lint::UnneededDisable.new(config, @options)
@@ -132,7 +142,7 @@ module RuboCop
       offenses.sort.reject(&:disabled?).freeze
     end
 
-    def check_for_unneded_disables?(source)
+    def check_for_unneeded_disables?(source)
       !source.disabled_line_ranges.empty? && !filtered_run?
     end