rubocop 0.42.0 → 0.52.1

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -14,10 +13,10 @@ module RuboCop
       #   # good
       #   CONST = [1, 2, 3].freeze
       class MutableConstant < Cop
-        MSG = 'Freeze mutable objects assigned to constants.'.freeze
-
         include FrozenStringLiteral
 
+        MSG = 'Freeze mutable objects assigned to constants.'.freeze
+
         def on_casgn(node)
           _scope, _const_name, value = *node
           on_assignment(value)
@@ -25,13 +24,17 @@ module RuboCop
 
         def on_or_asgn(node)
           lhs, value = *node
-          on_assignment(value) if lhs && lhs.type == :casgn
+
+          return unless lhs && lhs.casgn_type?
+
+          on_assignment(value)
         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.bracketed?
               corrector.insert_before(expr, '[')
               corrector.insert_after(expr, '].freeze')
             else
@@ -43,13 +46,18 @@ module RuboCop
         private
 
         def on_assignment(value)
-          return unless value
-          return unless value.mutable_literal?
+          value = splat_value(value) if splat_value(value)
+
+          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)
+          add_offense(value)
         end
+
+        def_node_matcher :splat_value, <<-PATTERN
+          (array (splat $_))
+        PATTERN
       end
     end
   end

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

@@ -1,46 +1,97 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
       # Checks for uses of if with a negated condition. Only ifs
-      # without else are considered.
+      # without else are considered. There are three different styles:
+      #
+      #   - both
+      #   - prefix
+      #   - postfix
+      #
+      # @example EnforcedStyle: both (default)
+      #   # enforces `unless` for `prefix` and `postfix` conditionals
+      #
+      #   # bad
+      #
+      #   if !foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #
+      #   unless foo
+      #     bar
+      #   end
+      #
+      #   # bad
+      #
+      #   bar if !foo
+      #
+      #   # good
+      #
+      #   bar unless foo
+      #
+      # @example EnforcedStyle: prefix
+      #   # enforces `unless` for just `prefix` conditionals
+      #
+      #   # bad
+      #
+      #   if !foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #
+      #   unless foo
+      #     bar
+      #   end
+      #
+      #   # good
+      #
+      #   bar if !foo
+      #
+      # @example EnforcedStyle: postfix
+      #   # enforces `unless` for just `postfix` conditionals
+      #
+      #   # bad
+      #
+      #   bar if !foo
+      #
+      #   # good
+      #
+      #   bar unless foo
+      #
+      #   # good
+      #
+      #   if !foo
+      #     bar
+      #   end
       class NegatedIf < Cop
+        include ConfigurableEnforcedStyle
         include NegativeConditional
 
-        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? || node.ternary?
+          return if correct_style?(node)
 
           check_negative_conditional(node)
         end
 
-        def message(node)
-          if node.loc.keyword.is?('if')
-            format(MSG, 'unless', 'if')
-          else
-            format(MSG, 'if', 'unless')
-          end
+        def autocorrect(node)
+          ConditionCorrector.correct_negative_condition(node)
         end
 
         private
 
-        def autocorrect(node)
-          lambda do |corrector|
-            condition, _body, _rest = *node
-            # look inside parentheses around the condition
-            condition = condition.children.first while condition.type == :begin
-            # 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
+        def message(node)
+          format(MSG, inverse: node.inverse_keyword, current: node.keyword)
+        end
+
+        def correct_style?(node)
+          style == :prefix && node.modifier_form? ||
+            style == :postfix && !node.modifier_form?
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -8,8 +7,6 @@ module RuboCop
       class NegatedWhile < Cop
         include NegativeConditional
 
-        MSG = 'Favor `%s` over `%s` for negative conditions.'.freeze
-
         def on_while(node)
           check_negative_conditional(node)
         end
@@ -18,29 +15,14 @@ module RuboCop
           check_negative_conditional(node)
         end
 
-        def message(node)
-          if node.type == :while
-            format(MSG, 'until', 'while')
-          else
-            format(MSG, 'while', 'until')
-          end
+        def autocorrect(node)
+          ConditionCorrector.correct_negative_condition(node)
         end
 
         private
 
-        def autocorrect(node)
-          lambda do |corrector|
-            condition, _body, _rest = *node
-            # Look inside parentheses around the condition, if any.
-            condition, = *condition while condition.type == :begin
-            # Unwrap the negated portion of the condition (a send node).
-            pos_condition, _method, = *condition
-            corrector.replace(
-              node.loc.keyword,
-              node.type == :while ? 'until' : 'while'
-            )
-            corrector.replace(condition.source_range, pos_condition.source)
-          end
+        def message(node)
+          format(MSG, inverse: node.inverse_keyword, current: node.keyword)
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -15,8 +14,6 @@ module RuboCop
       #   # good
       #   something if b && a
       class NestedModifier < Cop
