rubocop 0.58.2 → 0.59.0

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

@@ -66,6 +66,7 @@ module RuboCop
           unless supported_styles.include?(s)
             raise "Unknown style #{s} selected!"
           end
+
           s
         end
       end

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

@@ -35,6 +35,7 @@ module RuboCop
       # the method has the same name as a class defined in the class/module.
       def class_emitter_method?(node, name)
         return false unless node.parent && node.defs_type?
+
         # a class emitter method may be defined inside `def self.included`,
         # `def self.extended`, etc.
         node = node.parent while node.parent.defs_type?

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

@@ -21,14 +21,11 @@ module RuboCop
         def_node_matcher :constant_definition?, '{class module}'
         def_node_matcher :empty_line_required?, '{def defs class module}'
 
-        def check(node, body)
-          # When style is `empty_lines`, if the body is empty, we don't enforce
-          # the presence OR absence of an empty line
-          # But if style is `no_empty_lines`, there must not be an empty line
-          return unless body || style == :no_empty_lines
+        def check(node, body, adjusted_first_line: nil)
+          return if valid_body_style?(body)
           return if node.single_line?
 
-          first_line = node.source_range.first_line
+          first_line = adjusted_first_line || node.source_range.first_line
           last_line = node.source_range.last_line
 
           case style
@@ -51,6 +48,7 @@ module RuboCop
 
         def check_empty_lines_special(body, first_line, last_line)
           return unless body
+
           if namespace?(body, with_one_child: true)
             check_both(:no_empty_lines, first_line, last_line)
           else
@@ -124,6 +122,7 @@ module RuboCop
         def namespace?(body, with_one_child: false)
           if body.begin_type?
             return false if with_one_child
+
             body.children.all? { |child| constant_definition?(child) }
           else
             constant_definition?(body)
@@ -160,6 +159,13 @@ module RuboCop
         def deferred_message(node)
           format(MSG_DEFERRED, type: node.type)
         end
+
+        def valid_body_style?(body)
+          # When style is `empty_lines`, if the body is empty, we don't enforce
+          # the presence OR absence of an empty line
+          # But if style is `no_empty_lines`, there must not be an empty line
+          body.nil? && style != :no_empty_lines
+        end
       end
     end
   end

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

@@ -15,6 +15,7 @@ module RuboCop
       def check(node)
         empty_arguments?(node) do |args|
           return if args.empty_and_without_delimiters?
+
           add_offense(args)
         end
       end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This module encapsulates the ability to ignore certain methods when
+    # parsing.
+    module IgnoredMethods
+      private
+
+      def ignored_method?(name)
+        ignored_methods.include?(name.to_s)
+      end
+
+      def ignored_methods
+        cop_config.fetch('IgnoredMethods', [])
+      end
+    end
+  end
+end

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

@@ -56,8 +56,25 @@ module RuboCop
         end
       end
 
+      # The correct indentation of `node` is usually `IndentationWidth`, with
+      # one exception: prefix keywords.
+      #
+      # ```
+      # while foo &&  # Here, `while` is called a "prefix keyword"
+      #     bar       # This is called "special indentation"
+      #   baz
+      # end
+      # ```
+      #
+      # Note that *postfix conditionals* do *not* get "special indentation".
+      #
+      # ```
+      # next if foo &&
+      #   bar # normal indentation, not special
+      # ```
       def correct_indentation(node)
-        if kw_node_with_special_indentation(node)
+        kw_node = kw_node_with_special_indentation(node)
+        if kw_node && !postfix_conditional?(kw_node)
           # This cop could have its own IndentationWidth configuration
           configured_indentation_width +
             @config.for_cop('Layout/IndentationWidth')['Width']
@@ -115,6 +132,7 @@ module RuboCop
         keyword_node =
           node.each_ancestor(*KEYWORD_ANCESTOR_TYPES).find do |ancestor|
             next if ancestor.if_type? && ancestor.ternary?
+
             within_node?(node, indented_keyword_expression(ancestor))
           end
 
@@ -222,6 +240,12 @@ module RuboCop
           node.source_range.end_pos < ancestor.loc.end.end_pos
       end
 
+      # Returns true if `node` is a conditional whose `body` and `condition`
+      # begin on the same line.
+      def postfix_conditional?(node)
+        node.if_type? && node.modifier_form?
+      end
+
       def within_node?(inner, outer)
         o = outer.is_a?(AST::Node) ? outer.source_range : outer
         i = inner.is_a?(AST::Node) ? inner.source_range : inner

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

