rubocop 0.39.0 → 0.40.0

data/lib/rubocop/cli.rb

@@ -97,6 +97,8 @@ module RuboCop
     end
 
     def print_available_cops
+      # Load the configs so the require()s are done for custom cops
+      @config_store.for(Dir.pwd)
       cops = Cop::Cop.all
       show_all = @options[:show_cops].empty?
 
@@ -108,25 +110,39 @@ module RuboCop
     end
 
     def print_cops_of_type(cops, type, show_all)
-      cops_of_this_type = cops.with_type(type).sort_by!(&:cop_name)
+      selected_cops = if show_all
+                        cops_of_type(cops, type)
+                      else
+                        selected_cops_of_type(cops, type)
+                      end
 
       if show_all
-        puts "# Type '#{type.to_s.capitalize}' (#{cops_of_this_type.size}):"
-      end
-
-      selected_cops = cops_of_this_type.select do |cop|
-        show_all || @options[:show_cops].include?(cop.cop_name)
+        puts "# Type '#{type.to_s.capitalize}' (#{selected_cops.size}):"
       end
 
       selected_cops.each do |cop|
         puts '# Supports --auto-correct' if cop.new.support_autocorrect?
         puts "#{cop.cop_name}:"
-        cnf = @config_store.for(Dir.pwd).for_cop(cop)
-        puts cnf.to_yaml.lines.to_a.butfirst.map { |line| '  ' + line }
+        puts config_lines(cop)
         puts
       end
     end
 
+    def selected_cops_of_type(cops, type)
+      cops_of_type(cops, type).select do |cop|
+        @options[:show_cops].include?(cop.cop_name)
+      end
+    end
+
+    def cops_of_type(cops, type)
+      cops.with_type(type).sort_by!(&:cop_name)
+    end
+
+    def config_lines(cop)
+      cnf = @config_store.for(Dir.pwd).for_cop(cop)
+      cnf.to_yaml.lines.to_a.butfirst.map { |line| '  ' + line }
+    end
+
     def display_warning_summary(warnings)
       return if warnings.empty?
 

data/lib/rubocop/config.rb

@@ -146,8 +146,8 @@ module RuboCop
       absolute_file_path = File.expand_path(file)
 
       patterns_to_include.any? do |pattern|
-        match_path?(pattern, relative_file_path, loaded_path) ||
-          match_path?(pattern, absolute_file_path, loaded_path)
+        match_path?(pattern, relative_file_path) ||
+          match_path?(pattern, absolute_file_path)
       end
     end
 
@@ -162,7 +162,7 @@ module RuboCop
     def file_to_exclude?(file)
       file = File.expand_path(file)
       patterns_to_exclude.any? do |pattern|
-        match_path?(pattern, file, loaded_path)
+        match_path?(pattern, file)
       end
     end
 

data/lib/rubocop/config_loader.rb

@@ -73,7 +73,6 @@ module RuboCop
 
             if auto_gen_config?
               next if f.include?(AUTO_GENERATED_FILE)
-              old_auto_config_file_warning if f.include?('rubocop-todo.yml')
             end
 
             print 'Inheriting ' if debug?
@@ -193,12 +192,6 @@ module RuboCop
         dirs_to_search << Dir.home if ENV.key? 'HOME'
         dirs_to_search
       end
-
-      def old_auto_config_file_warning
-        raise RuboCop::Error,
-              'rubocop-todo.yml is obsolete; it must be called' \
-              " #{AUTO_GENERATED_FILE} instead"
-      end
     end
   end
 end

data/lib/rubocop/cop/cop.rb

@@ -248,11 +248,11 @@ module RuboCop
         path = nil
         patterns.any? do |pattern|
           # Try to match the absolute path, as Exclude properties are absolute.
-          next true if match_path?(pattern, file, config.loaded_path)
+          next true if match_path?(pattern, file)
 
           # Try with relative path.
           path ||= config.path_relative_to_config(file)
-          match_path?(pattern, path, config.loaded_path)
+          match_path?(pattern, path)
         end
       end
 

