rubocop 0.80.0 → 0.84.0

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

@@ -9,7 +9,7 @@ module RuboCop
       #
       # The maximum line length is configured in the `Layout/LineLength`
       # cop. The tab size is configured in the `IndentationWidth` of the
-      # `Layout/Tab` cop.
+      # `Layout/IndentationStyle` cop.
       #
       # @example
       #   # bad
@@ -47,7 +47,7 @@ module RuboCop
         def on_if(node)
           msg = if eligible_node?(node)
                   MSG_USE_MODIFIER unless named_capture_in_condition?(node)
-                elsif node.modifier_form? && too_long_single_line?(node)
+                elsif too_long_due_to_modifier?(node)
                   MSG_USE_NORMAL
                 end
           return unless msg
@@ -63,11 +63,16 @@ module RuboCop
                         else
                           to_modifier_form(node)
                         end
-          ->(corrector) { corrector.replace(node.source_range, replacement) }
+          ->(corrector) { corrector.replace(node, replacement) }
         end
 
         private
 
+        def too_long_due_to_modifier?(node)
+          node.modifier_form? && too_long_single_line?(node) &&
+            !another_statement_on_same_line?(node)
+        end
+
         def ignored_patterns
           config.for_cop('Layout/LineLength')['IgnoredPatterns'] || []
         end
@@ -129,6 +134,21 @@ module RuboCop
           node.ternary? || node.modifier_form? || node.elsif? || node.else?
         end
 
+        def another_statement_on_same_line?(node)
+          line_no = node.source_range.last_line
+
+          # traverse the AST upwards until we find a 'begin' node
+          # we want to look at the following child and see if it is on the
+          #   same line as this 'if' node
+          while node && !node.begin_type?
+            index = node.sibling_index
+            node  = node.parent
+          end
+
+          node && (sibling = node.children[index + 1]) &&
+            sibling.source_range.first_line == line_no
+        end
+
         def parenthesize?(node)
           # Parenthesize corrected expression if changing to modifier-if form
           # would change the meaning of the parent expression

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

@@ -19,11 +19,27 @@ module RuboCop
         MSG = 'Do not use if x; Use the ternary operator instead.'
 
         def on_normal_if_unless(node)
+          return unless node.else_branch
+
           beginning = node.loc.begin
           return unless beginning&.is?(';')
 
           add_offense(node)
         end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node, correct_to_ternary(node))
+          end
+        end
+
+        private
+
+        def correct_to_ternary(node)
+          else_code = node.else_branch ? node.else_branch.source : 'nil'
+
+          "#{node.condition.source} ? #{node.if_branch.source} : #{else_code}"
+        end
       end
     end
   end

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

@@ -44,7 +44,7 @@ module RuboCop
         CAMEL_CASE = /[A-Z]+[a-z]+/.freeze
 
         def self.autocorrect_incompatible_with
-          [Style::Not]
+          [Style::Not, Style::SymbolProc]
         end
 
         def_node_matcher :inverse_candidate?, <<~PATTERN
@@ -109,10 +109,7 @@ module RuboCop
             corrector.remove(not_to_receiver(node, method_call))
             corrector.replace(method_call.loc.selector,
                               inverse_methods[method].to_s)
-
-            if EQUALITY_METHODS.include?(method)
-              corrector.remove(end_parentheses(node, method_call))
-            end
+            remove_end_parenthesis(corrector, node, method, method_call)
           end
         end
 
@@ -187,6 +184,13 @@ module RuboCop
         def dot_range(loc)
           range_between(loc.dot.begin_pos, loc.expression.end_pos)
         end
+
+        def remove_end_parenthesis(corrector, node, method, method_call)
+          return unless EQUALITY_METHODS.include?(method) ||
+                        method_call.parent.begin_type?
+
+          corrector.remove(end_parentheses(node, method_call))
+        end
       end
     end
   end

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

@@ -73,6 +73,7 @@ module RuboCop
                       location: node.send_node.source_range,
                       message: message(node, selector))
         end
+        alias on_numblock on_block
 
         def autocorrect(node)
           if node.send_node.source == 'lambda'
@@ -108,13 +109,13 @@ module RuboCop
         end
 
         def autocorrect_method_to_literal(corrector, node)
-          corrector.replace(node.send_node.source_range, '->')
+          corrector.replace(node.send_node, '->')
 
           return unless node.arguments?
 
           arg_str = "(#{lambda_arg_string(node.arguments)})"
 
-          corrector.insert_after(node.send_node.source_range, arg_str)
+          corrector.insert_after(node.send_node, arg_str)
           corrector.remove(arguments_with_whitespace(node))
         end
 

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

