rubocop 0.49.1 → 0.52.0

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

@@ -11,7 +11,7 @@ module RuboCop
         def on_if(node)
           return unless node.ternary? && node.multiline?
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
       end
     end

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

@@ -20,7 +20,7 @@ module RuboCop
 
         def on_if(node)
           return unless nested_variable_comparison?(node.condition)
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         private

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

@@ -30,23 +30,11 @@ module RuboCop
           on_assignment(value)
         end
 
-        private
-
-        def on_assignment(value)
-          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?
-
-          add_offense(value, :expression)
-        end
-
         def autocorrect(node)
           expr = node.source_range
 
           lambda do |corrector|
-            if unbracketed_array?(node)
+            if node.array_type? && !node.bracketed?
               corrector.insert_before(expr, '[')
               corrector.insert_after(expr, '].freeze')
             else
@@ -55,8 +43,16 @@ module RuboCop
           end
         end
 
-        def unbracketed_array?(node)
-          node.array_type? && !node.square_brackets? && !node.percent_literal?
+        private
+
+        def on_assignment(value)
+          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?
+
+          add_offense(value)
         end
 
         def_node_matcher :splat_value, <<-PATTERN

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

@@ -10,17 +10,9 @@ module RuboCop
       #   - prefix
       #   - postfix
       #
-      # @example
-      #
-      #   # EnforcedStyle: both
+      # @example EnforcedStyle: both (default)
       #   # enforces `unless` for `prefix` and `postfix` conditionals
       #
-      #   # good
-      #
-      #   unless foo
-      #     bar
-      #   end
-      #
       #   # bad
       #
       #   if !foo
@@ -29,26 +21,30 @@ module RuboCop
       #
       #   # good
       #
-      #   bar unless foo
+      #   unless foo
+      #     bar
+      #   end
       #
       #   # bad
       #
       #   bar if !foo
       #
-      # @example
+      #   # good
       #
-      #   # EnforcedStyle: prefix
+      #   bar unless foo
+      #
+      # @example EnforcedStyle: prefix
       #   # enforces `unless` for just `prefix` conditionals
       #
-      #   # good
+      #   # bad
       #
-      #   unless foo
+      #   if !foo
       #     bar
       #   end
       #
-      #   # bad
+      #   # good
       #
-      #   if !foo
+      #   unless foo
       #     bar
       #   end
       #
@@ -56,21 +52,19 @@ module RuboCop
       #
       #   bar if !foo
       #
-      # @example
-      #
-      #   # EnforcedStyle: postfix
+      # @example EnforcedStyle: postfix
       #   # enforces `unless` for just `postfix` conditionals
       #
-      #   # good
-      #
-      #   bar unless foo
-      #
       #   # bad
       #
       #   bar if !foo
       #
       #   # good
       #
+      #   bar unless foo
+      #
+      #   # good
+      #
       #   if !foo
       #     bar
       #   end
@@ -78,24 +72,26 @@ module RuboCop
         include ConfigurableEnforcedStyle
         include NegativeConditional
 
-        MSG = 'Favor `%s` over `%s` for negative conditions.'.freeze
-
         def on_if(node)
           return if node.elsif? || node.ternary?
-          return if style == :prefix && node.modifier_form?
-          return if style == :postfix && !node.modifier_form?
+          return if correct_style?(node)
 
           check_negative_conditional(node)
         end
 
-        def message(node)
-          format(MSG, node.inverse_keyword, node.keyword)
+        def autocorrect(node)
+          negative_conditional_corrector(node)
         end
 
         private
 
-        def autocorrect(node)
-          negative_conditional_corrector(node)
+        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

@@ -7,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,11 +16,9 @@ module RuboCop
         end
 
         def message(node)
-          format(MSG, node.inverse_keyword, node.keyword)
+          format(MSG, inverse: node.inverse_keyword, current: node.keyword)
         end
 
-        private
-
         def autocorrect(node)
           negative_conditional_corrector(node)
         end

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

@@ -32,7 +32,7 @@ module RuboCop
           return if part_of_ignored_node?(node)
           return unless modifier?(node) && modifier?(node.parent)
 
-          add_offense(node, :keyword)
+          add_offense(node, location: :keyword)
           ignore_node(node)
         end
 

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