data/lib/rubocop/cop/lint/condition_position.rb

@@ -14,8 +14,10 @@ module RuboCop
       #     do_something
       #   end
       class ConditionPosition < Cop
+        include IfNode
+
         def on_if(node)
-          return if node.loc.respond_to?(:question)
+          return if ternary?(node)
 
           check(node)
         end

data/lib/rubocop/cop/lint/else_layout.rb

@@ -16,9 +16,10 @@ module RuboCop
       #     do_that
       #   end
       class ElseLayout < Cop
+        include IfNode
+
         def on_if(node)
-          # ignore ternary ops
-          return if node.loc.respond_to?(:question)
+          return if ternary?(node)
           # ignore modifier ops & elsif nodes
           return unless node.loc.end
 

data/lib/rubocop/cop/lint/end_alignment.rb

@@ -45,7 +45,7 @@ module RuboCop
         end
 
         def on_if(node)
-          check_other_alignment(node) unless ternary_op?(node)
+          check_other_alignment(node) unless ternary?(node)
         end
 
         def on_while(node)
@@ -69,7 +69,7 @@ module RuboCop
           # we check if it's an if/unless/while/until.
           return unless (rhs = first_part_of_call_chain(rhs))
           return unless [:if, :while, :until, :case].include?(rhs.type)
-          return if ternary_op?(rhs)
+          return if ternary?(rhs)
 
           check_asgn_alignment(node, rhs)
         end

data/lib/rubocop/cop/lint/nested_method_definition.rb

@@ -22,14 +22,6 @@ module RuboCop
         MSG = 'Method definitions must not be nested. ' \
               'Use `lambda` instead.'.freeze
 
-        def_node_matcher :eval_call?, <<-PATTERN
-          (block (send _ {:instance_eval :class_eval :module_eval} ...) ...)
-        PATTERN
-
-        def_node_matcher :class_or_module_new_call?, <<-PATTERN
-          (block (send (const nil {:Class :Module}) :new ...) ...)
-        PATTERN
-
         def on_method_def(node, _method_name, _args, _body)
           find_nested_defs(node) do |nested_def_node|
             add_offense(nested_def_node, :expression)
@@ -44,11 +36,25 @@ module RuboCop
               subject, = *child
               next if subject.lvar_type?
               yield child
-            elsif !(eval_call?(child) || class_or_module_new_call?(child))
+            elsif !ignored_child?(child)
               find_nested_defs(child, &block)
             end
           end
         end
+
+        private
+
+        def ignored_child?(child)
+          eval_call?(child) || class_or_module_or_struct_new_call?(child)
+        end
+
+        def_node_matcher :eval_call?, <<-PATTERN
+          (block (send _ {:instance_eval :class_eval :module_eval} ...) ...)
+        PATTERN
+
+        def_node_matcher :class_or_module_or_struct_new_call?, <<-PATTERN
+          (block (send (const nil {:Class :Module :Struct}) :new ...) ...)
+        PATTERN
       end
     end
   end

data/lib/rubocop/cop/lint/require_parentheses.rb

@@ -30,7 +30,7 @@ module RuboCop
           return if parentheses?(node)
           return if args.empty?
 
-          if ternary_op?(args.first)
+          if ternary?(args.first)
             check_ternary(args.first, node)
           elsif predicate?(method_name)
             # We're only checking predicate methods. There would be false

data/lib/rubocop/cop/lint/unused_block_argument.rb

@@ -16,6 +16,8 @@ module RuboCop
 
         def check_argument(variable)
           return unless variable.block_argument?
+          return if variable.keyword_argument? &&
+                    cop_config && cop_config['AllowUnusedKeywordArguments']
 
           if cop_config['IgnoreEmptyBlocks']
             _send, _args, body = *variable.scope.node

data/lib/rubocop/cop/lint/useless_access_modifier.rb

