rubocop 0.87.1

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

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      class MethodCallWithArgsParentheses
+        # Style omit_parentheses
+        module OmitParentheses
+          TRAILING_WHITESPACE_REGEX = /\s+\Z/.freeze
+
+          def on_send(node)
+            return unless node.parenthesized?
+            return if node.implicit_call?
+            return if super_call_without_arguments?(node)
+            return if allowed_camel_case_method_call?(node)
+            return if legitimate_call_with_parentheses?(node)
+
+            add_offense(node, location: node.loc.begin.join(node.loc.end))
+          end
+          alias on_csend on_send
+          alias on_super on_send
+          alias on_yield on_send
+
+          def autocorrect(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 message(_node = nil)
+            'Omit parentheses for method calls with arguments.'
+          end
+
+          private
+
+          def super_call_without_arguments?(node)
+            node.super_type? && node.arguments.none?
+          end
+
+          def allowed_camel_case_method_call?(node)
+            node.camel_case_method? &&
+              (node.arguments.none? ||
+              cop_config['AllowParenthesesInCamelCaseMethod'])
+          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 legitimate_call_with_parentheses?(node)
+            call_in_literals?(node) ||
+              call_with_ambiguous_arguments?(node) ||
+              call_in_logical_operators?(node) ||
+              call_in_optional_arguments?(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? ||
+              node.parent.range_type? ||
+              splat?(node.parent) ||
+              ternary_if?(node.parent))
+          end
+
+          def call_in_logical_operators?(node)
+            parent = node.parent&.block_type? ? node.parent.parent : node.parent
+            parent &&
+              (logical_operator?(parent) ||
+              parent.send_type? &&
+              parent.arguments.any?(&method(:logical_operator?)))
+          end
+
+          def call_in_optional_arguments?(node)
+            node.parent &&
+              (node.parent.optarg_type? || node.parent.kwoptarg_type?)
+          end
+
+          def call_with_ambiguous_arguments?(node)
+            call_with_braced_block?(node) ||
+              call_as_argument_or_chain?(node) ||
+              hash_literal_in_arguments?(node) ||
+              node.descendants.any? do |n|
+                ambigious_literal?(n) || logical_operator?(n) ||
+                  call_with_braced_block?(n)
+              end
+          end
+
+          def call_with_braced_block?(node)
+            (node.send_type? || node.super_type?) &&
+              node.block_node && node.block_node.braces?
+          end
+
+          def call_as_argument_or_chain?(node)
+            node.parent &&
+              (node.parent.send_type? && !assigned_before?(node.parent, node) ||
+              node.parent.csend_type? || node.parent.super_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 false unless cop_config['AllowParenthesesInChaining']
+
+            previous = node.descendants.first
+            return false unless previous&.send_type?
+
+            previous.parenthesized? ||
+              allowed_chained_call_with_parentheses?(previous)
+          end
+
+          def ambigious_literal?(node)
+            splat?(node) || ternary_if?(node) || regexp_slash_literal?(node) ||
+              unary_literal?(node)
+          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
+
+          def regexp_slash_literal?(node)
+            node.regexp_type? && node.loc.begin.source == '/'
+          end
+
+          def unary_literal?(node)
+            node.numeric_type? && node.sign? ||
+              node.parent&.send_type? && node.parent&.unary_operation?
+          end
+
+          def assigned_before?(node, target)
+            node.assignment? &&
+              node.loc.operator.begin < target.loc.begin
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      class MethodCallWithArgsParentheses
+        # Style require_parentheses
+        module RequireParentheses
+          def on_send(node)
+            return if ignored_method?(node.method_name)
+            return if matches_ignored_pattern?(node.method_name)
+            return if eligible_for_parentheses_omission?(node)
+            return unless node.arguments? && !node.parenthesized?
+
+            add_offense(node)
+          end
+          alias on_csend on_send
+          alias on_super on_send
+          alias on_yield on_send
+
+          def autocorrect(node)
+            lambda do |corrector|
+              corrector.replace(args_begin(node), '(')
+
+              corrector.insert_after(args_end(node), ')') unless args_parenthesized?(node)
+            end
+          end
+
+          def message(_node = nil)
+            'Use parentheses for method calls with arguments.'
+          end
+
+          private
+
+          def eligible_for_parentheses_omission?(node)
+            node.operator_method? || node.setter_method? || ignored_macro?(node)
+          end
+
+          def included_macros_list
+            cop_config.fetch('IncludedMacros', []).map(&:to_sym)
+          end
+
+          def ignored_macro?(node)
+            cop_config['IgnoreMacros'] &&
+              node.macro? &&
+              !included_macros_list.include?(node.method_name)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for unwanted parentheses in parameterless method calls.
+      #
+      # @example
+      #   # bad
+      #   object.some_method()
+      #
+      #   # good
+      #   object.some_method
+      class MethodCallWithoutArgsParentheses < Cop
+        include IgnoredMethods
+
+        MSG = 'Do not use parentheses for method calls with ' \
+              'no arguments.'
+
+        def on_send(node)
+          return if ineligible_node?(node)
+          return unless !node.arguments? && node.parenthesized?
+          return if ignored_method?(node.method_name)
+          return if same_name_assignment?(node)
+
+          add_offense(node, location: node.loc.begin.join(node.loc.end))
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(node.loc.begin)
+            corrector.remove(node.loc.end)
+          end
+        end
+
+        private
+
+        def ineligible_node?(node)
+          node.camel_case_method? || node.implicit_call? || node.prefix_not?
+        end
+
+        def same_name_assignment?(node)
+          any_assignment?(node) do |asgn_node|
+            next variable_in_mass_assignment?(node.method_name, asgn_node) if asgn_node.masgn_type?
+
+            asgn_node.loc.name.source == node.method_name.to_s
+          end
+        end
+
+        def any_assignment?(node)
+          node.each_ancestor(*AST::Node::ASSIGNMENTS).any? do |asgn_node|
+            # `obj.method = value` parses as (send ... :method= ...), and will
+            # not be returned as an `asgn_node` here, however,
+            # `obj.method ||= value` parses as (or-asgn (send ...) ...)
+            # which IS an `asgn_node`. Similarly, `obj.method += value` parses
+            # as (op-asgn (send ...) ...), which is also an `asgn_node`.
+            if asgn_node.shorthand_asgn?
+              asgn_node, _value = *asgn_node
+              next if asgn_node.send_type?
+            end
+
+            yield asgn_node
+          end
+        end
+
+        def variable_in_mass_assignment?(variable_name, node)
+          mlhs_node, _mrhs_node = *node
+          var_nodes = *mlhs_node
+
+          var_nodes.any? { |n| n.to_a.first == variable_name }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for methods called on a do...end block. The point of
+      # this check is that it's easy to miss the call tacked on to the block
+      # when reading code.
+      #
+      # @example
+      #
+      #   a do
+      #     b
+      #   end.c
+      class MethodCalledOnDoEndBlock < Cop
+        include RangeHelp
+
+        MSG = 'Avoid chaining a method call on a do...end block.'
+
+        def on_block(node)
+          # If the method that is chained on the do...end block is itself a
+          # method with a block, we allow it. It's pretty safe to assume that
+          # these calls are not missed by anyone reading code. We also want to
+          # avoid double reporting of offenses checked by the
+          # MultilineBlockChain cop.
+          ignore_node(node.send_node)
+        end
+
+        def on_send(node)
+          return if ignored_node?(node)
+
+          receiver = node.receiver
+
+          return unless receiver&.block_type? &&
+                        receiver.loc.end.is?('end')
+
+          range = range_between(receiver.loc.end.begin_pos,
+                                node.source_range.end_pos)
+
+          add_offense(nil, location: range)
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

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

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for parentheses around the arguments in method
+      # definitions. Both instance and class/singleton methods are checked.
+      #
+      # @example EnforcedStyle: require_parentheses (default)
+      #   # The `require_parentheses` style requires method definitions
+      #   # to always use parentheses
+      #
+      #   # bad
+      #   def bar num1, num2
+      #     num1 + num2
+      #   end
+      #
+      #   def foo descriptive_var_name,
+      #           another_descriptive_var_name,
+      #           last_descriptive_var_name
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   def bar(num1, num2)
+      #     num1 + num2
+      #   end
+      #
+      #   def foo(descriptive_var_name,
+      #           another_descriptive_var_name,
+      #           last_descriptive_var_name)
+      #     do_something
+      #   end
+      #
+      # @example EnforcedStyle: require_no_parentheses
+      #   # The `require_no_parentheses` style requires method definitions
+      #   # to never use parentheses
+      #
+      #   # bad
+      #   def bar(num1, num2)
+      #     num1 + num2
+      #   end
+      #
+      #   def foo(descriptive_var_name,
+      #           another_descriptive_var_name,
+      #           last_descriptive_var_name)
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   def bar num1, num2
+      #     num1 + num2
+      #   end
+      #
+      #   def foo descriptive_var_name,
+      #           another_descriptive_var_name,
+      #           last_descriptive_var_name
+      #     do_something
+      #   end
+      #
+      # @example EnforcedStyle: require_no_parentheses_except_multiline
+      #   # The `require_no_parentheses_except_multiline` style prefers no
+      #   # parentheses when method definition arguments fit on single line,
+      #   # but prefers parentheses when arguments span multiple lines.
+      #
+      #   # bad
+      #   def bar(num1, num2)
+      #     num1 + num2
+      #   end
+      #
+      #   def foo descriptive_var_name,
+      #           another_descriptive_var_name,
+      #           last_descriptive_var_name
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   def bar num1, num2
+      #     num1 + num2
+      #   end
+      #
+      #   def foo(descriptive_var_name,
+      #           another_descriptive_var_name,
+      #           last_descriptive_var_name)
+      #     do_something
+      #   end
+      class MethodDefParentheses < Cop
+        include ConfigurableEnforcedStyle
+        include RangeHelp
+
+        MSG_PRESENT = 'Use def without parentheses.'
+        MSG_MISSING = 'Use def with parentheses when there are ' \
+                      'parameters.'
+
+        def on_def(node)
+          args = node.arguments
+
+          if require_parentheses?(args)
+            if arguments_without_parentheses?(node)
+              missing_parentheses(node)
+            else
+              correct_style_detected
+            end
+          elsif parentheses?(args)
+            unwanted_parentheses(args)
+          else
+            correct_style_detected
+          end
+        end
+        alias on_defs on_def
+
+        def autocorrect(node)
+          lambda do |corrector|
+            if node.args_type?
+              # offense is registered on args node when parentheses are unwanted
+              correct_arguments(node, corrector)
+            else
+              correct_definition(node, corrector)
+            end
+          end
+        end
+
+        private
+
+        def correct_arguments(arg_node, corrector)
+          corrector.replace(arg_node.loc.begin, ' ')
+          corrector.remove(arg_node.loc.end)
+        end
+
+        def correct_definition(def_node, corrector)
+          arguments_range = def_node.arguments.source_range
+          args_with_space = range_with_surrounding_space(range: arguments_range,
+                                                         side: :left)
+          leading_space = range_between(args_with_space.begin_pos,
+                                        arguments_range.begin_pos)
+          corrector.replace(leading_space, '(')
+          corrector.insert_after(arguments_range, ')')
+        end
+
+        def require_parentheses?(args)
+          style == :require_parentheses ||
+            (style == :require_no_parentheses_except_multiline &&
+             args.multiline?)
+        end
+
+        def arguments_without_parentheses?(node)
+          node.arguments? && !parentheses?(node.arguments)
+        end
+
+        def missing_parentheses(node)
+          location = node.arguments.source_range
+
+          add_offense(node, location: location, message: MSG_MISSING) do
+            unexpected_style_detected(:require_no_parentheses)
+          end
+        end
+
+        def unwanted_parentheses(args)
+          add_offense(args, message: MSG_PRESENT) do
+            unexpected_style_detected(:require_parentheses)
+          end
+        end
+      end
+    end
+  end
+end