@@ -24,11 +24,13 @@ module RuboCop
       #    b # comment
       #   ].some_method
       def new_line_needed_before_closing_brace?(node)
-        return unless node.chained?
-
         last_element_line =
           last_element_range_with_trailing_comma(node).last_line
-        processed_source.comments.any? { |c| c.loc.line == last_element_line }
+
+        last_element_commented =
+          processed_source.comments.any? { |c| c.loc.line == last_element_line }
+
+        last_element_commented && (node.chained? || node.argument?)
       end
 
       def check(node)

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

@@ -12,11 +12,13 @@ module RuboCop
 
       def percent_literal?(node)
         return unless (begin_source = begin_source(node))
+
         begin_source.start_with?('%')
       end
 
       def process(node, *types)
         return unless percent_literal?(node) && types.include?(type(node))
+
         on_percent_literal(node)
       end
 

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

@@ -46,10 +46,12 @@ module RuboCop
       def aligned_with_line?(line_nos, range, indent = nil)
         line_nos.each do |lineno|
           next if aligned_comment_lines.include?(lineno + 1)
+
           line = processed_source.lines[lineno]
           index = line =~ /\S/
           next unless index
           next if indent && indent != index
+
           return yield(range, line)
         end
         false

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

@@ -11,8 +11,9 @@ module RuboCop
       private
 
       def_node_matcher :empty_condition?, '(begin)'
+      def_node_matcher :setter_method?, '[(send ...) setter_method?]'
       def_node_matcher :safe_assignment?,
-                       '(begin {equals_asgn? asgn_method_call?})'
+                       '(begin {equals_asgn? #setter_method?})'
 
       def safe_assignment_allowed?
         cop_config['AllowSafeAssignment']

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

@@ -52,7 +52,12 @@ module RuboCop
 
       def indentation_multiplier
         return 1 if config.for_cop('Layout/Tab')['Enabled']
-        config.for_cop('Layout/Tab')['IndentationWidth']
+
+        default_configuration = RuboCop::ConfigLoader.default_configuration
+        config.for_cop('Layout/Tab')['IndentationWidth'] ||
+          config.for_cop('Layout/IndentationWidth')['Width'] ||
+          default_configuration.for_cop('Layout/Tab')['IndentationWidth'] ||
+          default_configuration.for_cop('Layout/IndentationWidth')['Width']
       end
     end
   end

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

@@ -11,6 +11,7 @@ module RuboCop
       def wrong_quotes?(node)
         src = node.source
         return false if src.start_with?('%', '?')
+
         if style == :single_quotes
           !double_quotes_required?(src)
         else

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

@@ -63,6 +63,7 @@ module RuboCop
           space_offense(node, left_token, :right, message, NO_SPACE_COMMAND)
         end
         return if !extra_space?(right_token, :right) || end_ok
+
         space_offense(node, right_token, :left, message, NO_SPACE_COMMAND)
       end
 
@@ -76,11 +77,13 @@ module RuboCop
           space_offense(node, left_token, :none, message, SPACE_COMMAND)
         end
         return if extra_space?(right_token, :right) || end_ok
+
         space_offense(node, right_token, :none, message, SPACE_COMMAND)
       end
 
       def extra_space?(token, side)
         return false unless token
+
         if side == :left
           String(token.space_after?) == ' '
         else
@@ -106,6 +109,7 @@ module RuboCop
           empty_offense(node, range, message, 'Use one')
         end
         return unless offending_empty_no_space?(empty_config, left, right)
+
         empty_offense(node, range, message, 'Do not use')
       end
 

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

@@ -97,6 +97,7 @@ module RuboCop
 
         items = elements(node).map(&:source_range)
         return false if items.empty?
+
         items << node.loc.begin << node.loc.end
         (items.map(&:first_line) + items.map(&:last_line)).uniq.size > 1
       end

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

@@ -16,6 +16,7 @@ module RuboCop
           name = arg.children.first.to_s
           next if (arg.restarg_type? || arg.kwrestarg_type?) && name.empty?
           next if allowed_names.include?(name)
+
           range = arg_range(arg, name.size)
           issue_offenses(node, range, name)
         end
