rubocop 0.40.0 → 0.41.0

data/lib/rubocop/cop/style/symbol_proc.rb

@@ -19,33 +19,18 @@ module RuboCop
 
         def on_block(node)
           block_send_or_super, block_args, block_body = *node
-
-          if super?(block_send_or_super)
-            bmethod_name = :super
-          else
-            _breceiver, bmethod_name, _bargs = *block_send_or_super
-          end
+          block_method_name = resolve_block_method_name(block_send_or_super)
 
           # TODO: Rails-specific handling that we should probably make
           # configurable - https://github.com/bbatsov/rubocop/issues/1485
           # we should ignore lambdas & procs
           return if block_send_or_super == PROC_NODE
-          return if [:lambda, :proc].include?(bmethod_name)
-          return if ignored_method?(bmethod_name)
+          return if [:lambda, :proc].include?(block_method_name)
+          return if ignored_method?(block_method_name)
           return unless can_shorten?(block_args, block_body)
 
           _receiver, method_name, _args = *block_body
-
-          sb = node.source_range.source_buffer
-          block_start = node.loc.begin.begin_pos
-          block_end = node.loc.end.end_pos
-          range = Parser::Source::Range.new(sb, block_start, block_end)
-
-          add_offense(node,
-                      range,
-                      format(MSG,
-                             method_name,
-                             bmethod_name))
+          offense(node, method_name, block_method_name)
         end
 
         def autocorrect(node)
@@ -62,6 +47,28 @@ module RuboCop
           end
         end
 
+        private
+
+        def resolve_block_method_name(block_send_or_super)
+          return :super if super?(block_send_or_super)
+
+          _receiver, method_name, _args = *block_send_or_super
+          method_name
+        end
+
+        def offense(node, method_name, block_method_name)
+          sb = node.source_range.source_buffer
+          block_start = node.loc.begin.begin_pos
+          block_end = node.loc.end.end_pos
+          range = Parser::Source::Range.new(sb, block_start, block_end)
+
+          add_offense(node,
+                      range,
+                      format(MSG,
+                             method_name,
+                             block_method_name))
+        end
+
         def autocorrect_method(corrector, node, args, method_name)
           if args.empty?
             autocorrect_no_args(corrector, node, method_name)

data/lib/rubocop/cop/style/word_array.rb

@@ -27,7 +27,7 @@ module RuboCop
         def autocorrect(node)
           words = node.children
           if style == :percent
-            escape = words.any? { |w| double_quotes_required?(w.children[0]) }
+            escape = words.any? { |w| needs_escaping?(w.children[0]) }
             char = escape ? 'W' : 'w'
             contents = autocorrect_words(words, escape, node.loc.line)
             lambda do |corrector|
@@ -107,10 +107,6 @@ module RuboCop
           end.join(' ')
         end
 