-        include IfNode
-
         MSG = 'Avoid using nested modifiers.'.freeze
 
         def on_while(node)
@@ -33,56 +30,33 @@ module RuboCop
 
         def check(node)
           return if part_of_ignored_node?(node)
-          return unless modifier?(node)
-
-          ancestor = node.ancestors.first
-          return unless ancestor &&
-                        [:if, :while, :until].include?(ancestor.type) &&
-                        modifier?(ancestor)
+          return unless modifier?(node) && modifier?(node.parent)
 
-          add_offense(node, :keyword)
+          add_offense(node, location: :keyword)
           ignore_node(node)
         end
 
         def modifier?(node)
-          modifier_if?(node) || modifier_while_or_until?(node)
-        end
-
-        def modifier_while_or_until?(node)
-          node.loc.respond_to?(:keyword) &&
-            %w(while until).include?(node.loc.keyword.source) &&
-            node.modifier_form?
+          node && MODIFIER_NODES.include?(node.type) && node.modifier_form?
         end
 
         def autocorrect(node)
-          return unless node.if_type?
-
-          ancestor = node.ancestors.first
-          return unless ancestor.if_type?
+          return unless node.if_type? && node.parent.if_type?
 
-          autocorrect_if_unless(ancestor, node)
-        end
-
-        def autocorrect_if_unless(outer_node, inner_node)
-          outer_cond, = *outer_node
-
-          range =
-            Parser::Source::Range.new(inner_node.source_range.source_buffer,
-                                      inner_node.loc.keyword.begin_pos,
-                                      outer_cond.source_range.end_pos)
+          range = range_between(node.loc.keyword.begin_pos,
+                                node.parent.condition.source_range.end_pos)
 
           lambda do |corrector|
-            corrector.replace(range, new_expression(outer_node, inner_node))
+            corrector.replace(range, new_expression(node.parent, node))
           end
         end
 
         def new_expression(outer_node, inner_node)
-          outer_keyword = outer_node.loc.keyword.source
-          operator = replacement_operator(outer_keyword)
+          operator = replacement_operator(outer_node.keyword)
           lh_operand = left_hand_operand(outer_node, operator)
-          rh_operand = right_hand_operand(inner_node, outer_keyword)
+          rh_operand = right_hand_operand(inner_node, outer_node.keyword)
 
-          "#{outer_keyword} #{lh_operand} #{operator} #{rh_operand}"
+          "#{outer_node.keyword} #{lh_operand} #{operator} #{rh_operand}"
         end
 
         def replacement_operator(keyword)
@@ -90,26 +64,22 @@ module RuboCop
         end
 
         def left_hand_operand(node, operator)
-          cond, = *node
-
-          expr = cond.source
-          expr = "(#{expr})" if cond.or_type? && operator == '&&'.freeze
+          expr = node.condition.source
+          expr = "(#{expr})" if node.condition.or_type? &&
+                                operator == '&&'.freeze
           expr
         end
 
         def right_hand_operand(node, left_hand_keyword)
-          cond, = *node
-          keyword = node.loc.keyword.source
-
-          expr = cond.source
-          expr = "(#{expr})" if requires_parens?(cond)
-          expr = "!#{expr}" unless left_hand_keyword == keyword
+          expr = node.condition.source
+          expr = "(#{expr})" if requires_parens?(node.condition)
+          expr = "!#{expr}" unless left_hand_keyword == node.keyword
           expr
         end
 
         def requires_parens?(node)
           node.or_type? ||
-            !(RuboCop::Node::COMPARISON_OPERATORS & node.children).empty?
+            !(RuboCop::AST::Node::COMPARISON_OPERATORS & node.children).empty?
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -8,52 +7,57 @@ module RuboCop
       # of a parenthesized method call.
       #
       # @example
-      #   @good
+      #   # good
       #   method1(method2(arg), method3(arg))
       #
-      #   @bad
+      #   # bad
       #   method1(method2 arg, method3, arg)
       class NestedParenthesizedCalls < Cop
