rubocop 0.35.1 → 0.36.0

data/lib/rubocop/formatter/worst_offenders_formatter.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'pathname'
+
+module RuboCop
+  module Formatter
+    # This formatter displays the list of offensive files, sorted by number of
+    # offenses with the worst offenders first.
+    #
+    # Here's the format:
+    #
+    # 26  this/file/is/really/bad.rb
+    # 3   just/ok.rb
+    # --
+    # 29  Total
+    class WorstOffendersFormatter < BaseFormatter
+      attr_reader :offense_counts
+
+      def started(target_files)
+        super
+        @offense_counts = {}
+      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
+      end
+
+      def finished(_inspected_files)
+        report_summary(@offense_counts)
+      end
+
+      def report_summary(offense_counts)
+        per_file_counts = ordered_offense_counts(offense_counts)
+        total_count = total_offense_count(offense_counts)
+
+        output.puts
+
+        per_file_counts.each do |file_name, count|
+          output.puts "#{count.to_s.ljust(total_count.to_s.length + 2)}" \
+                      "#{file_name}\n"
+        end
+        output.puts '--'
+        output.puts "#{total_count}  Total"
+
+        output.puts
+      end
+
+      def ordered_offense_counts(offense_counts)
+        Hash[offense_counts.sort_by { |k, v| [-v, k] }]
+      end
+
+      def total_offense_count(offense_counts)
+        offense_counts.values.inject(0, :+)
+      end
+    end
+  end
+end

data/lib/rubocop/name_similarity.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  # Common functionality for finding names that are similar to a given name.
+  module NameSimilarity
+    MINIMUM_SIMILARITY_TO_SUGGEST = 0.9
+
+    def find_similar_name(target_name, scope)
+      names = collect_variable_like_names(scope)
+      names.delete(target_name)
+
+      scores = names.each_with_object({}) do |name, hash|
+        score = StringUtil.similarity(target_name, name)
+        hash[name] = score if score >= MINIMUM_SIMILARITY_TO_SUGGEST
+      end
+
+      most_similar_name, _max_score = scores.max_by { |_, score| score }
+      most_similar_name
+    end
+  end
+end

data/lib/rubocop/node_pattern.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 # rubocop:disable Metrics/ClassLength
 # rubocop:disable Metrics/CyclomaticComplexity
@@ -44,20 +45,33 @@ module RuboCop
   #    '(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
-  #                        # ({} is pattern union, [] is intersection)
+  #                        # 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:
   #
@@ -73,9 +87,10 @@ module RuboCop
   # `#prefix_type?` to the AST node class, then 'prefix' will become usable as
   # a pattern.
   #
-  # Also node that if you need a "guard clause" to protect against possible nils
+  # Also note that if you need a "guard clause" to protect against possible nils
   # in a certain place in the AST, you can do it like this: `[!nil <pattern>]`
   #
+  # The compiler code is very simple; don't be afraid to read through it!
   class NodePattern
     # @private
     Invalid = Class.new(StandardError)
@@ -83,15 +98,18 @@ module RuboCop
     # @private
     # Builds Ruby code which implements a pattern
     class Compiler
