rubocop 0.60.0 → 0.61.0

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

@@ -3,11 +3,26 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks presence of parentheses in method calls containing
-      # parameters. By default, macro methods are ignored. Additional methods
-      # can be added to the `IgnoredMethods` list.
+      # This cop enforces the presence (default) or absence of parentheses in
+      # method calls containing parameters.
+      #
+      # In the default style (require_parentheses), macro methods are ignored.
+      # Additional methods can be added to the `IgnoredMethods` list. This
+      # option is valid only in the default style.
+      #
+      # In the alternative style (omit_parentheses), there are two additional
+      # options.
+      #
+      # 1. `AllowParenthesesInChaining` is `false` by default. Setting it to
+      #    `true` allows the presence of parentheses in the last call during
+      #    method chaining.
+      #
+      # 2. `AllowParenthesesInMultilineCall` is `false` by default. Setting it
+      #     to `true` allows the presence of parentheses in multi-line method
+      #     calls.
+      #
+      # @example EnforcedStyle: require_parentheses
       #
-      # @example
       #
       #   # bad
       #   array.delete e
@@ -39,21 +54,114 @@ module RuboCop
       #   class Foo
       #     bar :baz
       #   end
+      #
+      # @example EnforcedStyle: omit_parentheses
+      #
+      #   # bad
+      #   array.delete(e)
+      #
+      #   # good
+      #   array.delete e
+      #
+      #   # bad
+      #   foo.enforce(strict: true)
+      #
+      #   # good
+      #   foo.enforce strict: true
+      #
+      #   # AllowParenthesesInMultilineCall: false (default)
+      #
+      #   # bad
+      #   foo.enforce(
+      #     strict: true
+      #   )
+      #
+      #   # good
+      #   foo.enforce \
+      #     strict: true
+      #
+      #   # AllowParenthesesInMultilineCall: true
+      #
+      #   # good
+      #   foo.enforce(
+      #     strict: true
+      #   )
+      #
+      #   # good
+      #   foo.enforce \
+      #     strict: true
+      #
+      #   # AllowParenthesesInChaining: false (default)
+      #
+      #   # bad
+      #   foo().bar(1)
+      #
+      #   # good
+      #   foo().bar 1
+      #
+      #   # AllowParenthesesInChaining: true
+      #
+      #   # good
+      #   foo().bar(1)
+      #
+      #   # good
+      #   foo().bar 1
       class MethodCallWithArgsParentheses < Cop
+        include ConfigurableEnforcedStyle
         include IgnoredMethods
 
-        MSG = 'Use parentheses for method calls with arguments.'.freeze
+        TRAILING_WHITESPACE_REGEX = /\s+\Z/.freeze
 
         def on_send(node)
-          return if ignored_method?(node)
-          return unless node.arguments? && !node.parenthesized?
-
-          add_offense(node)
+          case style
+          when :require_parentheses
+            add_offense_for_require_parentheses(node)
+          when :omit_parentheses
+            add_offense_for_omit_parentheses(node)
+          end
         end
         alias on_super on_send
         alias on_yield on_send
 
         def autocorrect(node)
+          case style
+          when :require_parentheses
+            autocorrect_for_require_parentheses(node)
+          when :omit_parentheses
+            autocorrect_for_omit_parentheses(node)
+          end
+        end
+
+        def message(_node = nil)
+          case style
+          when :require_parentheses
+            'Use parentheses for method calls with arguments.'.freeze
+          when :omit_parentheses
+            'Omit parentheses for method calls with arguments.'.freeze
+          end
+        end
+
+        private
+
+        def add_offense_for_require_parentheses(node)
+          return if ignored_method?(node.method_name)
+          return if eligible_for_parentheses_omission?(node)
+          return unless node.arguments? && !node.parenthesized?
+
+          add_offense(node)
+        end
+
+        def add_offense_for_omit_parentheses(node)
+          return unless node.parenthesized?
+          return if node.implicit_call?
+          return if super_call_without_arguments?(node)
+          return if camel_case_method_call_without_arguments?(node)
+          return if eligible_for_parentheses_presence?(node)
+
+          add_offense(node, location: node.loc.begin.join(node.loc.end))
+        end
+
+        def autocorrect_for_require_parentheses(node)
           lambda do |corrector|
             corrector.replace(args_begin(node), '(')
 
@@ -63,16 +171,23 @@ module RuboCop
           end
         end
 