-        MSG = 'Add parentheses to nested method call `%s`.'.freeze
-        RSPEC_MATCHERS = [:be, :eq, :eql, :equal, :be_kind_of, :be_instance_of,
-                          :respond_to, :be_between, :match, :be_within,
-                          :start_with, :end_with, :include, :raise_error].freeze
+        MSG = 'Add parentheses to nested method call `%<source>s`.'.freeze
 
         def on_send(node)
-          return unless parenthesized_call?(node)
+          return unless node.parenthesized?
 
           node.each_child_node(:send) do |nested|
-            next if nested.method_args.empty? ||
-                    parenthesized_call?(nested) ||
-                    operator?(nested.method_name) ||
-                    rspec_matcher?(node, nested) ||
-                    nested.asgn_method_call?
-            add_offense(nested, nested.source_range, format(MSG, nested.source))
-          end
-        end
-
-        private
+            next if allowed_omission?(nested)
 
-        def rspec_matcher?(parent, send)
-          parent.method_args.one? && # .to, .not_to, etc
-            RSPEC_MATCHERS.include?(send.method_name) &&
-            send.method_args.one?
+            add_offense(nested,
+                        location: nested.source_range,
+                        message: format(MSG, source: nested.source))
+          end
         end
 
         def autocorrect(nested)
-          _scope, _method_name, *args = *nested
-
-          first_arg = args.first.source_range
-          last_arg = args.last.source_range
+          first_arg = nested.first_argument.source_range
+          last_arg = nested.last_argument.source_range
 
-          first_arg_with_space = range_with_surrounding_space(first_arg, :left)
-          leading_space = first_arg_with_space.begin.resize(1)
+          leading_space =
+            range_with_surrounding_space(range: first_arg,
+                                         side: :left).begin.resize(1)
 
           lambda do |corrector|
             corrector.replace(leading_space, '(')
             corrector.insert_after(last_arg, ')')
           end
         end
+
+        private
+
+        def allowed_omission?(send_node)
+          !send_node.arguments? || send_node.parenthesized? ||
+            send_node.setter_method? || send_node.operator_method? ||
+            whitelisted?(send_node)
+        end
+
+        def whitelisted?(send_node)
+          send_node.parent.arguments.one? &&
+            whitelisted_methods.include?(send_node.method_name.to_s) &&
+            send_node.arguments.one?
+        end
+
+        def whitelisted_methods
+          cop_config['Whitelist'] || []
+        end
       end
     end
   end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,16 +5,14 @@ module RuboCop
     module Style
       # This cop checks for nested ternary op expressions.
       class NestedTernaryOperator < Cop
-        include IfNode
-
         MSG = 'Ternary operators must not be nested. Prefer `if` or `else` ' \
               'constructs instead.'.freeze
 
         def on_if(node)
-          return unless ternary?(node)
+          return unless node.ternary?
 
-          node.each_descendant(:if) do |nested_if_node|
-            add_offense(nested_if_node, :expression) if ternary?(nested_if_node)
+          node.each_descendant(:if).select(&:ternary?).each do |nested_ternary|
+            add_offense(nested_ternary)
           end
         end
       end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,10 +5,38 @@ module RuboCop
     module Style
       # Use `next` to skip iteration instead of a condition at the end.
       #
-      # @example
+      # @example EnforcedStyle: skip_modifier_ifs (default)
       #   # bad
       #   [1, 2].each do |a|
-      #     if a == 1 do
+      #     if a == 1
+      #       puts a
+      #     end
+      #   end
+      #
+      #   # good
+      #   [1, 2].each do |a|
+      #     next unless a == 1
+      #     puts a
+      #   end
+      #
+      #   # good
+      #   [1, 2].each do |o|
+      #     puts o unless o == 1
+      #   end
+      #
+      # @example EnforcedStyle: always
+      #   # With `always` all conditions at the end of an iteration needs to be
+      #   # replaced by next - with `skip_modifier_ifs` the modifier if like
+      #   # this one are ignored: `[1, 2].each { |a| return 'yes' if a == 1 }`
+      #
+      #   # bad
+      #   [1, 2].each do |o|
+      #     puts o unless o == 1
+      #   end
+      #
+      #   # bad
+      #   [1, 2].each do |a|
+      #     if a == 1
       #       puts a
       #     end
       #   end
@@ -20,17 +47,11 @@ module RuboCop
       #     puts a
       #   end
       class Next < Cop
-        include IfNode
         include ConfigurableEnforcedStyle
         include MinBodyLength
 
         MSG = 'Use `next` to skip iteration.'.freeze