-      RSYM      = %r{:(?:[\w+-@_*/?!<>~|%^]+|==|\[\]=?)}
-      ID_CHAR   = /[a-zA-Z_]/
-      META_CHAR = /\(|\)|\{|\}|\[|\]|\$\.\.\.|\$|!|\^|\.\.\./
-      TOKEN     = /\G(?:\s+|#{META_CHAR}|#{ID_CHAR}+\??|%\d*|\d+|#{RSYM}|.)/
+      RSYM    = %r{:(?:[\w+@_*/?!<>=~|%^-]+|\[\]=?)}
+      ID_CHAR = /[a-zA-Z_]/
+      META    = /\(|\)|\{|\}|\[|\]|\$\.\.\.|\$|!|\^|\.\.\./
+      NUMBER  = /-?\d+(?:\.\d+)?/
+      TOKEN   =
+        /\G(?:[\s,]+|#{META}|\#?#{ID_CHAR}+[\!\?]?\(?|%\d*|#{NUMBER}|#{RSYM}|.)/
 
       NODE      = /\A#{ID_CHAR}+\Z/
-      PREDICATE = /\A#{ID_CHAR}+\?\Z/
-      LITERAL   = /\A(?:#{RSYM}|\d+|nil)\Z/
+      PREDICATE = /\A#{ID_CHAR}+\?\(?\Z/
       WILDCARD  = /\A_#{ID_CHAR}*\Z/
+      FUNCALL   = /\A\##{ID_CHAR}+[\!\?]?\(?\Z/
+      LITERAL   = /\A(?:#{RSYM}|#{NUMBER}|nil)\Z/
       PARAM     = /\A%\d*\Z/
       CLOSING   = /\A(?:\)|\}|\])\Z/
 
@@ -99,6 +117,7 @@ module RuboCop
 
       def initialize(str, node_var = 'node0')
         @string   = str
+        @root     = node_var
 
         @temps    = 0  # avoid name clashes between temp variables
         @captures = 0  # number of captures seen
@@ -110,12 +129,18 @@ module RuboCop
 
       def run(node_var)
         tokens = @string.scan(TOKEN)
-        tokens.reject! { |token| token =~ /\A\s+\Z/ }
+        tokens.reject! { |token| token =~ /\A[\s,]+\Z/ } # drop whitespace
         @match_code = compile_expr(tokens, node_var, false)
         fail_due_to('unbalanced pattern') unless tokens.empty?
       end
 
       def compile_expr(tokens, cur_node, seq_head)
+        # read a single pattern-matching expression from the token stream,
+        # return Ruby code which performs the corresponding matching operation
+        # on 'cur_node' (which is Ruby code which evaluates to an AST node)
+        #
+        # the 'pattern-matching' expression may be a composite which
+        # contains an arbitrary number of sub-expressions
         token = tokens.shift
         case token
         when '('       then compile_seq(tokens, cur_node, seq_head)
@@ -125,8 +150,9 @@ module RuboCop
         when '$'       then compile_capture(tokens, cur_node, seq_head)
         when '^'       then compile_ascend(tokens, cur_node, seq_head)
         when WILDCARD  then compile_wildcard(cur_node, token[1..-1], seq_head)
+        when FUNCALL   then compile_funcall(tokens, cur_node, token, seq_head)
         when LITERAL   then compile_literal(cur_node, token, seq_head)
-        when PREDICATE then compile_predicate(cur_node, token, seq_head)
+        when PREDICATE then compile_predicate(tokens, cur_node, token, seq_head)
         when NODE      then compile_nodetype(cur_node, token)
         when PARAM     then compile_param(cur_node, token[1..-1], seq_head)
         when CLOSING   then fail_due_to("#{token} in invalid position")
@@ -139,6 +165,10 @@ module RuboCop
         fail_due_to('empty parentheses') if tokens.first == ')'
         fail_due_to('parentheses at sequence head') if seq_head
 
+        # 'cur_node' is a Ruby expression which evaluates to an AST node,
+        # 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)
@@ -155,6 +185,9 @@ module RuboCop
           elsif tokens.first == '$...'
             return compile_capt_ellip(tokens, cur_node, terms, index || 0)
           elsif index.nil?
+            # in 'sequence head' position; some expressions are compiled
+            # differently at 'sequence head' (notably 'node type' expressions)
+            # grep for seq_head to see where it makes a difference
             terms << compile_expr(tokens, cur_node, true)
             index = 0
           else
@@ -210,6 +243,10 @@ module RuboCop
         cur_node = "temp#{@temps}"
 
         terms = []
+        # 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
@@ -242,19 +279,17 @@ module RuboCop
       end
 
       def compile_capture(tokens, cur_node, seq_head)
-        "(#{next_capture} = #{cur_node}#{'.type' if seq_head}; " <<
-          compile_expr(tokens, cur_node, seq_head) <<
-          ')'
+        "(#{next_capture} = #{cur_node}#{'.type' if seq_head}; " \
+          "#{compile_expr(tokens, cur_node, seq_head)})"
       end
 
       def compile_negation(tokens, cur_node, seq_head)
-        '(!' << compile_expr(tokens, cur_node, seq_head) << ')'
+        "(!#{compile_expr(tokens, cur_node, seq_head)})"
       end
 
       def compile_ascend(tokens, cur_node, seq_head)
-        "(#{cur_node}.parent && " <<
-          compile_expr(tokens, "#{cur_node}.parent", seq_head) <<
-          ')'
+        "(#{cur_node}.parent && " \
+          "#{compile_expr(tokens, "#{cur_node}.parent", seq_head)})"
       end
 
       def compile_wildcard(cur_node, name, seq_head)
@@ -275,8 +310,27 @@ module RuboCop
         "(#{cur_node}#{'.type' if seq_head} == #{literal})"
       end
 
-      def compile_predicate(cur_node, predicate, seq_head)
-        "(#{cur_node}#{'.type' if seq_head}.#{predicate})"
+      def compile_predicate(tokens, cur_node, predicate, seq_head)
+        if predicate.end_with?('(') # is there an arglist?
+          args = compile_args(tokens)
+          predicate = predicate[0..-2] # drop the trailing (
+          "(#{cur_node}#{'.type' if seq_head}.#{predicate}(#{args.join(',')}))"
+        else
+          "(#{cur_node}#{'.type' if seq_head}.#{predicate})"
+        end
+      end
+
+      def compile_funcall(tokens, cur_node, method, seq_head)
+        # call a method in the context which this pattern-matching
+        # code is used in. pass target value as an argument
+        method = method[1..-1] # drop the leading #
+        if method.end_with?('(') # is there an arglist?
+          args = compile_args(tokens)
+          method = method[0..-2] # drop the trailing (
+          "(#{method}(#{cur_node}#{'.type' if seq_head}),#{args.join(',')})"
+        else
+          "(#{method}(#{cur_node}#{'.type' if seq_head}))"
+        end
       end
 
       def compile_nodetype(cur_node, type)
@@ -284,17 +338,42 @@ module RuboCop
       end
 
       def compile_param(cur_node, number, seq_head)
-        number = number.empty? ? 1 : Integer(number)
-        @params = number if number > @params
-        "(#{cur_node}#{'.type' if seq_head} == param#{number})"
+        "(#{cur_node}#{'.type' if seq_head} == #{get_param(number)})"
+      end
+
+      def compile_args(tokens)
+        args = []
+        args << compile_arg(tokens.shift) until tokens.first == ')'
+        tokens.shift # drop the )
+        args
+      end
+
+      def compile_arg(token)
+        case token
+        when WILDCARD  then
+          name   = token[1..-1]
+          number = @unify[name] || fail_due_to('invalid in arglist: ' + token)
+          "temp#{number}"
+        when LITERAL   then token
+        when PARAM     then get_param(token[1..-1])
+        when CLOSING   then fail_due_to("#{token} in invalid position")
+        when nil       then fail_due_to('pattern ended prematurely')
+        else fail_due_to("invalid token in arglist: #{token.inspect}")
+        end
       end
 
       def next_capture
         "capture#{@captures += 1}"
       end
 
+      def get_param(number)
+        number = number.empty? ? 1 : Integer(number)
+        @params = number if number > @params
+        number.zero? ? @root : "param#{number}"
+      end
+
       def join_terms(init, terms, operator)
-        '(' << init << ';' << terms.join(operator) << ')'
+        "(#{init};#{terms.join(operator)})"
       end
 
       def emit_capture_list
@@ -315,9 +394,9 @@ module RuboCop
         (1..@params).map { |n| "param#{n}" }.join(',')
       end
 
-      def emit_trailing_param_list
+      def emit_trailing_params
         params = emit_param_list
-        params.empty? ? '' : ',' << params
+        params.empty? ? '' : ",#{params}"
       end
 
       def emit_method_code
@@ -343,9 +422,12 @@ module RuboCop
       # return the captures, or `true` if there were none.
       def def_node_matcher(method_name, pattern_str)
         compiler = RuboCop::NodePattern::Compiler.new(pattern_str, 'node')
-        src = "def #{method_name}(node" << compiler.emit_trailing_param_list <<
-              ');' << compiler.emit_method_code << ';end'
-        class_eval(src)
+        src = "def #{method_name}(node" \
+              "#{compiler.emit_trailing_params});" \
+              "#{compiler.emit_method_code};end"
+
+        file, lineno = *caller.first.split(':')
+        class_eval(src, file, lineno.to_i)
       end
 
       # Define a method which recurses over the descendants of an AST node,
@@ -363,27 +445,36 @@ module RuboCop
           yieldval = compiler.emit_capture_list
           yieldval = 'node' if yieldval.empty?
           on_match = "yield(#{yieldval})"
-          prelude = "return enum_for(:#{method_name},node0) unless block_given?"
+          prelude = "return enum_for(:#{method_name}, node0" \
+          "#{compiler.emit_trailing_params}) unless block_given?"
         end
-        src = <<-END
-          def #{method_name}(node0#{compiler.emit_trailing_param_list})
+
+        src = node_search_body(method_name, compiler.emit_trailing_params,
+                               prelude, compiler.match_code, on_match)
+        filename, lineno = *caller.first.split(':')
+        class_eval(src, filename, lineno.to_i)
+      end
+
+      def node_search_body(method_name, trailing_params, prelude, match_code,
+                           on_match)
+        <<-END
+          def #{method_name}(node0#{trailing_params})
             #{prelude}
             node0.each_node do |node|
-              if #{compiler.match_code}
+              if #{match_code}
                 #{on_match}
               end
             end
             nil
           end
         END
-        class_eval(src)
       end
     end
 
     def initialize(str)
       compiler = Compiler.new(str)
-      src = 'def match(node0' << compiler.emit_trailing_param_list << ');' <<
-            compiler.emit_method_code << 'end'
+      src = "def match(node0#{compiler.emit_trailing_params});" \
+            "#{compiler.emit_method_code}end"
       instance_eval(src)
     end
   end

data/lib/rubocop/options.rb

@@ -1,12 +1,12 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 require 'optparse'
 
 module RuboCop
   # This class handles command line options.
   class Options
-    DEFAULT_FORMATTER = 'progress'
-    EXITING_OPTIONS = [:version, :verbose_version, :show_cops]
+    EXITING_OPTIONS = [:version, :verbose_version, :show_cops].freeze
     DEFAULT_MAXIMUM_EXCLUSION_ITEMS = 15
 
     def initialize
@@ -70,17 +70,17 @@ module RuboCop
     def add_configuration_options(opts, args)
       option(opts, '-c', '--config FILE')
 
-      option(opts, '--auto-gen-config') do
-        @options[:formatters] = [[DEFAULT_FORMATTER],
-                                 [Formatter::DisabledConfigFormatter,
-                                  ConfigLoader::AUTO_GENERATED_FILE]]
-      end
+      option(opts, '--auto-gen-config')
 
       option(opts, '--exclude-limit COUNT') do
         @validator.validate_exclude_limit_option(args)
       end
 
       option(opts, '--force-exclusion')
+
+      option(opts, '--no-offense-counts') do
+        @options[:no_offense_counts] = true
+      end
     end
 
     def add_formatting_options(opts)
@@ -90,8 +90,11 @@ module RuboCop
       end
 
       option(opts, '-o', '--out FILE') do |path|
-        @options[:formatters] ||= [[DEFAULT_FORMATTER]]
-        @options[:formatters].last << path
+        if @options[:formatters]
+          @options[:formatters].last << path
+        else
+          @options[:output_path] = path
+        end
       end
     end
 
@@ -124,8 +127,7 @@ module RuboCop
       end
       option(opts, '-a', '--auto-correct')
 
-      @options[:color] = true
-      option(opts, '-n', '--no-color') { @options[:color] = false }
+      option(opts, '-n', '--[no-]color') { |c| @options[:color] = c }
 
       option(opts, '-v', '--version')
       option(opts, '-V', '--verbose-version')
@@ -151,16 +153,12 @@ module RuboCop
     # e.g. [..., '--auto-correct', ...] to :auto_correct.
     def long_opt_symbol(args)
       long_opt = args.find { |arg| arg.start_with?('--') }
-      long_opt[2..-1].sub(/ .*/, '').tr('-', '_').to_sym
+      long_opt[2..-1].sub(/ .*/, '').tr('-', '_').gsub(/[\[\]]/, '').to_sym
     end
   end
 
-  # Validates option arguments and the options' compatibilty with each other.
+  # Validates option arguments and the options' compatibility with each other.
   class OptionsValidator
-    def initialize(options)
-      @options = options
-    end
-
     # Cop name validation must be done later than option parsing, so it's not
     # called from within Options.
     def self.validate_cop_list(names)
@@ -176,6 +174,10 @@ module RuboCop
       end
     end
 
+    def initialize(options)
+      @options = options
+    end
+
     def validate_compatibility
       if @options.key?(:only) &&
          (@options[:only] & %w(Lint/UnneededDisable UnneededDisable)).any?
@@ -188,6 +190,10 @@ module RuboCop
       if @options.key?(:cache) && !%w(true false).include?(@options[:cache])
         fail ArgumentError, '-C/--cache argument must be true or false'
       end
+      if @options.key?(:no_offense_counts) && !@options.key?(:auto_gen_config)
+        fail ArgumentError, '--no-offense-counts can only be used together ' \
+                            'with --auto-gen-config.'
+      end
       return if (incompat = @options.keys & Options::EXITING_OPTIONS).size <= 1
       fail ArgumentError, "Incompatible cli options: #{incompat.inspect}"
     end
@@ -220,6 +226,8 @@ module RuboCop
       config:               'Specify configuration file.',
       auto_gen_config:     ['Generate a configuration file acting as a',
                             'TODO list.'],
+      no_offense_counts:   ['Do not include offense counts in configuration',
+                            'file generated by --auto-gen-config.'],
       exclude_limit:       ['Used together with --auto-gen-config to',
                             'set the limit for how many Exclude',
                             "properties to generate. Default is #{MAX_EXCL}."],
@@ -239,6 +247,7 @@ module RuboCop
                             '  [h]tml',
                             '  [fi]les',
                             '  [o]ffenses',
+                            '  [w]orst',
                             '  custom formatter class name'],
       out:                 ['Write output to a file instead of STDOUT.',
                             'This option applies to the previously',
@@ -263,11 +272,11 @@ module RuboCop
       lint:                 'Run only lint cops.',
       list_target_files:    'List all files RuboCop will inspect.',
       auto_correct:         'Auto-correct offenses.',
-      no_color:             'Disable color output.',
+      no_color:             'Force color output on or off.',
       version:              'Display version.',
       verbose_version:      'Display verbose version.',
       stdin:                ['Pipe source from STDIN.',
                              'This is useful for editor integration.']
-    }
+    }.freeze
   end
 end