rubocop 0.42.0 → 0.43.0

data/lib/rubocop/formatter/worst_offenders_formatter.rb

@@ -23,10 +23,10 @@ module RuboCop
       end
 
       def file_finished(file, offenses)
-        unless offenses.empty?
-          path = Pathname.new(file).relative_path_from(Pathname.new(Dir.pwd))
-          @offense_counts[path] = offenses.size
-        end
+        return if offenses.empty?
+
+        path = Pathname.new(file).relative_path_from(Pathname.new(Dir.pwd))
+        @offense_counts[path] = offenses.size
       end
 
       def finished(_inspected_files)

data/lib/rubocop/node_pattern.rb

@@ -171,11 +171,11 @@ module RuboCop
         # but we don't know how expensive it is
         # to be safe, cache the node in a temp variable and then use the
         # temp variable as 'cur_node'
-        init = "temp#{@temps += 1} = #{cur_node}"
-        cur_node = "temp#{@temps}"
-        terms = compile_seq_terms(tokens, cur_node)
+        with_temp_node(cur_node) do |init, temp_node|
+          terms = compile_seq_terms(tokens, temp_node)
 
-        join_terms(init, terms, ' && ')
+          join_terms(init, terms, ' && ')
+        end
       end
 
       def compile_seq_terms(tokens, cur_node)
@@ -255,43 +255,60 @@ module RuboCop
       def compile_union(tokens, cur_node, seq_head)
         fail_due_to('empty union') if tokens.first == '}'
 
-        init = "temp#{@temps += 1} = #{cur_node}"
-        cur_node = "temp#{@temps}"
+        with_temp_node(cur_node) do |init, temp_node|
+          terms = union_terms(tokens, temp_node, seq_head)
+          join_terms(init, terms, ' || ')
+        end
+      end
 
-        terms = []
+      def union_terms(tokens, temp_node, seq_head)
         # we need to ensure that each branch of the {} contains the same
         # number of captures (since only one branch of the {} can actually
         # match, the same variables are used to hold the captures for each
         # branch)
-        captures_before = @captures
-        terms << compile_expr(tokens, cur_node, seq_head)
-        captures_after = @captures
-
-        until tokens.first == '}'
-          @captures = captures_before
-          terms << compile_expr(tokens, cur_node, seq_head)
-          if @captures != captures_after
-            fail_due_to('each branch of {} must have same # of captures')
+        compile_expr_with_captures(tokens,
+                                   temp_node, seq_head) do |term, before, after|
+          terms = [term]
+          until tokens.first == '}'
+            terms << compile_expr_with_capture_check(tokens, temp_node,
+                                                     seq_head, before, after)
           end
+          tokens.shift
+
+          terms
         end
-        tokens.shift
+      end
 
-        join_terms(init, terms, ' || ')
+      def compile_expr_with_captures(tokens, temp_node, seq_head)
+        captures_before = @captures
+        expr = compile_expr(tokens, temp_node, seq_head)
+
+        yield expr, captures_before, @captures
+      end
+
+      def compile_expr_with_capture_check(tokens, temp_node, seq_head, before,
+                                          after)
+        @captures = before
+        expr = compile_expr(tokens, temp_node, seq_head)
+        if @captures != after
+          fail_due_to('each branch of {} must have same # of captures')
+        end
+
+        expr
       end
 
       def compile_intersect(tokens, cur_node, seq_head)
         fail_due_to('empty intersection') if tokens.first == ']'
 
-        init = "temp#{@temps += 1} = #{cur_node}"
-        cur_node = "temp#{@temps}"
+        with_temp_node(cur_node) do |init, temp_node|
+          terms = []
+          until tokens.first == ']'
+            terms << compile_expr(tokens, temp_node, seq_head)
+          end
+          tokens.shift
 
-        terms = []
-        until tokens.first == ']'
-          terms << compile_expr(tokens, cur_node, seq_head)
+          join_terms(init, terms, ' && ')
         end