@@ -7,16 +7,13 @@ 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 = %i[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 node.parenthesized?
@@ -24,37 +21,43 @@ module RuboCop
           node.each_child_node(:send) do |nested|
             next if allowed_omission?(nested)
 
-            add_offense(nested, nested.source_range, format(MSG, nested.source))
+            add_offense(nested,
+                        location: nested.source_range,
+                        message: format(MSG, source: nested.source))
           end
         end
 
-        private
-
-        def allowed_omission?(send_node)
-          !send_node.arguments? || send_node.parenthesized? ||
-            send_node.setter_method? || send_node.operator_method? ||
-            rspec_matcher?(send_node)
-        end
-
-        # TODO: Relegate this from RuboCop core
-        def rspec_matcher?(send_node)
-          send_node.parent.arguments.one? && # .to, .not_to, etc
-            RSPEC_MATCHERS.include?(send_node.method_name) &&
-            send_node.arguments.one?
-        end
-
         def autocorrect(nested)
           first_arg = nested.first_argument.source_range
           last_arg = nested.last_argument.source_range
 
           leading_space =
-            range_with_surrounding_space(first_arg, :left).begin.resize(1)
+            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

@@ -12,7 +12,7 @@ module RuboCop
           return unless node.ternary?
 
           node.each_descendant(:if).select(&:ternary?).each do |nested_ternary|
-            add_offense(nested_ternary, :expression)
+            add_offense(nested_ternary)
           end
         end
       end

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

@@ -5,7 +5,35 @@ 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
+      #       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
@@ -44,6 +72,16 @@ module RuboCop
         alias on_until on_while
         alias on_for on_while
 
+        def autocorrect(node)
+          lambda do |corrector|
+            if node.modifier_form?
+              autocorrect_modifier(corrector, node)
+            else
+              autocorrect_block(corrector, node)
+            end
+          end
+        end
+
         private
 
         def check(node)
@@ -51,7 +89,8 @@ module RuboCop
 
           offending_node = offense_node(node.body)
 
-          add_offense(offending_node, offense_location(offending_node))
+          add_offense(offending_node,
+                      location: offense_location(offending_node))
         end
 
         def ends_with_condition?(body)
@@ -101,16 +140,6 @@ module RuboCop
           offense_begin_pos.join(condition_expression.source_range)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            if node.modifier_form?
-              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

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

@@ -7,24 +7,24 @@ module RuboCop
       #
       # @example
       #
-      #  # bad
-      #  if x == nil
+      #   # bad
+      #   if x == nil
+      #   end
       #
-      #  # good
-      #  if x.nil?
+      #   # good
+      #   if x.nil?
+      #   end
       class NilComparison < Cop
         MSG = 'Prefer the use of the `nil?` predicate.'.freeze
 
-        def_node_matcher :nil_comparison?, '(send _ {:== :===} (:nil))'
+        def_node_matcher :nil_comparison?, '(send _ {:== :===} nil)'
 
         def on_send(node)
           nil_comparison?(node) do
-            add_offense(node, :selector)
+            add_offense(node, location: :selector)
           end
         end
 
-        private
-
         def autocorrect(node)
           new_code = node.source.sub(/\s*={2,3}\s*nil/, '.nil?')
           ->(corrector) { corrector.replace(node.source_range, new_code) }

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

@@ -7,26 +7,27 @@ module RuboCop
       #
       # @example
       #
-      #  # bad
-      #  if x != nil
+      #   # bad
+      #   if x != nil
+      #   end
       #
-      #  # good (when not allowing semantic changes)
-      #  # bad (when allowing semantic changes)
-      #  if !x.nil?
+      #   # good (when not allowing semantic changes)
+      #   # bad (when allowing semantic changes)
+      #   if !x.nil?
+      #   end
       #
-      #  # good (when allowing semantic changes)
-      #  if x
+      #   # good (when allowing semantic changes)
+      #   if x
+      #   end
       #
       # Non-nil checks are allowed if they are the final nodes of predicate.
       #
-      #  # good
-      #  def signed_in?
-      #    !current_user.nil?
-      #  end
+      #   # good
+      #   def signed_in?
+      #     !current_user.nil?
+      #   end
       class NonNilCheck < Cop
-        include OnMethodDef
-
-        def_node_matcher :not_equal_to_nil?, '(send _ :!= (:nil))'
+        def_node_matcher :not_equal_to_nil?, '(send _ :!= nil)'
         def_node_matcher :unless_check?, '(if (send _ :nil?) ...)'
         def_node_matcher :nil_check?, '(send _ :nil?)'
         def_node_matcher :not_and_nil_check?, '(send (send _ :nil?) :!)'
@@ -35,10 +36,34 @@ module RuboCop
           return if ignored_node?(node)
 
           if not_equal_to_nil?(node)
-            add_offense(node, :selector)
+            add_offense(node, location: :selector)
           elsif include_semantic_changes? &&
                 (not_and_nil_check?(node) || unless_and_nil_check?(node))
-            add_offense(node, :expression)
+            add_offense(node)
+          end
+        end
+
+        def on_def(node)
+          body = node.body
+
+          return unless node.predicate_method? && body
+
+          if body.begin_type?
+            ignore_node(body.children.last)
+          else
+            ignore_node(body)
+          end
+        end
+        alias on_defs on_def
+
+        def autocorrect(node)
+          case node.method_name
+          when :!=
+            autocorrect_comparison(node)
+          when :!
+            autocorrect_non_nil(node, node.receiver)
+          when :nil?
+            autocorrect_unless_nil(node, node.receiver)
           end
         end
 
@@ -63,28 +88,6 @@ module RuboCop
           cop_config['IncludeSemanticChanges']
         end
 
-        def on_method_def(_node, name, _args, body)
-          # only predicate methods are handled differently
-          return unless name.to_s.end_with?('?') && body
-
-          if body.begin_type?
-            ignore_node(body.children.last)
-          else
-            ignore_node(body)
-          end
-        end
-
-        def autocorrect(node)
-          case node.method_name
-          when :!=
-            autocorrect_comparison(node)
-          when :!
-            autocorrect_non_nil(node, node.receiver)
-          when :nil?
-            autocorrect_unless_nil(node, node.receiver)
-          end
-        end
-
         def autocorrect_comparison(node)
           expr = node.source