-        def escape_string(string)
-          string.inspect[1..-2].tap { |s| s.gsub!(/\\"/, '"') }
-        end
-
         def style_detected(style, ary_size)
           cfg = config_to_allow_offenses
           return if cfg['Enabled'] == false

data/lib/rubocop/cop/style/zero_length_predicate.rb

@@ -41,15 +41,15 @@ module RuboCop
         end
 
         def_node_matcher :zero_length_predicate, <<-END
-          {(send (send _ ${:length :size}) $:== (int $0))
-           (send (int $0) $:== (send _ ${:length :size}))
-           (send (send _ ${:length :size}) $:<  (int $1))
-           (send (int $1) $:> (send _ ${:length :size}))}
+          {(send (send (...) ${:length :size}) $:== (int $0))
+           (send (int $0) $:== (send (...) ${:length :size}))
+           (send (send (...) ${:length :size}) $:<  (int $1))
+           (send (int $1) $:> (send (...) ${:length :size}))}
         END
 
         def_node_matcher :nonzero_length_predicate, <<-END
-          {(send (send _ ${:length :size}) ${:> :!=} (int $0))
-           (send (int $0) ${:< :!=} (send _ ${:length :size}))}
+          {(send (send (...) ${:length :size}) ${:> :!=} (int $0))
+           (send (int $0) ${:< :!=} (send (...) ${:length :size}))}
         END
 
         def autocorrect(node)

data/lib/rubocop/cop/team.rb

@@ -9,7 +9,9 @@ module RuboCop
       # bad things are liable to happen
       INCOMPATIBLE_COPS = {
         Style::SymbolProc => [Style::SpaceBeforeBlockBraces],
-        Style::SpaceBeforeBlockBraces => [Style::SymbolProc]
+        Style::SpaceBeforeBlockBraces => [Style::SymbolProc],
+        Style::LineEndConcatenation => [Style::UnneededInterpolation],
+        Style::UnneededInterpolation => [Style::LineEndConcatenation]
       }.freeze
 
       DEFAULT_OPTIONS = {
@@ -17,6 +19,8 @@ module RuboCop
         debug: false
       }.freeze
 
+      Investigation = Struct.new(:offenses, :errors)
+
       attr_reader :errors, :warnings, :updated_source_file
 
       alias updated_source_file? updated_source_file
@@ -45,32 +49,7 @@ module RuboCop
           return Lint::Syntax.offenses_from_processed_source(processed_source)
         end
 
-        # The autocorrection process may have to be repeated multiple times
-        # until there are no corrections left to perform
-        # To speed things up, run auto-correcting cops by themselves, and only
-        # run the other cops when no corrections are left
-        autocorrect_cops, other_cops = cops.partition(&:autocorrect?)
-        offenses = []
-        errors = {}
-
-        if autocorrect_cops.any?
-          commissioner = Commissioner.new(autocorrect_cops,
-                                          forces_for(autocorrect_cops))
-          offenses = commissioner.investigate(processed_source)
-          if autocorrect(processed_source.buffer, autocorrect_cops)
-            # We corrected some errors. Another round of inspection will be
-            # done, and any other offenses will be caught then, so we don't
-            # need to continue.
-            return offenses
-          end
-          errors = commissioner.errors
-        end
-
-        commissioner = Commissioner.new(other_cops, forces_for(other_cops))
-        offenses.concat(commissioner.investigate(processed_source))
-        errors.merge!(commissioner.errors)
-        process_commissioner_errors(processed_source.path, errors)
-        offenses
+        offenses(processed_source)
       end
 
       def cops
@@ -93,6 +72,40 @@ module RuboCop
 
       private
 
+      def offenses(processed_source)
+        # The autocorrection process may have to be repeated multiple times
+        # until there are no corrections left to perform
+        # To speed things up, run auto-correcting cops by themselves, and only
+        # run the other cops when no corrections are left
+        autocorrect_cops, other_cops = cops.partition(&:autocorrect?)
+
+        autocorrect =
+          investigate(autocorrect_cops, processed_source) do |offenses|
+            # We corrected some errors. Another round of inspection will be
+            # done, and any other offenses will be caught then, so we don't
+            # need to continue.
+            return offenses if autocorrect(processed_source.buffer,
+                                           autocorrect_cops)
+          end
+
+        other = investigate(other_cops, processed_source)
+
+        errors = autocorrect.errors.merge(other.errors)
+        process_commissioner_errors(processed_source.path, errors)
+
+        autocorrect.offenses.concat(other.offenses)
+      end
+
+      def investigate(cops, processed_source)
+        return Investigation.new([], {}) if cops.empty?
+
+        commissioner = Commissioner.new(cops, forces_for(cops))
+        offenses = commissioner.investigate(processed_source)
+        yield offenses if block_given?
+
+        Investigation.new(offenses, commissioner.errors)
+      end
+
       def cop_enabled?(cop_class)
         @config.cop_enabled?(cop_class) ||
           (@options[:only] || []).include?(cop_class.cop_name)

data/lib/rubocop/cop/util.rb

@@ -23,19 +23,6 @@ module RuboCop
         + - * / % ** ~ +@ -@ [] []= ! != !~
       ).map(&:to_sym).push(:'`').freeze
 
-      STRING_ESCAPES = {
-        '\a' => "\a", '\b' => "\b", '\e' => "\e", '\f' => "\f", '\n' => "\n",
-        '\r' => "\r", '\s' => ' ',  '\t' => "\t", '\v' => "\v", "\\\n" => ''
-      }.freeze
-      STRING_ESCAPE_REGEX = /\\(?:
-                              [abefnrstv\n]    |   # simple escapes (above)
-                              \d{1,3}          |   # octal byte escape
-                              x\d{1,2}         |   # hex byte escape
-                              u[0-9a-fA-F]{4}  |   # unicode char escape
-                              u\{[^}]*\}       |   # extended unicode escape
-                              .                    # any other escaped char
-                            )/x
-
       # Match literal regex characters, not including anchors, character
       # classes, alternatives, groups, repetitions, references, etc
       LITERAL_REGEX = /[\w\s\-,"'!#%&<>=;:`~]|\\[^AbBdDgGkwWszZS0-9]/
@@ -225,7 +212,7 @@ module RuboCop
 
         # Regex matches IF there is a ' or there is a \\ in the string that is
         # not preceded/followed by another \\ (e.g. "\\x34") but not "\\\\".
-        string.inspect =~ /'|(?<! \\) \\{2}* \\ (?![\\"])/x
+        string =~ /'|(?<! \\) \\{2}* \\ (?![\\"])/x
       end
 
       # If double quoted string literals are found in Ruby code, and they are
@@ -233,12 +220,20 @@ module RuboCop
       def double_quotes_acceptable?(string)
         # If a string literal contains hard-to-type characters which would
         # not appear on a "normal" keyboard, then double-quotes are acceptable
-        double_quotes_required?(string) ||
+        needs_escaping?(string) ||
           string.codepoints.any? { |cp| cp < 32 || cp > 126 }
       end
 
+      def needs_escaping?(string)
+        double_quotes_required?(escape_string(string))
+      end
+
+      def escape_string(string)
+        string.inspect[1..-2].tap { |s| s.gsub!(/\\"/, '"') }
+      end
+
       def to_string_literal(string)
-        if double_quotes_required?(string)
+        if needs_escaping?(string)
           string.inspect
         else
           "'#{string.gsub('\\') { '\\\\' }}'"
@@ -246,35 +241,11 @@ module RuboCop
       end
 
       def to_symbol_literal(string)
-        if string =~ /\s/ || double_quotes_required?(string)
-          ":#{to_string_literal(string)}"
-        else
-          ":#{string}"
-        end
+        ":#{string.to_sym}"
       end
 
-      # Take a string with embedded escapes, and convert the escapes as the Ruby
-      # interpreter would when reading a double-quoted string literal.
-      # For example, "\\n" will be converted to "\n".
       def interpret_string_escapes(string)
-        # We currently don't handle \cx, \C-x, and \M-x
-        string.gsub(STRING_ESCAPE_REGEX) do |escape|
-          STRING_ESCAPES[escape] || begin
-            if escape[1] == 'x'
-              [escape[2..-1].hex].pack('C')
-            elsif escape[1] == 'u'
-              if escape[2] == '{'
-                escape[3..-1].split(/\s+/).map(&:hex).pack('U')
-              else
-                [escape[2..-1].hex].pack('U')
-              end
-            elsif escape[1] =~ /\d/ # octal escape
-              [escape[1..-1].to_i(8)].pack('C')
-            else
-              escape[1] # literal escaped char, like \\
-            end
-          end
-        end
+        StringInterpreter.interpret(string)
       end
     end
   end

data/lib/rubocop/formatter/disabled_config_formatter.rb

@@ -25,6 +25,12 @@ module RuboCop
         attr_accessor :config_to_allow_offenses, :detected_styles
       end
 
+      def initialize(output, options = {})
+        super
+        @cops_with_offenses ||= Hash.new(0)
+        @files_with_offenses ||= {}
+      end
+
       def file_started(_file, _file_info)
         @exclude_limit_option = @options[:exclude_limit]
         @exclude_limit = (
@@ -34,8 +40,6 @@ module RuboCop
       end
 
       def file_finished(file, offenses)
-        @cops_with_offenses ||= Hash.new(0)
-        @files_with_offenses ||= {}
         offenses.each do |o|
           @cops_with_offenses[o.cop_name] += 1
           @files_with_offenses[o.cop_name] ||= []
@@ -44,27 +48,41 @@ module RuboCop
       end
 
       def finished(_inspected_files)
-        command = 'rubocop --auto-gen-config'
-        if @exclude_limit_option
-          command += format(' --exclude-limit %d', @exclude_limit_option.to_i)
-        end
         output.puts HEADING % command
 
         # Syntax isn't a real cop and it can't be disabled.
         @cops_with_offenses.delete('Syntax')
 
-        @cops_with_offenses.sort.each do |cop_name, offense_count|
-          output.puts
-          cfg = self.class.config_to_allow_offenses[cop_name] || {}
+        output_offenses
 
-          output_cop_comments(output, cfg, cop_name, offense_count)
-          output_cop_config(output, cfg, cop_name)
-        end
         puts "Created #{output.path}."
         puts "Run `rubocop --config #{output.path}`, or add `inherit_from: " \
              "#{output.path}` in a .rubocop.yml file."
       end
 
+      def command
+        command = 'rubocop --auto-gen-config'
+        if @exclude_limit_option
+          command += format(' --exclude-limit %d', @exclude_limit_option.to_i)
+        end
+
+        command
+      end
+
+      def output_offenses
+        @cops_with_offenses.sort.each do |cop_name, offense_count|
+          output_cop(cop_name, offense_count)
+        end
+      end
+
+      def output_cop(cop_name, offense_count)
+        output.puts
+        cfg = self.class.config_to_allow_offenses[cop_name] || {}
+
+        output_cop_comments(output, cfg, cop_name, offense_count)
+        output_cop_config(output, cfg, cop_name)
+      end
+
       def output_cop_comments(output, cfg, cop_name, offense_count)
         output.puts "# Offense count: #{offense_count}" if @show_offense_counts
         if COPS[cop_name] && COPS[cop_name].first.new.support_autocorrect?
@@ -91,12 +109,17 @@ module RuboCop
       end
 
       def output_cop_config(output, cfg, cop_name)
+        # 'Enabled' option will be put into file only if exclude
+        # limit is exceeded.
+        cfg_without_enabled = cfg.reject { |key| key == 'Enabled' }
+
         output.puts "#{cop_name}:"
-        cfg.each do |key, value|
+        cfg_without_enabled.each do |key, value|
           value = value[0] if value.is_a?(Array)
           output.puts "  #{key}: #{value}"
         end
-        output_offending_files(output, cfg, cop_name)
+
+        output_offending_files(output, cfg_without_enabled, cop_name)
       end
 
       def output_offending_files(output, cfg, cop_name)

data/lib/rubocop/formatter/html_formatter.rb

@@ -95,18 +95,14 @@ module RuboCop
 
         def highlighted_source_line(offense)
           location = offense.location
-
-          source_line = if location.first_line == location.last_line
-                          location.source_line
-                        else
-                          "#{location.source_line} #{ELLIPSES}"
-                        end
+          source_line = location.source_line
 
           escape(source_line[0...offense.highlighted_area.begin_pos]) +
             "<span class=\"highlight #{offense.severity}\">" +
             escape(offense.highlighted_area.source) +
             '</span>' +
-            escape(source_line[offense.highlighted_area.end_pos..-1])
+            escape(source_line[offense.highlighted_area.end_pos..-1]) +
+            (location.first_line == location.last_line ? '' : " #{ELLIPSES}")
         end
 
         def escape(s)

data/lib/rubocop/result_cache.rb

@@ -41,7 +41,11 @@ module RuboCop
       private
 
       def remove_files(files, dirs, remove_count, verbose)
-        File.delete(*files[0, 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
@@ -60,8 +64,14 @@ module RuboCop
       File.join(root, 'rubocop_cache')
     end
 
+    def self.allow_symlinks_in_cache_location?(config_store)
+      config_store.for('.').for_all_cops['AllowSymlinksInCacheRootDirectory']
+    end
+
     def initialize(file, options, config_store, cache_root = nil)
       cache_root ||= ResultCache.cache_root(config_store)
+      @allow_symlinks_in_cache_location =
+        ResultCache.allow_symlinks_in_cache_location?(config_store)
       @path = File.join(cache_root, rubocop_checksum,
                         relevant_options_digest(options),
                         file_checksum(file, config_store))
@@ -81,9 +91,9 @@ module RuboCop
       FileUtils.mkdir_p(dir)
       preliminary_path = "#{@path}_#{rand(1_000_000_000)}"
       # RuboCop must be in control of where its cached data is stored. A
-      # symbolic link anywhere in the cache directory tree is an indication
-      # that a symlink attack is being waged.
-      return if any_symlink?(dir)
+      # symbolic link anywhere in the cache directory tree can be an
+      # indication that a symlink attack is being waged.
+      return if symlink_protection_triggered?(dir)
 
       File.open(preliminary_path, 'wb') do |f|
         f.write(@cached_data.to_json(offenses))
@@ -98,6 +108,10 @@ module RuboCop
 
     private
 
+    def symlink_protection_triggered?(path)
+      !@allow_symlinks_in_cache_location && any_symlink?(path)
+    end
+
     def any_symlink?(path)
       while path != File.dirname(path)
         if File.symlink?(path)