rubocop 0.46.0 → 0.47.0

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

@@ -16,18 +16,18 @@ module RuboCop
       #     work
       #   end
       class InfiniteLoop < Cop
+        LEADING_SPACE = /\A(\s*)/
+
         MSG = 'Use `Kernel#loop` for infinite loops.'.freeze
 
         def on_while(node)
-          condition, = *node
-          return unless condition.truthy_literal?
+          return unless node.condition.truthy_literal?
 
           add_offense(node, :keyword)
         end
 
         def on_until(node)
-          condition, = *node
-          return unless condition.falsey_literal?
+          return unless node.condition.falsey_literal?
 
           add_offense(node, :keyword)
         end
@@ -35,6 +35,8 @@ module RuboCop
         alias on_while_post on_while
         alias on_until_post on_until
 
+        private
+
         def autocorrect(node)
           if node.while_post_type? || node.until_post_type?
             replace_begin_end_with_modifier(node)
@@ -45,46 +47,43 @@ module RuboCop
           end
         end
 
-        private
-
         def replace_begin_end_with_modifier(node)
-          _, body = *node
-
           lambda do |corrector|
-            corrector.replace(body.loc.begin, 'loop do')
-            corrector.remove(body.loc.end.end.join(node.source_range.end))
+            corrector.replace(node.body.loc.begin, 'loop do')
+            corrector.remove(node.body.loc.end.end.join(node.source_range.end))
           end
         end
 
         def replace_source(range, replacement)
-          ->(corrector) { corrector.replace(range, replacement) }
+          lambda do |corrector|
+            corrector.replace(range, replacement)
+          end
         end
 
         def modifier_replacement(node)
-          _, body = *node
           if node.single_line?
-            'loop { ' + body.source + ' }'
+            'loop { ' + node.body.source + ' }'
           else
-            indentation = body.loc.expression.source_line[/\A(\s*)/]
-            "loop do\n" + indentation +
-              body.source.gsub(/^/, ' ' * configured_indentation_width) +
-              "\n#{indentation}end"
+            indentation = node.body.loc.expression.source_line[LEADING_SPACE]
+
+            ['loop do', node.body.source.gsub(/^/, configured_indent),
+             'end'].join("\n#{indentation}")
           end
         end
 
         def non_modifier_range(node)
-          condition_node, = *node
           start_range = node.loc.keyword.begin
-          end_range = if node.loc.begin
+          end_range = if node.do?
                         node.loc.begin.end
                       else
-                        condition_node.source_range.end
+                        node.condition.source_range.end
                       end
+
           start_range.join(end_range)
         end
 
-        def configured_indentation_width
-          config.for_cop('IndentationWidth')['Width']
+        def configured_indent
+          ' ' * config.for_cop('IndentationWidth')['Width']
         end
       end
     end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks presence of parentheses in method calls containing
+      # parameters.
+      # As in popular Ruby's frameworks a lot of methods should always be
+      # called without parentheses,
+      # users can ignore them by passing their names to IgnoredMethods option.
+      #
+      # @example
+      #   # bad
+      #   array.delete e
+      #
+      #   # good
+      #   array.delete(e)
+      #
+      #   # good if `puts` is listed in IgnoredMethods
+      #   puts 'test'
+      class MethodCallWithArgsParentheses < Cop
+        MSG = 'Use parentheses for method calls with arguments.'.freeze
+
+        def on_send(node)
+          _receiver, method_name, *args = *node
+          return if ignored_list.include?(method_name)
+          return if args.empty?
+          return if operator_call?(node)
+          return if parentheses?(node)
+
+          add_offense(node, :selector)
+        end
+
+        def on_super(node)
+          # super nodetype implies call with arguments.
+          return if parentheses?(node)
+
+          add_offense(node, :keyword)
+        end
+
+        def on_yield(node)
+          args = node.children
+          return if args.empty?
+          return if parentheses?(node)
+
+          add_offense(node, :keyword)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(args_begin(node), '(')
+            corrector.insert_after(args_end(node), ')')
+          end
+        end
+
+        private
+
+        def ignored_list
+          cop_config['IgnoredMethods'].map(&:to_sym)
+        end
+
+        def parentheses?(node)
+          node.loc.begin
+        end
+
+        def operator_call?(node)
+          node.loc.operator || (reciever?(node) && !node.loc.dot)
+        end
+
+        def reciever?(node)
+          !node.children[0].nil?
+        end
+
+        def args_begin(node)
+          loc = node.loc
+          selector = node.super_type? ? loc.keyword : loc.selector
+          selector.end.resize(1)
+        end
+
+        def args_end(node)
+          node.loc.expression.end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/{method_call_parentheses.rb → method_call_without_args_parentheses.rb}

