rubocop 0.75.1

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

@@ -0,0 +1,77 @@
+# 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|
+            if asgn_node.masgn_type?
+              next variable_in_mass_assignment?(node.method_name, asgn_node)
+            end
+
+            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,158 @@
+# 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
+              corrector.replace(node.loc.begin, ' ')
+              corrector.remove(node.loc.end)
+            else
+              args_expr = node.arguments.source_range
+              args_with_space = range_with_surrounding_space(range: args_expr,
+                                                             side: :left)
+              just_space = range_between(args_with_space.begin_pos,
+                                         args_expr.begin_pos)
+              corrector.replace(just_space, '(')
+              corrector.insert_after(args_expr, ')')
+            end
+          end
+        end
+
+        private
+
+        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

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`.'
+
+        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/min_max.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for potential uses of `Enumerable#minmax`.
+      #
+      # @example
+      #
+      #   # bad
+      #   bar = [foo.min, foo.max]
+      #   return foo.min, foo.max
+      #
+      #   # good
+      #   bar = foo.minmax
+      #   return foo.minmax
+      class MinMax < Cop
+        MSG = 'Use `%<receiver>s.minmax` instead of `%<offender>s`.'
+
+        def on_array(node)
+          min_max_candidate(node) do |receiver|
+            offender = offending_range(node)
+
+            add_offense(node, location: offender,
+                              message: message(offender, receiver))
+          end
+        end
+        alias on_return on_array
+
+        def autocorrect(node)
+          receiver = node.children.first.receiver
+
+          lambda do |corrector|
+            corrector.replace(offending_range(node),
+                              "#{receiver.source}.minmax")
+          end
+        end
+
+        private
+
+        def_node_matcher :min_max_candidate, <<~PATTERN
+          ({array return} (send [$_receiver !nil?] :min) (send [$_receiver !nil?] :max))
+        PATTERN
+
+        def message(offender, receiver)
+          format(MSG, offender: offender.source,
+                      receiver: receiver.source)
+        end
+
+        def offending_range(node)
+          case node.type
+          when :return
+            argument_range(node)
+          else
+            node.loc.expression
+          end
+        end
+
+        def argument_range(node)
+          first_argument_range = node.children.first.loc.expression
+          last_argument_range  = node.children.last.loc.expression
+
+          first_argument_range.join(last_argument_range)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for `if` expressions that do not have an `else` branch.
+      #
+      # Supported styles are: if, case, both.
+      #
+      # @example EnforcedStyle: if
+      #   # warn when an `if` expression is missing an `else` branch.
+      #
+      #   # bad
+      #   if condition
+      #     statement
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   else
+      #     # the content of `else` branch will be determined by Style/EmptyElse
+      #   end
+      #
+      #   # good
+      #   case var
+      #   when condition
+      #     statement
+      #   end
+      #
+      #   # good
+      #   case var
+      #   when condition
+      #     statement
+      #   else
+      #     # the content of `else` branch will be determined by Style/EmptyElse
+      #   end
+      #
+      # @example EnforcedStyle: case
+      #   # warn when a `case` expression is missing an `else` branch.
+      #
+      #   # bad
+      #   case var
+      #   when condition
+      #     statement
+      #   end
+      #
+      #   # good
+      #   case var
+      #   when condition
+      #     statement
+      #   else
+      #     # the content of `else` branch will be determined by Style/EmptyElse
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   else
+      #     # the content of `else` branch will be determined by Style/EmptyElse
+      #   end
+      #
+      # @example EnforcedStyle: both (default)
+      #   # warn when an `if` or `case` expression is missing an `else` branch.
+      #
+      #   # bad
+      #   if condition
+      #     statement
+      #   end
+      #
+      #   # bad
+      #   case var
+      #   when condition
+      #     statement
+      #   end
+      #
+      #   # good
+      #   if condition
+      #     statement
+      #   else
+      #     # the content of `else` branch will be determined by Style/EmptyElse
+      #   end
+      #
+      #   # good
+      #   case var
+      #   when condition
+      #     statement
+      #   else
+      #     # the content of `else` branch will be determined by Style/EmptyElse
+      #   end
+      class MissingElse < Cop
+        include OnNormalIfUnless
+        include ConfigurableEnforcedStyle
+
+        MSG = '`%<type>s` condition requires an `else`-clause.'
+        MSG_NIL = '`%<type>s` condition requires an `else`-clause with ' \
+                  '`nil` in it.'
+        MSG_EMPTY = '`%<type>s` condition requires an empty ' \
+                    '`else`-clause.'
+
+        def on_normal_if_unless(node)
+          return if case_style?
+          return if unless_else_cop_enabled? && node.unless?
+
+          check(node)
+        end
+
+        def on_case(node)
+          return if if_style?
+
+          check(node)
+        end
+
+        private
+
+        def check(node)
+          return if node.else?
+
+          if empty_else_cop_enabled?
+            if empty_else_style == :empty
+              add_offense(node)
+            elsif empty_else_style == :nil
+              add_offense(node)
+            end
+          end
+
+          add_offense(node)
+        end
+
+        def message(node)
+          template = case empty_else_style
+                     when :empty
+                       MSG_NIL
+                     when :nil
+                       MSG_EMPTY
+                     else
+                       MSG
+                     end
+
+          format(template, type: node.type)
+        end
+
+        def if_style?
+          style == :if
+        end
+
+        def case_style?
+          style == :case
+        end
+
+        def unless_else_cop_enabled?
+          unless_else_config.fetch('Enabled')
+        end
+
+        def unless_else_config
+          config.for_cop('Style/UnlessElse')
+        end
+
+        def empty_else_cop_enabled?
+          empty_else_config.fetch('Enabled')
+        end
+
+        def empty_else_style
+          return unless empty_else_config.key?('EnforcedStyle')
+
+          empty_else_config['EnforcedStyle'].to_sym
+        end
+
+        def empty_else_config
+          config.for_cop('Style/EmptyElse')
+        end
+      end
+    end
+  end
+end