-        tokens.shift
-
-        join_terms(init, terms, ' && ')
       end
 
       def compile_capture(tokens, cur_node, seq_head)
@@ -317,7 +334,7 @@ module RuboCop
           # in a temp. check if this value matches the one stored in the temp
           "(#{cur_node}#{'.type' if seq_head} == temp#{@unify[name]})"
         else
-          n = @unify[name] = (@temps += 1)
+          n = @unify[name] = next_temp_value
           "(temp#{n} = #{cur_node}#{'.type' if seq_head}; true)"
         end
       end
@@ -425,6 +442,20 @@ module RuboCop
       def fail_due_to(message)
         raise Invalid, "Couldn't compile due to #{message}. Pattern: #{@string}"
       end
+
+      def with_temp_node(cur_node)
+        with_temp_variable do |temp_var|
+          yield "#{temp_var} = #{cur_node}", temp_var
+        end
+      end
+
+      def with_temp_variable
+        yield "temp#{next_temp_value}"
+      end
+
+      def next_temp_value
+        @temps += 1
+      end
     end
 
     # Helpers for defining methods based on a pattern string
@@ -454,20 +485,33 @@ 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(':')
+
         if method_name.to_s.end_with?('?')
-          on_match = 'return true'
-          prelude = ''
+          node_search_first(method_name, compiler, called_from)
         else
-          yieldval = compiler.emit_capture_list
-          yieldval = 'node' if yieldval.empty?
-          on_match = "yield(#{yieldval})"
-          prelude = "return enum_for(:#{method_name}, node0" \
-          "#{compiler.emit_trailing_params}) unless block_given?"
+          node_search_all(method_name, compiler, called_from)
         end
+      end
+
+      def node_search_first(method_name, compiler, called_from)
+        node_search(method_name, compiler, 'return true', '', called_from)
+      end
+
+      def node_search_all(method_name, compiler, called_from)
+        yieldval = compiler.emit_capture_list
+        yieldval = 'node' if yieldval.empty?
+        prelude = "return enum_for(:#{method_name}, node0" \
+                  "#{compiler.emit_trailing_params}) unless block_given?"
+
+        node_search(method_name, compiler, "yield(#{yieldval})", prelude,
+                    called_from)
+      end
 
+      def node_search(method_name, compiler, on_match, prelude, called_from)
         src = node_search_body(method_name, compiler.emit_trailing_params,
                                prelude, compiler.match_code, on_match)
-        filename, lineno = *caller.first.split(':')
+        filename, lineno = *called_from
         class_eval(src, filename, lineno.to_i)
       end
 

data/lib/rubocop/options.rb

@@ -34,7 +34,7 @@ module RuboCop
     private
 
     def args_from_file
-      if File.exist?('.rubocop')
+      if File.exist?('.rubocop') && !File.directory?('.rubocop')
         IO.readlines('.rubocop').map(&:strip)
       else
         []
@@ -127,7 +127,7 @@ module RuboCop
       end
     end
 
-    def add_boolean_flags(opts)
+    def add_boolean_flags(opts) # rubocop:disable Metrics/MethodLength
       option(opts, '-F', '--fail-fast')
       option(opts, '-C', '--cache FLAG')
       option(opts, '-d', '--debug')
@@ -145,7 +145,7 @@ module RuboCop
 
       option(opts, '-v', '--version')
       option(opts, '-V', '--verbose-version')
-      option(opts, '-s', '--stdin') { @options[:stdin] = $stdin.read }
+      option(opts, '-s', '--stdin') { @options[:stdin] = $stdin.binmode.read }
     end
 
     def add_list_options(opts)
@@ -192,7 +192,7 @@ module RuboCop
       @options = options
     end
 