-        private
+        def autocorrect_for_omit_parentheses(node)
+          lambda do |corrector|
+            if parentheses_at_the_end_of_multiline_call?(node)
+              corrector.replace(args_begin(node), ' \\')
+            else
+              corrector.replace(args_begin(node), ' ')
+            end
+            corrector.remove(node.loc.end)
+          end
+        end
 
-        def ignored_method?(node)
-          node.operator_method? || node.setter_method? ||
-            ignore_macros? && node.macro? ||
-            super(node.method_name)
+        def eligible_for_parentheses_omission?(node)
+          node.operator_method? || node.setter_method? || ignore_macros?(node)
         end
 
-        def ignore_macros?
-          cop_config['IgnoreMacros']
+        def ignore_macros?(node)
+          cop_config['IgnoreMacros'] && node.macro?
         end
 
         def args_begin(node)
@@ -94,6 +209,96 @@ module RuboCop
           first_node = node.arguments.first
           first_node.begin_type? && first_node.parenthesized_call?
         end
+
+        def parentheses_at_the_end_of_multiline_call?(node)
+          node.multiline? &&
+            node.loc.begin.source_line
+                .gsub(TRAILING_WHITESPACE_REGEX, '')
+                .end_with?('(')
+        end
+
+        def super_call_without_arguments?(node)
+          node.super_type? && node.arguments.none?
+        end
+
+        def camel_case_method_call_without_arguments?(node)
+          node.camel_case_method? && node.arguments.none?
+        end
+
+        def eligible_for_parentheses_presence?(node)
+          call_in_literals?(node) ||
+            call_with_ambiguous_arguments?(node) ||
+            call_in_logical_operators?(node) ||
+            allowed_multiline_call_with_parentheses?(node) ||
+            allowed_chained_call_with_parentheses?(node)
+        end
+
+        def call_in_literals?(node)
+          node.parent &&
+            (node.parent.pair_type? ||
+             node.parent.array_type? ||
+             ternary_if?(node.parent))
+        end
+
+        def call_in_logical_operators?(node)
+          node.parent &&
+            (logical_operator?(node.parent) ||
+             node.parent.descendants.any?(&method(:logical_operator?)))
+        end
+
+        def call_with_ambiguous_arguments?(node)
+          call_with_braced_block?(node) ||
+            call_as_argument?(node) ||
+            hash_literal_in_arguments?(node) ||
+            node.descendants.any? do |n|
+              splat?(n) || ternary_if?(n) || logical_operator?(n)
+            end
+        end
+
+        def call_with_braced_block?(node)
+          node.block_node && node.block_node.braces?
+        end
+
+        def call_as_argument?(node)
+          node.parent && node.parent.send_type?
+        end
+
+        def hash_literal_in_arguments?(node)
+          node.arguments.any? do |n|
+            hash_literal?(n) ||
+              n.send_type? && node.descendants.any?(&method(:hash_literal?))
+          end
+        end
+
+        def allowed_multiline_call_with_parentheses?(node)
+          cop_config['AllowParenthesesInMultilineCall'] && node.multiline?
+        end
+
+        def allowed_chained_call_with_parentheses?(node)
+          return unless cop_config['AllowParenthesesInChaining']
+
+          previous = node.descendants.first
+          return false unless previous && previous.send_type?
+
+          previous.parenthesized? ||
+            allowed_chained_call_with_parentheses?(previous)
+        end
+
+        def splat?(node)
+          node.splat_type? || node.kwsplat_type? || node.block_pass_type?
+        end
+
+        def ternary_if?(node)
+          node.if_type? && node.ternary?
+        end
+
+        def logical_operator?(node)
+          (node.and_type? || node.or_type?) && node.logical_operator?
+        end
+
+        def hash_literal?(node)
+          node.hash_type? && node.braces?
+        end
       end
     end
   end

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

@@ -68,7 +68,7 @@ module RuboCop
 
           message = message_node && message_node.source
 
-          correction = exception_node.const_name.to_s
+          correction = exception_node.source
           correction = "#{correction}, #{message}" if message
 
           "#{node.method_name} #{correction}"

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

@@ -83,6 +83,7 @@ module RuboCop
       #   x =~ /home\//
       class RegexpLiteral < Cop
         include ConfigurableEnforcedStyle
+        include RangeHelp
 
         MSG_USE_SLASHES = 'Use `//` around regular expression.'.freeze
         MSG_USE_PERCENT_R = 'Use `%r` around regular expression.'.freeze
@@ -96,17 +97,9 @@ module RuboCop
         end
 
         def autocorrect(node)
