rubbycop 0.49.0

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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.
+      #
+      # @example
+      #
+      #   # bad
+      #   array.delete e
+      #
+      #   # good
+      #   array.delete(e)
+      #
+      #   # good
+      #   # Operators don't need parens
+      #   foo == bar
+      #
+      #   # good
+      #   # Setter methods don't need parens
+      #   foo.bar = baz
+      #
+      #   # okay with `puts` listed in `IgnoredMethods`
+      #   puts 'test'
+      #
+      #   # IgnoreMacros: true (default)
+      #
+      #   # good
+      #   class Foo
+      #     bar :baz
+      #   end
+      #
+      #   # IgnoreMacros: false
+      #
+      #   # bad
+      #   class Foo
+      #     bar :baz
+      #   end
+      class MethodCallWithArgsParentheses < Cop
+        MSG = 'Use parentheses for method calls with arguments.'.freeze
+
+        def on_send(node)
+          return if ignored_method?(node)
+          return unless node.arguments? && !node.parenthesized?
+
+          add_offense(node, :selector)
+        end
+
+        def on_super(node)
+          # super nodetype implies call with arguments.
+          return if parentheses?(node)
+
+          add_offense(node, :keyword)
+        end
+
+        def on_yield(node)
+          args = node.children
+          return if args.empty?
+          return if parentheses?(node)
+
+          add_offense(node, :keyword)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(args_begin(node), '(')
+            corrector.insert_after(args_end(node), ')')
+          end
+        end
+
+        private
+
+        def ignored_method?(node)
+          node.operator_method? || node.setter_method? ||
+            ignore_macros? && node.macro? ||
+            ignored_list.include?(node.method_name)
+        end
+
+        def ignored_list
+          cop_config['IgnoredMethods'].map(&:to_sym)
+        end
+
+        def ignore_macros?
+          cop_config['IgnoreMacros']
+        end
+
+        def parentheses?(node)
+          node.loc.begin
+        end
+
+        def args_begin(node)
+          loc = node.loc
+          selector =
+            node.super_type? || node.yield_type? ? loc.keyword : loc.selector
+          selector.end.resize(1)
+        end
+
+        def args_end(node)
+          node.loc.expression.end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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
+        MSG = 'Do not use parentheses for method calls with ' \
+              'no arguments.'.freeze
+
+        ASGN_NODES = %i[lvasgn masgn] + SHORTHAND_ASGN_NODES
+
+        def on_send(node)
+          return if node.camel_case_method?
+          return unless !node.arguments? && node.parenthesized?
+          return if same_name_assignment?(node)
+          return if node.implicit_call?
+          return if node.keyword_not?
+
+          add_offense(node, :begin)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.remove(node.loc.begin)
+            corrector.remove(node.loc.end)
+          end
+        end
+
+        private
+
+        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(*ASGN_NODES).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.or_asgn_type? || asgn_node.and_asgn_type? ||
+               asgn_node.op_asgn_type?
+              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.map { |n| n.to_a.first }.include?(variable_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  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
+        MSG = 'Avoid chaining a method call on a do...end block.'.freeze
+
+        def on_block(node)
+          method, _args, _body = *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(method)
+        end
+
+        def on_send(node)
+          return if ignored_node?(node)
+
+          receiver = node.receiver
+
+          return unless receiver && receiver.block_type? &&
+                        receiver.loc.end.is?('end')
+
+          range = range_between(receiver.loc.end.begin_pos,
+                                node.source_range.end_pos)
+
+          add_offense(nil, range)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cops checks for parentheses around the arguments in method
+      # definitions. Both instance and class/singleton methods are checked.
+      class MethodDefParentheses < Cop
+        include OnMethodDef
+        include ConfigurableEnforcedStyle
+
+        def on_method_def(node, _method_name, args, _body)
+          if require_parentheses?(args)
+            if arguments_without_parentheses?(args)
+              missing_parentheses(node, args)
+            else
+              correct_style_detected
+            end
+          elsif parentheses?(args)
+            unwanted_parentheses(args)
+          else
+            correct_style_detected
+          end
+        end
+
+        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 = args_node(node).source_range
+              args_with_space = range_with_surrounding_space(args_expr, :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?(args)
+          arguments?(args) && !parentheses?(args)
+        end
+
+        def missing_parentheses(node, args)
+          add_offense(node, args.source_range,
+                      'Use def with parentheses when there are parameters.') do
+            unexpected_style_detected(:require_no_parentheses)
+          end
+        end
+
+        def unwanted_parentheses(args)
+          add_offense(args, :expression, 'Use def without parentheses.') do
+            unexpected_style_detected(:require_parentheses)
+          end
+        end
+
+        def args_node(def_node)
+          if def_node.def_type?
+            _method_name, args, _body = *def_node
+          else
+            _scope, _method_name, args, _body = *def_node
+          end
+          args
+        end
+
+        def arguments?(args)
+          !args.children.empty?
+        end
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/style/method_missing.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop checks for the presence of `method_missing` without also
+      # defining `respond_to_missing?` and falling back on `super`.
+      #
+      # @example
+      #   #bad
+      #   def method_missing(...)
+      #     ...
+      #   end
+      #
+      #   #good
+      #   def respond_to_missing?(...)
+      #     ...
+      #   end
+      #
+      #   def method_missing(...)
+      #     ...
+      #     super
+      #   end
+      class MethodMissing < Cop
+        include OnMethodDef
+
+        MSG = 'When using `method_missing`, %s.'.freeze
+
+        def on_method_def(node, method_name, _args, _body)
+          return unless method_name == :method_missing
+
+          check(node)
+        end
+
+        private
+
+        def check(node)
+          return if calls_super?(node) && implements_respond_to_missing?(node)
+
+          add_offense(node, :expression)
+        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.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|
+            if node.def_type?
+              respond_to_missing_def?(sibling)
+            elsif node.defs_type?
+              respond_to_missing_defs?(sibling)
+            end
+          end
+        end
+
+        def_node_matcher :respond_to_missing_def?, <<-PATTERN
+          (def :respond_to_missing? (...) ...)
+        PATTERN
+
+        def_node_matcher :respond_to_missing_defs?, <<-PATTERN
+          (defs (self) :respond_to_missing? (...) ...)
+        PATTERN
+      end
+    end
+  end
+end

data/lib/rubbycop/cop/style/method_name.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # This cop makes sure that all methods use the configured style,
+      # snake_case or camelCase, for their names. Some special arrangements
+      # have to be made for operator methods.
+      class MethodName < Cop
+        include ConfigurableNaming
+
+        def on_def(node)
+          name, = *node
+          check_name(node, name, node.loc.name)
+        end
+
+        def on_defs(node)
+          _object, name, = *node
+          check_name(node, name, node.loc.name)
+        end
+
+        def message(style)
+          format('Use %s for method names.', style)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RubbyCop
+  module Cop
+    module Style
+      # Checks for `if` expressions that do not have an `else` branch.
+      # SupportedStyles
+      #
+      # if
+      # @example
+      #   # bad
+      #   if condition
+      #     statement
+      #   end
+      #
+      # case
+      # @example
+      #   # bad
+      #   case var
+      #   when condition
+      #     statement
+      #   end
+      #
+      # @example
+      #   # good
+      #   if condition
+      #     statement
+      #   else
+      #   # the content of the else branch will be determined by Style/EmptyElse
+      #   end
+      class MissingElse < Cop
+        include OnNormalIfUnless
+        include ConfigurableEnforcedStyle
+
+        MSG = '`%s` condition requires an `else`-clause.'.freeze
+        MSG_NIL = '`%s` condition requires an `else`-clause with ' \
+                  '`nil` in it.'.freeze
+        MSG_EMPTY = '`%s` condition requires an empty `else`-clause.'.freeze
+
+        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, :expression, format(MSG_NIL, node.type))
+            elsif empty_else_style == :nil
+              add_offense(node, :expression, format(MSG_EMPTY, node.type))
+            end
+          end
+
+          add_offense(node, :expression, format(MSG, 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