rubocop 0.87.1

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

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for the presence of `method_missing` without also
+      # defining `respond_to_missing?`.
+      #
+      # @example
+      #   #bad
+      #   def method_missing(name, *args)
+      #     # ...
+      #   end
+      #
+      #   #good
+      #   def respond_to_missing?(name, include_private)
+      #     # ...
+      #   end
+      #
+      #   def method_missing(name, *args)
+      #     # ...
+      #   end
+      #
+      class MissingRespondToMissing < Cop
+        MSG =
+          'When using `method_missing`, define `respond_to_missing?`.'
+
+        def on_def(node)
+          return unless node.method?(:method_missing)
+          return if implements_respond_to_missing?(node)
+
+          add_offense(node)
+        end
+        alias on_defs on_def
+
+        private
+
+        def implements_respond_to_missing?(node)
+          node.parent.each_child_node(node.type).any? do |sibling|
+            sibling.method?(:respond_to_missing?)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for grouping of mixins in `class` and `module` bodies.
+      # By default it enforces mixins to be placed in separate declarations,
+      # but it can be configured to enforce grouping them in one declaration.
+      #
+      # @example EnforcedStyle: separated (default)
+      #   # bad
+      #   class Foo
+      #     include Bar, Qox
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     include Qox
+      #     include Bar
+      #   end
+      #
+      # @example EnforcedStyle: grouped
+      #   # bad
+      #   class Foo
+      #     extend Bar
+      #     extend Qox
+      #   end
+      #
+      #   # good
+      #   class Foo
+      #     extend Qox, Bar
+      #   end
+      class MixinGrouping < Cop
+        include ConfigurableEnforcedStyle
+
+        MIXIN_METHODS = %i[extend include prepend].freeze
+        MSG = 'Put `%<mixin>s` mixins in %<suffix>s.'
+
+        def on_class(node)
+          begin_node = node.child_nodes.find(&:begin_type?) || node
+          begin_node.each_child_node(:send).select(&:macro?).each do |macro|
+            next unless MIXIN_METHODS.include?(macro.method_name)
+
+            check(macro)
+          end
+        end
+
+        alias on_module on_class
+
+        def autocorrect(node)
+          range = node.loc.expression
+          if separated_style?
+            correction = separate_mixins(node)
+          else
+            mixins = sibling_mixins(node)
+            if node == mixins.first
+              correction = group_mixins(node, mixins)
+            else
+              range = range_to_remove_for_subsequent_mixin(mixins, node)
+              correction = ''
+            end
+          end
+
+          ->(corrector) { corrector.replace(range, correction) }
+        end
+
+        private
+
+        def range_to_remove_for_subsequent_mixin(mixins, node)
+          range = node.loc.expression
+          prev_mixin = mixins.each_cons(2) { |m, n| break m if n == node }
+          between = prev_mixin.loc.expression.end
+                              .join(range.begin)
+          # if separated from previous mixin with only whitespace?
+          unless /\S/.match?(between.source)
+            range = range.join(between) # then remove that too
+          end
+          range
+        end
+
+        def check(send_node)
+          if separated_style?
+            check_separated_style(send_node)
+          else
+            check_grouped_style(send_node)
+          end
+        end
+
+        def check_grouped_style(send_node)
+          return if sibling_mixins(send_node).size == 1
+
+          add_offense(send_node)
+        end
+
+        def check_separated_style(send_node)
+          return if send_node.arguments.one?
+
+          add_offense(send_node)
+        end
+
+        def sibling_mixins(send_node)
+          siblings = send_node.parent.each_child_node(:send)
+                              .select(&:macro?)
+
+          siblings.select do |sibling_node|
+            sibling_node.method?(send_node.method_name)
+          end
+        end
+
+        def message(send_node)
+          suffix =
+            separated_style? ? 'separate statements' : 'a single statement'
+
+          format(MSG, mixin: send_node.method_name, suffix: suffix)
+        end
+
+        def grouped_style?
+          style == :grouped
+        end
+
+        def separated_style?
+          style == :separated
+        end
+
+        def separate_mixins(node)
+          arguments = node.arguments.reverse
+          mixins = ["#{node.method_name} #{arguments.first.source}"]
+
+          arguments[1..-1].inject(mixins) do |replacement, arg|
+            replacement << "#{indent(node)}#{node.method_name} #{arg.source}"
+          end.join("\n")
+        end
+
+        def group_mixins(node, mixins)
+          mixin_names = mixins.reverse.flat_map do |mixin|
+            mixin.arguments.map(&:source)
+          end
+
+          "#{node.method_name} #{mixin_names.join(', ')}"
+        end
+
+        def indent(node)
+          ' ' * node.loc.column
+        end
+      end
+    end
+  end
+end