@@ -4,35 +4,61 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for redundant access modifiers, including those with
-      # no code, those which are repeated, and leading `public` modifiers in
-      # a class or module body.
+      # This cop checks for redundant access modifiers, including those with no
+      # code, those which are repeated, and leading `public` modifiers in a
+      # class or module body. Conditionally-defined methods are considered as
+      # always being defined, and thus access modifiers guarding such methods
+      # are not redundant.
       #
       # @example
       #
       #   class Foo
-      #     public # this is redundant
+      #     public # this is redundant (default access is public)
       #
       #     def method
       #     end
       #
-      #     private # this is not redundant
+      #     private # this is not redundant (a method is defined)
       #     def method2
       #     end
       #
-      #     private # this is redundant
+      #     private # this is redundant (no following methods are defined)
+      #   end
+      #
+      # @example
+      #
+      #   class Foo
+      #     # The following is not redundant (conditionally defined methods are
+      #     # considered as always defining a method)
+      #     private
+      #
+      #     if condition?
+      #       def method
+      #       end
+      #     end
+      #
+      #     protected # this is not redundant (method is defined)
+      #
+      #     define_method(:method2) do
+      #     end
+      #
+      #     protected # this is redundant (repeated from previous modifier)
+      #
+      #     [1,2,3].each do |i|
+      #       define_method("foo#{i}") do
+      #       end
+      #     end
+      #
+      #     # The following is redundant (methods defined on the class'
+      #     # singleton class are not affected by the public modifier)
+      #     public
+      #
+      #     def self.method3
+      #     end
       #   end
       class UselessAccessModifier < Cop
         MSG = 'Useless `%s` access modifier.'.freeze
 
-        def_node_matcher :access_modifier, <<-PATTERN
-          (send nil ${:public :protected :private})
-        PATTERN
-
-        def_node_matcher :method_definition?, <<-PATTERN
-          {def (send nil {:attr :attr_reader :attr_writer :attr_accessor} ...)}
-        PATTERN
-
         def on_class(node)
           check_node(node.children[2]) # class body
         end
@@ -41,10 +67,37 @@ module RuboCop
           check_node(node.children[1]) # module body
         end
 
+        def on_block(node)
+          return unless class_or_instance_eval?(node)
+
+          check_node(node.children[2]) # block body
+        end
+
+        def on_sclass(node)
+          check_node(node.children[1]) # singleton class body
+        end
+
         private
 
+        def_node_matcher :access_modifier, <<-PATTERN
+          (send nil ${:public :protected :private})
+        PATTERN
+
+        def_node_matcher :static_method_definition?, <<-PATTERN
+          {def (send nil {:attr :attr_reader :attr_writer :attr_accessor} ...)}
+        PATTERN
+
+        def_node_matcher :dynamic_method_definition?, <<-PATTERN
+          {(send nil :define_method ...) (block (send nil :define_method ...) ...)}
+        PATTERN
+
+        def_node_matcher :class_or_instance_eval?, <<-PATTERN
+          (block (send _ {:class_eval :instance_eval}) ...)
+        PATTERN
+
         def check_node(node)
           return if node.nil?
+
           if node.begin_type?
             check_scope(node)
           elsif (vis = access_modifier(node))
@@ -52,9 +105,13 @@ module RuboCop
           end
         end
 
-        def check_scope(node, cur_vis = :public)
-          unused = nil
+        def check_scope(node)
+          cur_vis, unused = check_child_nodes(node, nil, :public)
+
+          add_offense(unused, :expression, format(MSG, cur_vis)) if unused
+        end
 
+        def check_child_nodes(node, unused, cur_vis)
           node.child_nodes.each do |child|
             if (new_vis = access_modifier(child))
               # does this modifier just repeat the existing visibility?
@@ -70,15 +127,24 @@ module RuboCop
               cur_vis = new_vis
             elsif method_definition?(child)
               unused = nil
-            elsif child.kwbegin_type? || child.send_type?
-              cur_vis, unused = check_scope(child, cur_vis)
+            elsif start_of_new_scope?(child)
+              check_scope(child)
+            elsif !child.defs_type?
+              cur_vis, unused = check_child_nodes(child, unused, cur_vis)
             end
           end
 