@@ -37,7 +37,7 @@ module RuboCop
               receiver = node.receiver.source
               replacement = node.source.sub("#{receiver}.", "#{receiver}.call")
 
-              corrector.replace(node.source_range, replacement)
+              corrector.replace(node, replacement)
             else
               add_parentheses(node, corrector) unless node.parenthesized?
               corrector.remove(node.loc.selector)
@@ -52,26 +52,6 @@ module RuboCop
             implicit_style? && !node.implicit_call?
         end
 
-        def add_parentheses(node, corrector)
-          if node.arguments.empty?
-            corrector.insert_after(node.source_range, '()')
-          else
-            corrector.replace(args_begin(node), '(')
-            corrector.insert_after(args_end(node), ')')
-          end
-        end
-
-        def args_begin(node)
-          loc = node.loc
-          selector =
-            node.super_type? || node.yield_type? ? loc.keyword : loc.selector
-          selector.end.resize(1)
-        end
-
-        def args_end(node)
-          node.loc.expression.end
-        end
-
         def message(_node)
           if explicit_style?
             'Prefer the use of `lambda.call(...)` over `lambda.(...)`.'

data/lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb

@@ -22,9 +22,7 @@ module RuboCop
             lambda do |corrector|
               corrector.replace(args_begin(node), '(')
 
-              unless args_parenthesized?(node)
-                corrector.insert_after(args_end(node), ')')
-              end
+              corrector.insert_after(args_end(node), ')') unless args_parenthesized?(node)
             end
           end
 

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

@@ -41,9 +41,7 @@ module RuboCop
 
         def same_name_assignment?(node)
           any_assignment?(node) do |asgn_node|
-            if asgn_node.masgn_type?
-              next variable_in_mass_assignment?(node.method_name, asgn_node)
-            end
+            next variable_in_mass_assignment?(node.method_name, asgn_node) if asgn_node.masgn_type?
 
             asgn_node.loc.name.source == node.method_name.to_s
           end

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

@@ -72,7 +72,7 @@ module RuboCop
           between = prev_mixin.loc.expression.end
                               .join(range.begin)
           # if separated from previous mixin with only whitespace?
-          if between.source !~ /\S/
+          unless /\S/.match?(between.source)
             range = range.join(between) # then remove that too
           end
           range

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

@@ -6,7 +6,7 @@ module RuboCop
       # This cop checks for use of `extend self` or `module_function` in a
       # module.
       #
-      # Supported styles are: module_function, extend_self.
+      # Supported styles are: module_function, extend_self, forbidden.
       #
       # @example EnforcedStyle: module_function (default)
       #   # bad
@@ -46,6 +46,29 @@ module RuboCop
       #     # ...
       #   end
       #
+      # The option `forbidden` prohibits the usage of both styles.
+      #
+      # @example EnforcedStyle: forbidden
+      #   # bad
+      #   module Test
+      #     module_function
+      #     # ...
+      #   end
+      #
+      #   # bad
+      #   module Test
+      #     extend self
+      #     # ...
+      #   end
+      #
+      #   # bad
+      #   module Test
+      #     extend self
+      #     # ...
+      #     private
+      #     # ...
+      #   end
+      #
       # These offenses are not safe to auto-correct since there are different
       # implications to each approach.
       class ModuleFunction < Cop
@@ -55,6 +78,8 @@ module RuboCop
           'Use `module_function` instead of `extend self`.'
         EXTEND_SELF_MSG =
           'Use `extend self` instead of `module_function`.'
+        FORBIDDEN_MSG =
+          'Do not use `module_function` or `extend self`.'
 
         def_node_matcher :module_function_node?, '(send nil? :module_function)'
         def_node_matcher :extend_self_node?, '(send nil? :extend self)'
@@ -69,33 +94,54 @@ module RuboCop
         end
 
         def autocorrect(node)
+          return if style == :forbidden
+
           lambda do |corrector|
             if extend_self_node?(node)
-              corrector.replace(node.source_range, 'module_function')
+              corrector.replace(node, 'module_function')
             else
-              corrector.replace(node.source_range, 'extend self')
+              corrector.replace(node, 'extend self')
             end
           end
         end
 
         private
 
-        def each_wrong_style(nodes)
+        def each_wrong_style(nodes, &block)
           case style
           when :module_function
-            private_directive = nodes.any? { |node| private_directive?(node) }
-
-            nodes.each do |node|
-              yield node if extend_self_node?(node) && !private_directive
-            end
+            check_module_function(nodes, &block)
           when :extend_self