-        EXIT_TYPES = [:break, :return].freeze
-        EACH_ = 'each_'.freeze
-        ENUMERATORS = [:collect, :collect_concat, :detect, :downto, :each,
-                       :find, :find_all, :find_index, :inject, :loop, :map!,
-                       :map, :reduce, :reject, :reject!, :reverse_each, :select,
-                       :select!, :times, :upto].freeze
+        EXIT_TYPES = %i[break return].freeze
 
         def investigate(_processed_source)
           # When correcting nested offenses, we need to keep track of how much
@@ -39,39 +60,37 @@ module RuboCop
         end
 
         def on_block(node)
-          block_owner, _, body = *node
-          return unless block_owner.send_type?
-          return unless body && ends_with_condition?(body)
-
-          _, method_name = *block_owner
-          return unless enumerator?(method_name)
+          return unless node.send_node.send_type? &&
+                        node.send_node.enumerator_method?
 
-          offense_node = offense_node(body)
-          add_offense(offense_node, offense_location(offense_node), MSG)
+          check(node)
         end
 
         def on_while(node)
-          _, body = *node
-          return unless body && ends_with_condition?(body)
-
-          offense_node = offense_node(body)
-          add_offense(offense_node, offense_location(offense_node), MSG)
+          check(node)
         end
         alias on_until on_while
+        alias on_for on_while
 
-        def on_for(node)
-          _, _, body = *node
-          return unless body && ends_with_condition?(body)
-
-          offense_node = offense_node(body)
-          add_offense(offense_node, offense_location(offense_node), MSG)
+        def autocorrect(node)
+          lambda do |corrector|
+            if node.modifier_form?
+              autocorrect_modifier(corrector, node)
+            else
+              autocorrect_block(corrector, node)
+            end
+          end
         end
 
         private
 
-        def enumerator?(method_name)
-          ENUMERATORS.include?(method_name) ||
-            method_name.to_s.start_with?(EACH_)
+        def check(node)
+          return unless node.body && ends_with_condition?(node.body)
+
+          offending_node = offense_node(node.body)
+
+          add_offense(offending_node,
+                      location: offense_location(offending_node))
         end
 
         def ends_with_condition?(body)
@@ -82,21 +101,32 @@ module RuboCop
 
         def simple_if_without_break?(node)
           return false unless if_without_else?(node)
-          return false if style == :skip_modifier_ifs && modifier_if?(node)
-          return false if !modifier_if?(node) && !min_body_length?(node)
+          return false if if_else_children?(node)
+          return false if allowed_modifier_if?(node)
 
           !exit_body_type?(node)
         end
 
+        def allowed_modifier_if?(node)
+          if node.modifier_form?
+            style == :skip_modifier_ifs
+          else
+            !min_body_length?(node)
+          end
+        end
+
+        def if_else_children?(node)
+          node.each_child_node(:if).any?(&:else?)
+        end
+
         def if_without_else?(node)
-          node.if_type? && !ternary?(node) && !if_else?(node)
+          node && node.if_type? && !node.ternary? && !node.else?
         end
 
         def exit_body_type?(node)
-          _conditional, if_body, _else_body = *node
-          return false unless if_body
+          return false unless node.if_branch
 
-          EXIT_TYPES.include?(if_body.type)
+          EXIT_TYPES.include?(node.if_branch.type)
         end
 
         def offense_node(body)
@@ -110,16 +140,6 @@ module RuboCop
           offense_begin_pos.join(condition_expression.source_range)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            if modifier_if?(node)
-              autocorrect_modifier(corrector, node)
-            else
-              autocorrect_block(corrector, node)
-            end
-          end
-        end
-
         def autocorrect_modifier(corrector, node)
           cond, if_body, else_body = *node
           body = if_body || else_body
@@ -155,19 +175,18 @@ module RuboCop
                     else
                       cond.source_range.end_pos
                     end
-          Parser::Source::Range.new(node.source_range.source_buffer,
-                                    node.source_range.begin_pos,
-                                    end_pos)
+
+          range_between(node.source_range.begin_pos, end_pos)
         end
 
         def end_range(node)
           source_buffer = node.source_range.source_buffer
           end_pos = node.loc.end.end_pos
-          begin_pos = node.loc.end.begin_pos - node.source_range.column
+          begin_pos = node.loc.end.begin_pos - node.loc.end.column
           begin_pos -= 1 if end_followed_by_whitespace_only?(source_buffer,
                                                              end_pos)
 
-          Parser::Source::Range.new(source_buffer, begin_pos, end_pos)
+          range_between(begin_pos, end_pos)
         end
 
         def end_followed_by_whitespace_only?(source_buffer, end_pos)