-    def validate_compatibility
+    def validate_compatibility # rubocop:disable Metrics/MethodLength
       if only_includes_unneeded_disable?
         raise ArgumentError, 'Lint/UnneededDisable can not be used with --only.'
       end

data/lib/rubocop/processed_source.rb

@@ -14,7 +14,7 @@ module RuboCop
                 :parser_error, :raw_source, :ruby_version
 
     def self.from_file(path, ruby_version)
-      file = File.read(path)
+      file = File.read(path, mode: 'rb')
       new(file, ruby_version, path)
     rescue Errno::ENOENT
       raise RuboCop::Error, "No such file or directory: #{path}"
@@ -91,16 +91,20 @@ module RuboCop
         return
       end
 
-      parser = create_parser(ruby_version)
+      @ast, @comments, @tokens = tokenize(create_parser(ruby_version))
+    end
 
+    def tokenize(parser)
       begin
-        @ast, @comments, tokens = parser.tokenize(@buffer)
-        @ast.complete! if @ast
+        ast, comments, tokens = parser.tokenize(@buffer)
+        ast.complete! if ast
       rescue Parser::SyntaxError # rubocop:disable Lint/HandleExceptions
         # All errors are in diagnostics. No need to handle exception.
       end
 
-      @tokens = tokens.map { |t| Token.from_parser_token(t) } if tokens
+      tokens = tokens.map { |t| Token.from_parser_token(t) } if tokens
+
+      [ast, comments, tokens]
     end
 
     def parser_class(ruby_version) # rubocop:disable Metrics/MethodLength

data/lib/rubocop/remote_config.rb

@@ -17,6 +17,18 @@ module RuboCop
     def file
       return cache_path unless cache_path_expired?
 
+      request do |response|
+        open cache_path, 'w' do |io|
+          io.write response.body
+        end
+      end
+
+      cache_path
+    end
+
+    private
+
+    def request
       http = Net::HTTP.new(@uri.hostname, @uri.port)
       http.use_ssl = true if @uri.instance_of? URI::HTTPS
 
@@ -24,19 +36,11 @@ module RuboCop
       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
+      response = http.request(request)
+      yield response if response.is_a?(Net::HTTPSuccess)
     end
 
-    private
-
     def cache_path
       File.expand_path(".rubocop-#{cache_name_from_uri}", @base_dir)
     end

data/lib/rubocop/result_cache.rb

@@ -24,8 +24,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
@@ -35,10 +47,6 @@ module RuboCop
         sorted = files.sort_by { |path| File.mtime(path) }
         remove_files(sorted, dirs, remove_count, verbose)
       end
-    end
-
-    class << self
-      private
 
       def remove_files(files, dirs, remove_count, verbose)
         # Batch file deletions, deleting over 130,000+ files will crash

data/lib/rubocop/runner.rb

@@ -16,6 +16,8 @@ module RuboCop
       end
     end
 
+    MAX_ITERATIONS = 200
+
     attr_reader :errors, :warnings, :aborting
     alias aborting? aborting
 
@@ -50,25 +52,32 @@ module RuboCop
 
     def inspect_files(files)
       inspected_files = []
-      all_passed = true
 
       formatter_set.started(files)
 
-      files.each do |file|
-        break if aborting?
-        offenses = process_file(file)
-        all_passed = false if offenses.any? { |o| considered_failure?(o) }
-        inspected_files << file
-        break if @options[:fail_fast] && !all_passed
-      end
-
-      all_passed
+      each_inspected_file(files) { |file| inspected_files << file }
     ensure
       ResultCache.cleanup(@config_store, @options[:debug]) if cached_run?
       formatter_set.finished(inspected_files.freeze)
       formatter_set.close_output_files
     end
 
+    def each_inspected_file(files)
+      files.reduce(true) do |all_passed, file|
+        break false if aborting?
+
+        offenses = process_file(file)
+        yield file
+
+        if offenses.any? { |o| considered_failure?(o) }
+          break false if @options[:fail_fast]
+          next false
+        end
+
+        all_passed
+      end
+    end
+
     def list_files(paths)
       paths.each do |path|
         puts PathUtil.relative_path(path)