-          add_offense(unused, :expression, format(MSG, cur_vis)) if unused
-
           [cur_vis, unused]
         end
+
+        def method_definition?(child)
+          static_method_definition?(child) || dynamic_method_definition?(child)
+        end
+
+        def start_of_new_scope?(child)
+          child.module_type? || child.class_type? ||
+            child.sclass_type? || class_or_instance_eval?(child)
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/useless_array_splat.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for unncessary array splats.
+      #
+      # @example
+      #
+      # # bad:
+      #
+      # a, b = *[1, 2, 3]
+      #
+      # # good:
+      #
+      # a, b = [1, 2, 3]
+      #
+      # # bad:
+      #
+      # a = *[1, 2, 3]
+      #
+      # # good:
+      #
+      # a = [1, 2, 3]
+      class UselessArraySplat < Cop
+        MSG = 'Unnecessary array splat.'.freeze
+        ARRAY_NEW_PATTERN = '(send (const nil :Array) :new ...)'.freeze
+
+        %w(m lv cv iv c gv).each do |var_type|
+          define_method("on_#{var_type}asgn") do |node|
+            *, rhs = *node
+
+            return unless rhs.is_a?(Node) && rhs.array_type?
+
+            add_offense(rhs, splat_source_range(rhs)) if array_splat?(rhs)
+          end
+        end
+
+        private
+
+        def_node_matcher :array_splat?, <<-PATTERN
+          (array (splat {(array ...) (block #{ARRAY_NEW_PATTERN} ...) #{ARRAY_NEW_PATTERN}} ...))
+        PATTERN
+
+        def splat_source_range(node)
+          node.loc.expression.begin.resize(1)
+        end
+
+        def autocorrect(node)
+          ->(corrector) { corrector.remove(splat_source_range(node)) }
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/metrics/method_length.rb

@@ -4,7 +4,7 @@
 module RuboCop
   module Cop
     module Metrics
-      # This cop checks if the length a method exceeds some maximum value.
+      # This cop checks if the length of a method exceeds some maximum value.
       # Comment lines can optionally be ignored.
       # The maximum allowed length is configurable.
       class MethodLength < Cop

data/lib/rubocop/cop/mixin/configurable_enforced_style.rb

@@ -22,25 +22,18 @@ module RuboCop
       end
 
       def style_detected(detected)
-        # `detected` can be a single style, or an Array of possible styles
-        # (if there is more than one which matches the observed code)
-
         return if no_acceptable_style?
 
-        if detected.is_a?(Array)
-          detected.map!(&:to_s)
-        else
-          detected = detected.to_s
-        end
+        # `detected` can be a single style, or an Array of possible styles
+        # (if there is more than one which matches the observed code)
+        detected_as_strings = Array(detected).map(&:to_s)
 
         if !detected_style # we haven't observed any specific style yet
-          self.detected_style = detected
+          self.detected_style = detected_as_strings
         elsif detected_style.is_a?(Array)
-          self.detected_style &= [*detected]
-        elsif detected.is_a?(Array)
-          no_acceptable_style! unless detected.include?(detected_style)
-        else
-          no_acceptable_style! unless detected_style == detected
+          self.detected_style &= detected_as_strings
+        elsif !detected.include?(detected_style)
+          no_acceptable_style!
         end
       end
 
@@ -60,17 +53,10 @@ module RuboCop
       def detected_style=(style)
         Formatter::DisabledConfigFormatter.detected_styles[cop_name] = style
 
-        if style.nil?
-          no_acceptable_style!
-        elsif style.is_a?(Array)
-          if style.empty?
-            no_acceptable_style!
-          else
-            config_to_allow_offenses[parameter_name] = style[0]
-          end
-        else
-          config_to_allow_offenses[parameter_name] = style
-        end
+        return no_acceptable_style! if style.nil?
+        return no_acceptable_style! if style.empty?
+
+        config_to_allow_offenses[parameter_name] = style.first
       end
 
       alias conflicting_styles_detected no_acceptable_style!