rubocop 0.55.0 → 0.56.0

data/lib/rubocop/cop/rails/refute_methods.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      #
+      # Use `assert_not` methods instead of `refute` methods.
+      #
+      # @example
+      #   # bad
+      #   refute false
+      #   refute_empty [1, 2, 3]
+      #   refute_equal true, false
+      #
+      #   # good
+      #   assert_not false
+      #   assert_not_empty [1, 2, 3]
+      #   assert_not_equal true, false
+      #
+      class RefuteMethods < Cop
+        MSG = 'Prefer `%<assert_method>s` over `%<refute_method>s`.'.freeze
+
+        CORRECTIONS = {
+          refute:             'assert_not',
+          refute_empty:       'assert_not_empty',
+          refute_equal:       'assert_not_equal',
+          refute_in_delta:    'assert_not_in_delta',
+          refute_in_epsilon:  'assert_not_in_epsilon',
+          refute_includes:    'assert_not_includes',
+          refute_instance_of: 'assert_not_instance_of',
+          refute_kind_of:     'assert_not_kind_of',
+          refute_nil:         'assert_not_nil',
+          refute_operator:    'assert_not_operator',
+          refute_predicate:   'assert_not_predicate',
+          refute_respond_to:  'assert_not_respond_to',
+          refute_same:        'assert_not_same',
+          refute_match:       'assert_no_match'
+        }.freeze
+
+        OFFENSIVE_METHODS = CORRECTIONS.keys.freeze
+
+        def_node_matcher :offensive?, '(send nil? #refute_method? ...)'
+
+        def on_send(node)
+          return unless offensive?(node)
+
+          message = offense_message(node.method_name)
+          add_offense(node, location: :selector, message: message)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(
+              node.loc.selector,
+              CORRECTIONS[node.method_name]
+            )
+          end
+        end
+
+        private
+
+        def refute_method?(method_name)
+          OFFENSIVE_METHODS.include?(method_name)
+        end
+
+        def offense_message(method_name)
+          format(
+            MSG,
+            refute_method: method_name,
+            assert_method: CORRECTIONS[method_name]
+          )
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/reversible_migration.rb

@@ -157,7 +157,7 @@ module RuboCop
 
         def on_send(node)
           return unless within_change_method?(node)
-          return if within_reversible_block?(node)
+          return if within_reversible_or_up_only_block?(node)
 
           check_irreversible_schema_statement_node(node)
           check_drop_table_node(node)
@@ -168,7 +168,7 @@ module RuboCop
 
         def on_block(node)
           return unless within_change_method?(node)
-          return if within_reversible_block?(node)
+          return if within_reversible_or_up_only_block?(node)
 
           check_change_table_node(node.send_node, node.body)
         end
@@ -261,9 +261,11 @@ module RuboCop
           end
         end
 
-        def within_reversible_block?(node)
+        def within_reversible_or_up_only_block?(node)
           node.each_ancestor(:block).any? do |ancestor|
-            ancestor.block_type? && ancestor.send_node.method?(:reversible)
+            ancestor.block_type? &&
+              ancestor.send_node.method?(:reversible) ||
+              ancestor.send_node.method?(:up_only)
           end
         end
 

data/lib/rubocop/cop/rails/save_bang.rb

@@ -36,6 +36,8 @@ module RuboCop
       #     # ...
       #   end
       class SaveBang < Cop
+        include NegativeConditional
+
         MSG = 'Use `%<prefer>s` instead of `%<current>s` if the return ' \
               'value is not checked.'.freeze
         CREATE_MSG = (MSG +
@@ -131,7 +133,8 @@ module RuboCop
         def conditional?(node)
           node.parent && (
             node.parent.if_type? || node.parent.case_type? ||
-            node.parent.or_type? || node.parent.and_type?
+            node.parent.or_type? || node.parent.and_type? ||
+            single_negative?(node.parent)
           )
         end
 

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

@@ -126,13 +126,10 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/AbcSize
         def remove_braces_with_whitespace(corrector, node, space)
           right_brace_and_space = right_brace_and_space(node.loc.end, space)
 
-          if processed_source.comment_on_line?(right_brace_and_space.line)
-            remove_braces(corrector, node)
-          elsif node.multiline?
+          if node.multiline?
             remove_braces_with_range(corrector,
                                      left_whole_line_range(node.loc.begin),
                                      right_whole_line_range(node.loc.end))
@@ -143,7 +140,6 @@ module RuboCop
                                      right_brace_and_space)
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         def remove_braces_with_range(corrector, left_range, right_range)
           corrector.remove(left_range)