@@ -108,10 +117,7 @@ module RuboCop
     end
 
     def add_unneeded_disables(file, offenses, source)
-      if source.disabled_line_ranges.any? &&
-         # Don't check unneeded disable if --only or --except option is
-         # given, because these options override configuration.
-         (@options[:except] || []).empty? && (@options[:only] || []).empty?
+      if check_for_unneded_disables?(source)
         config = @config_store.for(file)
         if config.cop_enabled?(Cop::Lint::UnneededDisable)
           cop = Cop::Lint::UnneededDisable.new(config, @options)
@@ -127,6 +133,14 @@ module RuboCop
       offenses.sort.reject(&:disabled?).freeze
     end
 
+    def check_for_unneded_disables?(source)
+      !source.disabled_line_ranges.empty? && !filtered_run?
+    end
+
+    def filtered_run?
+      @options[:except] || @options[:only]
+    end
+
     def autocorrect_unneeded_disables(source, cop)
       cop.processed_source = source
       Cop::Team.new([], nil, @options).autocorrect(source.buffer, [cop])
@@ -166,27 +180,11 @@ module RuboCop
     def do_inspection_loop(file, processed_source)
       offenses = []
 
-      # Keep track of the state of the source. If a cop modifies the source
-      # and another cop undoes it producing identical source we have an
-      # infinite loop.
-      @processed_sources = []
-
-      # It is also possible for a cop to keep adding indefinitely to a file,
-      # making it bigger and bigger. If the inspection loop runs for an
-      # excessively high number of iterations, this is likely happening.
-      @iterations = 0
-
       # When running with --auto-correct, we need to inspect the file (which
       # includes writing a corrected version of it) until no more corrections
       # are made. This is because automatic corrections can introduce new
       # offenses. In the normal case the loop is only executed once.
-      loop do
-        check_for_infinite_loop(processed_source, offenses)
-
-        if (@iterations += 1) > 200
-          raise InfiniteCorrectionLoop.new(processed_source.path, offenses)
-        end
-
+      iterate_until_no_changes(processed_source, offenses) do
         # The offenses that couldn't be corrected will be found again so we
         # only keep the corrected ones in order to avoid duplicate reporting.
         offenses.select!(&:corrected?)
@@ -204,6 +202,29 @@ module RuboCop
       [processed_source, offenses]
     end
 
+    def iterate_until_no_changes(source, offenses)
+      # Keep track of the state of the source. If a cop modifies the source
+      # and another cop undoes it producing identical source we have an
+      # infinite loop.
+      @processed_sources = []
+
+      # It is also possible for a cop to keep adding indefinitely to a file,
+      # making it bigger and bigger. If the inspection loop runs for an
+      # excessively high number of iterations, this is likely happening.
+      iterations = 0
+
+      loop do
+        check_for_infinite_loop(source, offenses)
+
+        if (iterations += 1) > MAX_ITERATIONS
+          raise InfiniteCorrectionLoop.new(source.path, offenses)
+        end
+
+        source = yield
+        break unless source
+      end
+    end
+
     # Check whether a run created source identical to a previous run, which
     # means that we definitely have an infinite loop.
     def check_for_infinite_loop(processed_source, offenses)
@@ -254,9 +275,9 @@ module RuboCop
 
     def filter_cop_classes(cop_classes, config)
       # use only cops that link to a style guide if requested
-      if style_guide_cops_only?(config)
-        cop_classes.select! { |cop| config.for_cop(cop)['StyleGuide'] }
-      end
+      return unless style_guide_cops_only?(config)
+
+      cop_classes.select! { |cop| config.for_cop(cop)['StyleGuide'] }
     end
 
     def style_guide_cops_only?(config)