-          return if contains_slash?(node)
-
-          replacement = if slash_literal?(node)
-                          ['%r', ''].zip(preferred_delimiters).map(&:join)
-                        else
-                          %w[/ /]
-                        end
-
           lambda do |corrector|
-            corrector.replace(node.loc.begin, replacement.first)
-            corrector.replace(node.loc.end, replacement.last)
+            correct_delimiters(node, corrector)
+            correct_inner_slashes(node, corrector)
           end
         end
 
@@ -169,6 +162,65 @@ module RuboCop
           config.for_cop('Style/PercentLiteralDelimiters') \
             ['PreferredDelimiters']['%r'].split(//)
         end
+
+        def correct_delimiters(node, corrector)
+          replacement = calculate_replacement(node)
+          corrector.replace(node.loc.begin, replacement.first)
+          corrector.replace(node.loc.end, replacement.last)
+        end
+
+        def correct_inner_slashes(node, corrector)
+          regexp_begin = node.loc.begin.end_pos
+
+          inner_slash_indices(node).each do |index|
+            start = regexp_begin + index
+
+            corrector.replace(
+              range_between(
+                start,
+                start + inner_slash_before_correction(node).length
+              ),
+              inner_slash_after_correction(node)
+            )
+          end
+        end
+
+        def inner_slash_indices(node)
+          text    = node_body(node)
+          pattern = inner_slash_before_correction(node)
+          index   = -1
+          indices = []
+
+          while (index = text.index(pattern, index + 1))
+            indices << index
+          end
+
+          indices
+        end
+
+        def inner_slash_before_correction(node)
+          inner_slash_for(node.loc.begin.source)
+        end
+
+        def inner_slash_after_correction(node)
+          inner_slash_for(calculate_replacement(node).first)
+        end
+
+        def inner_slash_for(opening_delimiter)
+          if ['/', '%r/'].include?(opening_delimiter)
+            '\/'
+          else
+            '/'
+          end
+        end
+
+        def calculate_replacement(node)
+          if slash_literal?(node)
+            ['%r', ''].zip(preferred_delimiters).map(&:join)
+          else
+            %w[/ /]
+          end
+        end
       end
     end
   end

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

@@ -47,7 +47,7 @@ module RuboCop
           lambda do |corrector|
             if node.ternary?
               corrector.replace(range_of_offense(node), '||')
-            elsif node.modifier_form?
+            elsif node.modifier_form? || !node.else_branch
               corrector.replace(node.source_range, node.if_branch.source)
             else
               corrected = make_ternary_form(node)
@@ -60,7 +60,7 @@ module RuboCop
         private
 
         def message(node)
-          if node.modifier_form?
+          if node.modifier_form? || !node.else_branch
             UNNEEDED_CONDITION
           else
             MSG

data/lib/rubocop/cop/variable_force.rb

@@ -50,8 +50,8 @@ module RuboCop
 
       ZERO_ARITY_SUPER_TYPE = :zsuper
 
-      TWISTED_SCOPE_TYPES = %i[block class sclass defs].freeze
-      SCOPE_TYPES = (TWISTED_SCOPE_TYPES + %i[module def]).freeze
+      TWISTED_SCOPE_TYPES = %i[block class sclass defs module].freeze
+      SCOPE_TYPES = (TWISTED_SCOPE_TYPES + [:def]).freeze
 
       SEND_TYPE = :send
 
@@ -196,6 +196,7 @@ module RuboCop
         regexp.named_captures.keys
       end
 
+      # rubocop:disable Metrics/AbcSize
       def process_variable_operator_assignment(node)
         if LOGICAL_OPERATOR_ASSIGNMENT_TYPES.include?(node.type)
           asgn_node, rhs_node = *node
@@ -232,6 +233,7 @@ module RuboCop
 
         skip_children!
       end
+      # rubocop:enable Metrics/AbcSize
 
       def process_variable_multiple_assignment(node)
         lhs_node, rhs_node = *node

data/lib/rubocop/cop/variable_force/variable.rb

@@ -37,6 +37,7 @@ module RuboCop
           !@references.empty?
         end
 
+        # rubocop:disable Metrics/AbcSize
         def reference!(node)
           reference = Reference.new(node, @scope)
           @references << reference
@@ -56,6 +57,7 @@ module RuboCop
             end
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         def capture_with_block!
           @captured_by_block = true

data/lib/rubocop/magic_comment.rb

@@ -134,7 +134,7 @@ module RuboCop
       OPERATOR  = ':'.freeze
 
       def encoding
-        match('encoding')
+        match('(?:en)?coding')
       end
 
       private