@@ -4,7 +4,14 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for unwanted parentheses in parameterless method calls.
-      class MethodCallParentheses < Cop
+      #
+      # @example
+      #   # bad
+      #   object.some_method()
+      #
+      #   # good
+      #   object.some_method
+      class MethodCallWithoutArgsParentheses < Cop
         MSG = 'Do not use parentheses for method calls with ' \
               'no arguments.'.freeze
 

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

@@ -38,35 +38,61 @@ module RuboCop
         MSG_EMPTY = '`%s` condition requires an empty `else`-clause.'.freeze
 
         def on_normal_if_unless(node)
-          unless_else_cop = config.for_cop('Style/UnlessElse')
-          unless_else_enabled = unless_else_cop['Enabled'] if unless_else_cop
-          return if unless_else_enabled &&
-                    node.loc.keyword &&
-                    node.loc.keyword.is?('unless')
-          check(node, if_else_clause(node)) unless style == :case
+          return if case_style?
+          return if unless_else_cop_enabled? && node.unless?
+
+          check(node)
         end
 
         def on_case(node)
-          check(node, case_else_clause(node)) unless style == :if
+          return if if_style?
+
+          check(node)
         end
 
         private
 
-        def check(node, _else_clause)
-          return if node.loc.else
-          empty_else = config.for_cop('Style/EmptyElse')
+        def check(node)
+          return if node.else?
 
-          if empty_else && empty_else['Enabled']
-            case empty_else['EnforcedStyle']
-            when 'empty'
+          if empty_else_cop_enabled?
+            if empty_else_style == :empty
               add_offense(node, :expression, format(MSG_NIL, node.type))
-            when 'nil'
+            elsif empty_else_style == :nil
               add_offense(node, :expression, format(MSG_EMPTY, node.type))
             end
           end
 
           add_offense(node, :expression, format(MSG, node.type))
         end
+
+        def if_style?
+          style == :if
+        end
+
+        def case_style?
+          style == :case
+        end
+
+        def unless_else_cop_enabled?
+          unless_else_config['Enabled'] if unless_else_config
+        end
+
+        def unless_else_config
+          config.for_cop('Style/UnlessElse')
+        end
+
+        def empty_else_cop_enabled?
+          empty_else_config['Enabled'] if empty_else_config
+        end
+
+        def empty_else_style
+          empty_else_config['EnforcedStyle'].to_sym if empty_else_config
+        end
+
+        def empty_else_config
+          config.for_cop('Style/EmptyElse')
+        end
       end
     end
   end

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

@@ -15,7 +15,6 @@ module RuboCop
       #   # good
       #   { result: 'ok' } if cond
       class MultilineIfModifier < Cop
-        include IfNode
         include StatementModifier
         include AutocorrectAlignment
 
@@ -23,20 +22,13 @@ module RuboCop
               ' clause in a multiline statement.'.freeze
 
         def on_if(node)
-          return unless modifier_if?(node)
+          return unless node.modifier_form? && node.body.multiline?
 
-          _cond, body = if_node_parts(node)
-          return if body.single_line?
-
-          add_offense(node, :expression)
+          add_offense(node, :expression, format(MSG, node.keyword))
         end
 
         private
 
-        def message(node)
-          format(MSG, node.loc.keyword.source)
-        end
-
         def autocorrect(node)
           lambda do |corrector|
             corrector.replace(node.source_range, to_normal_if(node))
@@ -44,13 +36,11 @@ module RuboCop
         end
 
         def to_normal_if(node)
-          cond, body = if_node_parts(node)
-          indented_body = indented_body(body, node)
-
-          condition = "#{node.loc.keyword.source} #{cond.source}"
+          indented_body = indented_body(node.body, node)
+          condition = "#{node.keyword} #{node.condition.source}"
           indented_end = "#{offset(node)}end"
 