-            nodes.each do |node|
-              yield node if module_function_node?(node)
-            end
+            check_extend_self(nodes, &block)
+          when :forbidden
+            check_forbidden(nodes, &block)
+          end
+        end
+
+        def check_module_function(nodes)
+          private_directive = nodes.any? { |node| private_directive?(node) }
+
+          nodes.each do |node|
+            yield node if extend_self_node?(node) && !private_directive
+          end
+        end
+
+        def check_extend_self(nodes)
+          nodes.each do |node|
+            yield node if module_function_node?(node)
+          end
+        end
+
+        def check_forbidden(nodes)
+          nodes.each do |node|
+            yield node if extend_self_node?(node)
+            yield node if module_function_node?(node)
           end
         end
 
         def message(_node)
+          return FORBIDDEN_MSG if style == :forbidden
+
           style == :module_function ? MODULE_FUNCTION_MSG : EXTEND_SELF_MSG
         end
       end

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

@@ -29,7 +29,7 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            corrector.replace(node.source_range, to_normal_if(node))
+            corrector.replace(node, to_normal_if(node))
           end
         end
 

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

@@ -82,7 +82,7 @@ module RuboCop
         end
 
         def keyword_end_str(node, node_buf)
-          if node_buf.source_line(node.loc.end.line) =~ /[^\s\)]/
+          if /[^\s\)]/.match?(node_buf.source_line(node.loc.end.line))
             "\n" + (' ' * node.loc.column) + 'end'
           else
             'end'

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

@@ -22,6 +22,12 @@ module RuboCop
       #   when bar then do_something
       #   end
       #
+      #   # good
+      #   case foo
+      #   when bar then do_something(arg1,
+      #                              arg2)
+      #   end
+      #
       class MultilineWhenThen < Cop
         include RangeHelp
 
@@ -32,7 +38,10 @@ module RuboCop
           return unless node.then?
 
           # Single line usage of `then` is not an offense
-          return if !node.children.last.nil? && !node.multiline? && node.then?
+          return if !node.children.last.nil? && !node.multiline?
+
+          # Requires `then` for write `when` and its body on the same line.
+          return if require_then?(node)
 
           # With more than one statements after then, there's not offense
           return if accept_node_type?(node.body)
@@ -50,6 +59,12 @@ module RuboCop
           end
         end
 
+        def require_then?(when_node)
+          return false unless when_node.body
+
+          when_node.loc.line == when_node.body.loc.line
+        end
+
         def accept_node_type?(node)
           node&.begin_type? || node&.array_type? || node&.hash_type?
         end

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

@@ -77,11 +77,9 @@ module RuboCop
             if splat_value
               correct_splat_expansion(corrector, expr, splat_value)
             elsif node.array_type? && !node.bracketed?
-              corrector.insert_before(expr, '[')
-              corrector.insert_after(expr, ']')
+              corrector.wrap(expr, '[', ']')
             elsif requires_parentheses?(node)
-              corrector.insert_before(expr, '(')
-              corrector.insert_after(expr, ')')
+              corrector.wrap(expr, '(', ')')
             end
 
             corrector.insert_after(expr, '.freeze')

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

@@ -8,10 +8,10 @@ module RuboCop
       #
       # @example
       #   # good
-      #   method1(method2(arg), method3(arg))
+      #   method1(method2(arg))
       #
       #   # bad
-      #   method1(method2 arg, method3, arg)
+      #   method1(method2 arg)
       class NestedParenthesizedCalls < Cop
         include RangeHelp
 
@@ -35,8 +35,8 @@ module RuboCop
           last_arg = nested.last_argument.source_range
 
           leading_space =
-            range_with_surrounding_space(range: first_arg,
-                                         side: :left).begin.resize(1)
+            range_with_surrounding_space(range: first_arg.begin,
+                                         side: :left)
 
           lambda do |corrector|
             corrector.replace(leading_space, '(')

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

@@ -152,13 +152,13 @@ module RuboCop
             "next #{node.inverse_keyword} #{node.condition.source}\n" \
             "#{' ' * node.source_range.column}#{body.source}"
 
-          corrector.replace(node.source_range, replacement)
+          corrector.replace(node, replacement)
         end
 
         def autocorrect_block(corrector, node)
           next_code = "next #{node.inverse_keyword} #{node.condition.source}"
 
-          corrector.insert_before(node.source_range, next_code)
+          corrector.insert_before(node, next_code)
 
           corrector.remove(cond_range(node, node.condition))
           corrector.remove(end_range(node))

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

@@ -49,7 +49,7 @@ module RuboCop
                      else
                        node.source.sub(/\s*={2,3}\s*nil/, '.nil?')
                      end
-          ->(corrector) { corrector.replace(node.source_range, new_code) }
+          ->(corrector) { corrector.replace(node, new_code) }
         end
 
         private