@@ -28,6 +29,7 @@ module RuboCop
         case_offense(node, range) if uppercase?(name)
         length_offense(node, range) unless long_enough?(name)
         return if allow_nums
+
         num_offense(node, range) if ends_with_num?(name)
       end
 

data/lib/rubocop/cop/naming/ascii_identifiers.rb

@@ -44,6 +44,7 @@ module RuboCop
         def investigate(processed_source)
           processed_source.each_token do |token|
             next unless token.type == :tIDENTIFIER && !token.text.ascii_only?
+
             add_offense(token, location: first_offense_range(token))
           end
         end

data/lib/rubocop/cop/naming/binary_operator_parameter_name.rb

@@ -34,6 +34,7 @@ module RuboCop
 
         def op_method?(name)
           return false if BLACKLISTED.include?(name)
+
           name !~ /\A\w/ || OP_LIKE_METHODS.include?(name)
         end
       end

data/lib/rubocop/cop/naming/file_name.rb

@@ -32,7 +32,8 @@ module RuboCop
 
         def investigate(processed_source)
           file_path = processed_source.file_path
-          return if config.file_to_include?(file_path)
+          return if config.file_to_exclude?(file_path) ||
+                    config.allowed_camel_case_file?(file_path)
 
           for_bad_filename(file_path) do |range, msg|
             add_offense(nil, location: range, message: msg)
@@ -52,6 +53,7 @@ module RuboCop
                 else
                   return if ignore_executable_scripts? &&
                             processed_source.start_with?('#!')
+
                   other_message(basename)
                 end
 
@@ -121,6 +123,7 @@ module RuboCop
 
           node.each_ancestor(:class, :module, :sclass, :casgn) do |ancestor|
             return false if ancestor.sclass_type?
+
             match_partial.call(ancestor.defined_module)
           end
 

data/lib/rubocop/cop/naming/memoized_instance_variable_name.rb

@@ -127,6 +127,7 @@ module RuboCop
 
         def matches?(method_name, ivar_assign)
           return true if ivar_assign.nil? || method_name == :initialize
+
           method_name = method_name.to_s.delete('!?')
           variable = ivar_assign.children.first
           variable_name = variable.to_s.sub('@', '')

data/lib/rubocop/cop/naming/predicate_name.rb

@@ -63,6 +63,7 @@ module RuboCop
         def allowed_method_name?(method_name, prefix)
           !method_name.start_with?(prefix) ||
             method_name == expected_name(method_name, prefix) ||
+            method_name.end_with?('=') ||
             predicate_whitelist.include?(method_name)
         end
 

data/lib/rubocop/cop/naming/uncommunicative_block_param_name.rb

@@ -40,6 +40,7 @@ module RuboCop
 
         def on_block(node)
           return unless node.arguments?
+
           check(node, node.arguments)
         end
       end

data/lib/rubocop/cop/naming/uncommunicative_method_param_name.rb

@@ -48,6 +48,7 @@ module RuboCop
 
         def on_def(node)
           return unless node.arguments?
+
           check(node, node.arguments)
         end
         alias on_defs on_def

data/lib/rubocop/cop/naming/variable_name.rb

@@ -27,6 +27,7 @@ module RuboCop
         def on_lvasgn(node)
           name, = *node
           return unless name
+
           check_name(node, name, node.loc.name)
         end
         alias on_ivasgn    on_lvasgn

data/lib/rubocop/cop/performance/case_when_splat.rb

@@ -3,16 +3,19 @@
 module RuboCop
   module Cop
     module Performance
-      # Place `when` conditions that use splat at the end
-      # of the list of `when` branches.
+      # Reordering `when` conditions with a splat to the end
+      # of the `when` branches can improve performance.
       #
       # Ruby has to allocate memory for the splat expansion every time
       # that the `case` `when` statement is run. Since Ruby does not support
       # fall through inside of `case` `when`, like some other languages do,
-      # the order of the `when` branches does not matter. By placing any
+      # the order of the `when` branches should not matter. By placing any
       # splat expansions at the end of the list of `when` branches we will
       # reduce the number of times that memory has to be allocated for
-      # the expansion.
+      # the expansion. The exception to this is if multiple of your `when`
+      # conditions can be true for any given condition. A likely scenario for
+      # this defining a higher level when condition to override a condition
+      # that is inside of the splat expansion.
       #
       # This is not a guaranteed performance improvement. If the data being
       # processed by the `case` condition is normalized in a manner that favors