-          "#{condition}\n#{indented_body}\n#{indented_end}"
+          [condition, indented_body, indented_end].join("\n")
         end
 
         def configured_indentation_width

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

@@ -16,23 +16,29 @@ module RuboCop
       #   elsif cond then b
       #   end
       class MultilineIfThen < Cop
-        include IfNode
         include OnNormalIfUnless
 
+        NON_MODIFIER_THEN = /then\s*(#.*)?$/
+
+        MSG = 'Do not use `then` for multi-line `%s`.'.freeze
+
         def on_normal_if_unless(node)
-          return unless node.loc.begin
-          return unless node.loc.begin.source_line =~ /then\s*(#.*)?$/
-          add_offense(node, :begin)
+          return unless non_modifier_then?(node)
+
+          add_offense(node, :begin, format(MSG, node.keyword))
         end
 
-        def message(node)
-          "Do not use `then` for multi-line `#{node.loc.keyword.source}`."
+        private
+
+        def non_modifier_then?(node)
+          node.loc.begin && node.loc.begin.source_line =~ NON_MODIFIER_THEN
         end
 
         def autocorrect(node)
           lambda do |corrector|
-            corrector.remove(range_with_surrounding_space(node.loc.begin,
-                                                          :left))
+            corrector.remove(
+              range_with_surrounding_space(node.loc.begin, :left)
+            )
           end
         end
       end

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

@@ -129,9 +129,9 @@ module RuboCop
           n = kw_node_with_special_indentation(lhs)
           if n
             case n.type
-            when :if, :while, :until then expression, = *n
-            when :for                then _, expression, = *n
-            when :return             then expression, = *n
+            when :for            then _, expression, = *n
+            when :return         then expression, = *n
+            when *MODIFIER_NODES then expression, = *n
             end
             return expression.source_range
           end

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

@@ -5,15 +5,11 @@ module RuboCop
     module Style
       # This cop checks for multi-line ternary op expressions.
       class MultilineTernaryOperator < Cop
-        include IfNode
-
         MSG = 'Avoid multi-line ternary operators, ' \
               'use `if` or `unless` instead.'.freeze
 
         def on_if(node)
-          _condition, _if_branch, = *node
-
-          return unless ternary?(node) && node.multiline?
+          return unless node.ternary? && node.multiline?
 
           add_offense(node, :expression)
         end

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

@@ -37,15 +37,16 @@ module RuboCop
 
           return unless value && value.mutable_literal?
           return if FROZEN_STRING_LITERAL_TYPES.include?(value.type) &&
-                    frozen_string_literals_enabled?(processed_source)
+                    frozen_string_literals_enabled?
 
           add_offense(value, :expression)
         end
 
         def autocorrect(node)
           expr = node.source_range
+
           lambda do |corrector|
-            if node.array_type? && node.loc.begin.nil? && node.loc.end.nil?
+            if node.array_type? && !node.square_brackets?
               corrector.insert_before(expr, '[')
               corrector.insert_after(expr, '].freeze')
             else

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

@@ -11,35 +11,19 @@ module RuboCop
         MSG = 'Favor `%s` over `%s` for negative conditions.'.freeze
 
         def on_if(node)
-          return unless node.loc.respond_to?(:keyword)
-          return if node.loc.keyword.is?('elsif')
+          return if node.elsif?
 
           check_negative_conditional(node)
         end
 
         def message(node)
-          if node.loc.keyword.is?('if')
-            format(MSG, 'unless', 'if')
-          else
-            format(MSG, 'if', 'unless')
-          end
+          format(MSG, node.inverse_keyword, node.keyword)
         end
 
         private
 
         def autocorrect(node)
-          lambda do |corrector|
-            condition, _body, _rest = *node
-            # look inside parentheses around the condition
-            condition = condition.children.first while condition.begin_type?
-            # unwrap the negated portion of the condition (a send node)
-            pos_condition, _method, = *condition
-            corrector.replace(
-              node.loc.keyword,
-              node.loc.keyword.is?('if') ? 'unless' : 'if'
-            )
-            corrector.replace(condition.source_range, pos_condition.source)
-          end
+          negative_conditional_corrector(node)
         end
       end
     end