@@ -184,11 +180,6 @@ module RuboCop
           range_with_surrounding_comma(brace_and_space, :left)
         end
 
-        def remove_braces(corrector, node)
-          corrector.remove(node.loc.begin)
-          corrector.remove(node.loc.end)
-        end
-
         def add_braces(corrector, node)
           corrector.insert_before(node.source_range, '{')
           corrector.insert_after(node.source_range, '}')

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

@@ -95,7 +95,7 @@ module RuboCop
           return if contains_backtick?(node)
 
           replacement = if backtick_literal?(node)
-                          ['%x', ''].zip(preferred_delimiters).map(&:join)
+                          ['%x', ''].zip(preferred_delimiter).map(&:join)
                         else
                           %w[` `]
                         end
@@ -169,9 +169,21 @@ module RuboCop
           node.loc.begin.source == '`'
         end
 
-        def preferred_delimiters
+        def preferred_delimiter
+          (command_delimiter || default_delimiter).split(//)
+        end
+
+        def command_delimiter
+          preferred_delimiters_config['%x']
+        end
+
+        def default_delimiter
+          preferred_delimiters_config['default']
+        end
+
+        def preferred_delimiters_config
           config.for_cop('Style/PercentLiteralDelimiters') \
-            ['PreferredDelimiters']['%x'].split(//)
+            ['PreferredDelimiters']
         end
       end
     end

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

@@ -42,7 +42,8 @@ module RuboCop
 
         def investigate(processed_source)
           processed_source.comments.each_with_index do |comment, index|
-            next unless first_comment_line?(processed_source.comments, index)
+            next unless first_comment_line?(processed_source.comments, index) ||
+                        inline_comment?(comment)
 
             margin, first_word, colon, space, note = split_comment(comment)
             next unless annotation?(comment) &&
@@ -74,6 +75,10 @@ module RuboCop
             comments[index - 1].loc.line < comments[index].loc.line - 1
         end
 
+        def inline_comment?(comment)
+          !comment_line?(comment.loc.expression.source_line)
+        end
+
         def annotation_range(comment, margin, length)
           start = comment.loc.expression.begin_pos + margin.length
           range_between(start, start + length)

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

@@ -73,10 +73,13 @@ module RuboCop
         end
 
         def corrected(node)
-          arguments = node.arguments? ? node.arguments.source : ''
-          scope     = node.receiver ? "#{node.receiver.source}." : ''
+          has_parentheses = parentheses?(node.arguments)
 
-          signature = [scope, node.method_name, arguments].join
+          arguments   = node.arguments? ? node.arguments.source : ''
+          extra_space = node.arguments? && !has_parentheses ? ' ' : ''
+          scope       = node.receiver ? "#{node.receiver.source}." : ''
+
+          signature = [scope, node.method_name, extra_space, arguments].join
 
           ["def #{signature}", 'end'].join(joint(node))
         end

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

@@ -54,7 +54,10 @@ module RuboCop
         def autocorrect(node)
           lambda do |corrector|
             corrector.replace(args_begin(node), '(')
-            corrector.insert_after(args_end(node), ')')
+
+            unless args_parenthesized?(node)
+              corrector.insert_after(args_end(node), ')')
+            end
           end
         end
 
@@ -78,12 +81,19 @@ module RuboCop
           loc = node.loc
           selector =
             node.super_type? || node.yield_type? ? loc.keyword : loc.selector
-          selector.end.resize(1)
+
+          resize_by = args_parenthesized?(node) ? 2 : 1
+          selector.end.resize(resize_by)
         end
 
         def args_end(node)
           node.loc.expression.end
         end
+
+        def args_parenthesized?(node)
+          return false unless node.arguments.length == 1
+          node.arguments.first.parenthesized_call?
+        end
       end
     end
   end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for the presence of `method_missing` without
+      # falling back on `super`.
+      #
+      # @example
+      #   #bad
+      #   def method_missing(name, *args)
+      #     # ...
+      #   end
+      #
+      #   #good
+      #
+      #   def method_missing(name, *args)
+      #     # ...
+      #     super
+      #   end
+      class MethodMissingSuper < Cop
+        MSG = 'When using `method_missing`, fall back on `super`.'.freeze
+
+        def on_def(node)
+          return unless node.method?(:method_missing)
+          return if node.descendants.any?(&:zsuper_type?)
+
+          add_offense(node)
+        end
+        alias on_defs on_def
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/{method_missing.rb → missing_respond_to_missing.rb}

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for the presence of `method_missing` without also
-      # defining `respond_to_missing?` and falling back on `super`.
+      # defining `respond_to_missing?`.
       #
       # @example
       #   #bad
@@ -19,44 +19,22 @@ module RuboCop
       #
       #   def method_missing(name, *args)
       #     # ...
-      #     super
       #   end
-      class MethodMissing < Cop
-        MSG = 'When using `method_missing`, %<instructions>s.'.freeze
+      #
+      class MissingRespondToMissing < Cop
+        MSG =
+          'When using `method_missing`, define `respond_to_missing?`.'.freeze
 
         def on_def(node)
           return unless node.method?(:method_missing)
+          return if implements_respond_to_missing?(node)
 
-          check(node)
+          add_offense(node)
         end
         alias on_defs on_def
 
         private
 
-        def check(node)
-          return if calls_super?(node) && implements_respond_to_missing?(node)
-
-          add_offense(node)
-        end
-
-        def message(node)
-          instructions = []
-
-          unless implements_respond_to_missing?(node)
-            instructions << 'define `respond_to_missing?`'.freeze
-          end
-
-          unless calls_super?(node)
-            instructions << 'fall back on `super`'.freeze
-          end
-
-          format(MSG, instructions: instructions.join(' and '))
-        end
-
-        def calls_super?(node)
-          node.descendants.any?(&:zsuper_type?)
-        end
-
         def implements_respond_to_missing?(node)
           node.parent.each_child_node(node.type).any? do |sibling|
             sibling.method?(:respond_to_missing?)

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

@@ -22,6 +22,23 @@ module RuboCop
       #   if x > 10
       #   elsif x < 3
       #   end
+      #
+      # @example AllowInMultilineConditions: false (default)
+      #   # bad
+      #   if (x > 10 &&
+      #      y > 10)
+      #   end
+      #
+      #   # good
+      #    if x > 10 &&
+      #       y > 10
+      #    end
+      #
+      # @example AllowInMultilineConditions: true
+      #   # good
+      #   if (x > 10 &&
+      #      y > 10)
+      #   end
       class ParenthesesAroundCondition < Cop
         include SafeAssignment
         include Parentheses
@@ -52,8 +69,7 @@ module RuboCop
 
           control_op_condition(cond) do |first_child|
             return if modifier_op?(first_child)
-            return if parens_required?(node.condition)
-            return if safe_assignment?(cond) && safe_assignment_allowed?
+            return if parens_allowed?(cond)
 
             add_offense(cond)
           end
@@ -71,6 +87,16 @@ module RuboCop
           article = kw == 'while' ? 'a' : 'an'
           "Don't use parentheses around the condition of #{article} `#{kw}`."
         end
+
+        def parens_allowed?(node)
+          parens_required?(node) ||
+            (safe_assignment?(node) && safe_assignment_allowed?) ||
+            (node.multiline? && allow_multiline_conditions?)
+        end
+
+        def allow_multiline_conditions?
+          cop_config['AllowInMultilineConditions']
+        end
       end
     end
   end

data/lib/rubocop/node_pattern.rb

@@ -74,7 +74,7 @@ module RuboCop
   # You can nest arbitrarily deep:
   #
   #     # matches node parsed from 'Const = Class.new' or 'Const = Module.new':
-  #     '(casgn nil? const (send (const nil? {:Class :Module}) :new)))'
+  #     '(casgn nil? :Const (send (const nil? {:Class :Module}) :new))'
   #     # matches a node parsed from an 'if', with a '==' comparison,
   #     # and no 'else' branch:
   #     '(if (send _ :== _) _ nil?)'

data/lib/rubocop/processed_source.rb

@@ -106,10 +106,6 @@ module RuboCop
       comment_lines.include?(source_range.line)
     end
 
-    def comment_on_line?(line)
-      comments.any? { |c| c.loc.line == line }
-    end
-
     def comments_before_line(line)
       comments.select { |c| c.location.line <= line }
     end
@@ -127,6 +123,13 @@ module RuboCop
       lines[token.line]
     end
 
+    def line_indentation(line_number)
+      lines[line_number - 1]
+        .match(/^(\s*)/)[1]
+        .to_s
+        .length
+    end
+
     private
 
     def comment_lines
@@ -160,7 +163,7 @@ module RuboCop
       [ast, comments, tokens]
     end
 
-    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
     def parser_class(ruby_version)
       case ruby_version
       when 2.1
@@ -178,11 +181,14 @@ module RuboCop
       when 2.5
         require 'parser/ruby25'
         Parser::Ruby25
+      when 2.6
+        require 'parser/ruby26'
+        Parser::Ruby26
       else
         raise ArgumentError, "Unknown Ruby version: #{ruby_version.inspect}"
       end
     end
-    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength
 
     def create_parser(ruby_version)
       builder = RuboCop::AST::Builder.new