@@ -54,9 +57,10 @@ module RuboCop
         include Alignment
         include RangeHelp
 
-        MSG = 'Place `when` conditions with a splat ' \
-              'at the end of the `when` branches.'.freeze
-        ARRAY_MSG = 'Do not expand array literals in `when` conditions.'.freeze
+        MSG = 'Reordering `when` conditions with a splat to the end ' \
+          'of the `when` branches can improve performance.'.freeze
+        ARRAY_MSG = 'Pass the contents of array literals ' \
+          'directly to `when` conditions.'.freeze
 
         def on_case(case_node)
           when_conditions = case_node.when_branches.flat_map(&:conditions)

data/lib/rubocop/cop/performance/casecmp.rb

@@ -18,7 +18,7 @@ module RuboCop
       #   str.casecmp('ABC').zero?
       #   'abc'.casecmp(str).zero?
       class Casecmp < Cop
-        MSG = 'Use `casecmp` instead of `%<methods>s`.'.freeze
+        MSG = 'Use `%<good>s` instead of `%<bad>s`.'.freeze
         CASE_METHODS = %i[downcase upcase].freeze
 
         def_node_matcher :downcase_eq, <<-PATTERN
@@ -43,16 +43,29 @@ module RuboCop
         PATTERN
 
         def on_send(node)
-          return if part_of_ignored_node?(node)
+          return unless downcase_eq(node) || eq_downcase(node)
+          return unless (parts = take_method_apart(node))
 
-          inefficient_comparison(node) do |range, is_other_part, *methods|
-            ignore_node(node) if is_other_part
-            add_offense(node, location: range,
-                              message: format(MSG, methods: methods.join(' ')))
-          end
+          _, _, arg, variable = parts
+          good_method = build_good_method(arg, variable)
+
+          add_offense(
+            node,
+            message: format(MSG, good: good_method, bad: node.source)
+          )
         end
 
         def autocorrect(node)
+          return unless (parts = take_method_apart(node))
+
+          receiver, method, arg, variable = parts
+
+          correction(node, receiver, method, arg, variable)
+        end
+
+        private
+
+        def take_method_apart(node)
           if downcase_downcase(node)
             receiver, method, rhs = *node
             arg, = *rhs
@@ -65,52 +78,30 @@ module RuboCop
           end
 
           variable, = *receiver
-          correction(node, receiver, method, arg, variable)
-        end
-
-        private
-
-        def inefficient_comparison(node)
-          loc = node.loc
 
-          downcase_eq(node) do |send_downcase, case_method, eq_method, other|
-            *_, method = *other
-            range, is_other_part = downcase_eq_range(method, loc, send_downcase)
-
-            yield range, is_other_part, case_method, eq_method
-            return
-          end
-
-          eq_downcase(node) do |eq_method, send_downcase, case_method|
-            range = loc.selector.join(send_downcase.loc.selector)
-            yield range, false, eq_method, case_method
-          end
-        end
-
-        def downcase_eq_range(method, loc, send_downcase)
-          if CASE_METHODS.include?(method)
-            [loc.expression, true]
-          else
-            [loc.selector.join(send_downcase.loc.selector), false]
-          end
+          [receiver, method, arg, variable]
         end
 
         def correction(node, _receiver, method, arg, variable)
           lambda do |corrector|
             corrector.insert_before(node.loc.expression, '!') if method == :!=
 
-            # we want resulting call to be parenthesized
-            # if arg already includes one or more sets of parens, don't add more
-            # or if method call already used parens, again, don't add more
-            replacement = if arg.send_type? || !parentheses?(arg)
-                            "#{variable.source}.casecmp(#{arg.source}).zero?"
-                          else
-                            "#{variable.source}.casecmp#{arg.source}.zero?"
-                          end
+            replacement = build_good_method(arg, variable)
 
             corrector.replace(node.loc.expression, replacement)
           end
         end
+
+        def build_good_method(arg, variable)
+          # We want resulting call to be parenthesized
+          # if arg already includes one or more sets of parens, don't add more
+          # or if method call already used parens, again, don't add more
+          if arg.send_type? || !parentheses?(arg)
+            "#{variable.source}.casecmp(#{arg.source}).zero?"
+          else
+            "#{variable.source}.casecmp#{arg.source}.zero?"
+          end
+        end
       end
     end
   end