rubocop 0.42.0 → 0.52.1

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

@@ -0,0 +1,145 @@
+# 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.'.freeze
+
+        def on_send(node)
+          return unless node.macro? && MIXIN_METHODS.include?(node.method_name)
+
+          check(node)
+        end
+
+        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?
+          if between.source !~ /\S/
+            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_name == 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)
+          _receiver, mixin, *args = *node
+          args.reverse!
+          first_mixin = String.new("#{mixin} #{args.first.source}")
+
+          args[1..-1].inject(first_mixin) do |replacement, arg|
+            replacement << "\n#{indent(node)}#{mixin} #{arg.source}"
+          end
+        end
+
+        def group_mixins(node, mixins)
+          _receiver, mixin, *_args = *node
+          all_mixin_arguments = mixins.reverse.flat_map do |m|
+            m.arguments.map(&:source)
+          end
+
+          "#{mixin} #{all_mixin_arguments.join(', ')}"
+        end
+
+        def indent(node)
+          ' ' * node.loc.column
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks that `include`, `extend` and `prepend` exists at
+      # the top level.
+      # Using these at the top level affects the behavior of `Object`.
+      # There will not be using `include`, `extend` and `prepend` at
+      # the top level. Let's use it inside `class` or `module`.
+      #
+      # @example
+      #   # bad
+      #   include M
+      #
+      #   class C
+      #   end
+      #
+      #   # bad
+      #   extend M
+      #
+      #   class C
+      #   end
+      #
+      #   # bad
+      #   prepend M
+      #
+      #   class C
+      #   end
+      #
+      #   # good
+      #   class C
+      #     include M
+      #   end
+      #
+      #   # good
+      #   class C
+      #     extend M
+      #   end
+      #
+      #   # good
+      #   class C
+      #     prepend M
+      #   end
+      class MixinUsage < Cop
+        MSG = '`%<statement>s` is used at the top level. Use inside `class` ' \
+              'or `module`.'.freeze
+
+        def_node_matcher :include_statement, <<-PATTERN
+          (send nil? ${:include :extend :prepend}
+            const)
+        PATTERN
+
+        def on_send(node)
+          include_statement(node) do |statement|
+            return if node.argument? ||
+                      accepted_include?(node) ||
+                      belongs_to_class_or_module?(node)
+
+            add_offense(node, message: format(MSG, statement: statement))
+          end
+        end
+
+        private
+
+        def accepted_include?(node)
+          node.parent && node.macro?
+        end
+
+        def belongs_to_class_or_module?(node)
+          if !node.parent
+            false
+          else
+            return true if node.parent.class_type? || node.parent.module_type?
+
+            belongs_to_class_or_module?(node.parent)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -9,18 +8,30 @@ module RuboCop
       #
       # Supported styles are: module_function, extend_self.
       #
-      # @example
+      # @example EnforcedStyle: module_function (default)
+      #   # bad
+      #   module Test
+      #     extend self
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   module Test
+      #     module_function
+      #     # ...
+      #   end
       #
-      #   # Good if EnforcedStyle is module_function
+      # @example EnforcedStyle: extend_self
+      #   # bad
       #   module Test
       #     module_function
-      #     ...
+      #     # ...
       #   end
       #
-      #   # Good if EnforcedStyle is extend_self
+      #   # good
       #   module Test
       #     extend self
-      #     ...
+      #     # ...
       #   end
       #
       # These offenses are not auto-corrected since there are different
@@ -28,26 +39,41 @@ module RuboCop
       class ModuleFunction < Cop
         include ConfigurableEnforcedStyle
 
-        MODULE_FUNCTION_MSG = 'Use `module_function` instead of `extend self`.'
-                              .freeze
-        EXTEND_SELF_MSG = 'Use `extend self` instead of `module_function`.'
-                          .freeze
+        MODULE_FUNCTION_MSG =
+          'Use `module_function` instead of `extend self`.'.freeze
+        EXTEND_SELF_MSG =
+          'Use `extend self` instead of `module_function`.'.freeze
 
-        MODULE_FUNCTION_NODE = s(:send, nil, :module_function)
-        EXTEND_SELF_NODE = s(:send, nil, :extend, s(:self))
+        def_node_matcher :module_function_node?, '(send nil? :module_function)'
+        def_node_matcher :extend_self_node?, '(send nil? :extend self)'
 
         def on_module(node)
           _name, body = *node
-          return unless body && body.type == :begin
+          return unless body && body.begin_type?
 
-          body.children.each do |body_node|
-            if style == :module_function && body_node == EXTEND_SELF_NODE
-              add_offense(body_node, :expression, MODULE_FUNCTION_MSG)
-            elsif style == :extend_self && body_node == MODULE_FUNCTION_NODE
-              add_offense(body_node, :expression, EXTEND_SELF_MSG)
+          each_wrong_style(body.children) do |child_node|
+            add_offense(child_node)
+          end
+        end
+
+        private
+
+        def each_wrong_style(nodes)
+          case style
+          when :module_function
+            nodes.each do |node|
+              yield node if extend_self_node?(node)
+            end
+          when :extend_self
+            nodes.each do |node|
+              yield node if module_function_node?(node)
             end
           end
         end
+
+        def message(_node)
+          style == :module_function ? MODULE_FUNCTION_MSG : EXTEND_SELF_MSG
+        end
       end
     end
   end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -18,22 +17,16 @@ module RuboCop
         MSG = 'Avoid multi-line chains of blocks.'.freeze
 
         def on_block(node)
-          method, _args, _body = *node
-          method.each_node(:send) do |send_node|
-            receiver, _method_name, *_args = *send_node
-            next unless receiver && receiver.type == :block
+          node.send_node.each_node(:send) do |send_node|
+            receiver = send_node.receiver
 
-            # The begin and end could also be braces, but we call the
-            # variables do... and end...
-            do_kw_loc = receiver.loc.begin
-            end_kw_loc = receiver.loc.end
-            next if do_kw_loc.line == end_kw_loc.line
+            next unless receiver && receiver.block_type? && receiver.multiline?
+
+            range = range_between(receiver.loc.end.begin_pos,
+                                  node.send_node.source_range.end_pos)
+
+            add_offense(nil, location: range)
 
-            range =
-              Parser::Source::Range.new(end_kw_loc.source_buffer,
-                                        end_kw_loc.begin_pos,
-                                        method.source_range.end_pos)
-            add_offense(nil, range)
             # Done. If there are more blocks in the chain, they will be
             # found by subsequent calls to on_block.
             break

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of if/unless modifiers with multiple-lines bodies.
+      #
+      # @example
+      #
+      #   # bad
+      #   {
+      #     result: 'this should not happen'
+      #   } unless cond
+      #
+      #   # good
+      #   { result: 'ok' } if cond
+      class MultilineIfModifier < Cop
+        include StatementModifier
+        include Alignment
+
+        MSG = 'Favor a normal %<keyword>s-statement over a modifier' \
+              ' clause in a multiline statement.'.freeze
+
+        def on_if(node)
+          return unless node.modifier_form? && node.body.multiline?
+
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.source_range, to_normal_if(node))
+          end
+        end
+
+        private
+
+        def message(node)
+          format(MSG, keyword: node.keyword)
+        end
+
+        def to_normal_if(node)
+          indented_body = indented_body(node.body, node)
+          condition = "#{node.keyword} #{node.condition.source}"
+          indented_end = "#{offset(node)}end"
+
+          [condition, indented_body, indented_end].join("\n")
+        end
+
+        def configured_indentation_width
+          super || 2
+        end
+
+        def indented_body(body, node)
+          body_source = "#{offset(node)}#{body.source}"
+          body_source.each_line.map do |line|
+            if line == "\n"
+              line
+            else
+              line.sub(/^\s{#{offset(node).length}}/, indentation(node))
+            end
+          end.join
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,36 +5,44 @@ module RuboCop
     module Style
       # Checks for uses of the `then` keyword in multi-line if statements.
       #
-      # @example This is considered bad practice:
-      #
+      # @example
+      #   # bad
+      #   # This is considered bad practice.
       #   if cond then
       #   end
       #
-      # @example If statements can contain `then` on the same line:
-      #
+      #   # good
+      #   # If statements can contain `then` on the same line.
       #   if cond then a
       #   elsif cond then b
       #   end
       class MultilineIfThen < Cop
-        include IfNode
         include OnNormalIfUnless
 
+        NON_MODIFIER_THEN = /then\s*(#.*)?$/
+
+        MSG = 'Do not use `then` for multi-line `%<keyword>s`.'.freeze
+
         def on_normal_if_unless(node)
-          return unless node.loc.begin
-          return unless node.loc.begin.source_line =~ /then\s*(#.*)?$/
-          add_offense(node, :begin)
-        end
+          return unless non_modifier_then?(node)
 
-        def message(node)
-          "Do not use `then` for multi-line `#{node.loc.keyword.source}`."
+          add_offense(node, location: :begin,
+                            message: format(MSG, keyword: node.keyword))
         end
 
         def autocorrect(node)
           lambda do |corrector|
-            corrector.remove(range_with_surrounding_space(node.loc.begin,
-                                                          :left))
+            corrector.remove(
+              range_with_surrounding_space(range: node.loc.begin, side: :left)
+            )
           end
         end
+
+        private
+
+        def non_modifier_then?(node)
+          node.loc.begin && node.loc.begin.source_line =~ NON_MODIFIER_THEN
+        end
       end
     end
   end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks expressions wrapping styles for multiline memoization.
+      #
+      # @example EnforcedStyle: keyword (default)
+      #   # bad
+      #   foo ||= (
+      #     bar
+      #     baz
+      #   )
+      #
+      #   # good
+      #   foo ||= begin
+      #     bar
+      #     baz
+      #   end
+      #
+      # @example EnforcedStyle: braces
+      #   # bad
+      #   foo ||= begin
+      #     bar
+      #     baz
+      #   end
+      #
+      #   # good
+      #   foo ||= (
+      #     bar
+      #     baz
+      #   )
+      class MultilineMemoization < Cop
+        include ConfigurableEnforcedStyle
+
+        MSG = 'Wrap multiline memoization blocks in `begin` and `end`.'.freeze
+
+        def on_or_asgn(node)
+          _lhs, rhs = *node
+
+          return unless bad_rhs?(rhs)
+
+          add_offense(rhs, location: node.source_range)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            if style == :keyword
+              keyword_autocorrect(node, corrector)
+            else
+              corrector.replace(node.loc.begin, '(')
+              corrector.replace(node.loc.end, ')')
+            end
+          end
+        end
+
+        private
+
+        def bad_rhs?(rhs)
+          return false unless rhs.multiline?
+          if style == :keyword
+            rhs.begin_type?
+          else
+            rhs.kwbegin_type?
+          end
+        end
+
+        def keyword_autocorrect(node, corrector)
+          node_buf = node.source_range.source_buffer
+          corrector.replace(node.loc.begin, keyword_begin_str(node, node_buf))
+          corrector.replace(node.loc.end, keyword_end_str(node, node_buf))
+        end
+
+        def keyword_begin_str(node, node_buf)
+          indent = config.for_cop('IndentationWidth')['Width'] || 2
+          if node_buf.source[node.loc.begin.end_pos] == "\n"
+            'begin'
+          else
+            "begin\n" + (' ' * (node.loc.column + indent))
+          end
+        end
+
+        def keyword_end_str(node, node_buf)
+          if node_buf.source_line(node.loc.end.line) =~ /[^\s\)]/
+            "\n" + (' ' * node.loc.column) + 'end'
+          else
+            'end'
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,24 +1,36 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
       # This cop checks for multi-line ternary op expressions.
+      #
+      # @example
+      #   # bad
+      #   a = cond ?
+      #     b : c
+      #   a = cond ? b :
+      #       c
+      #   a = cond ?
+      #       b :
+      #       c
+      #
+      #   # good
+      #   a = cond ? b : c
+      #   a =
+      #     if cond
+      #       b
+      #     else
+      #       c
+      #     end
       class MultilineTernaryOperator < Cop
-        include IfNode
-
         MSG = 'Avoid multi-line ternary operators, ' \
               'use `if` or `unless` instead.'.freeze
 
         def on_if(node)
-          _condition, _if_branch, else_branch = *node
-
-          return unless ternary?(node)
+          return unless node.ternary? && node.multiline?
 
-          unless node.loc.line == else_branch.loc.line
-            add_offense(node, :expression)
-          end
+          add_offense(node)
         end
       end
     end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks against comparing a variable with multiple items, where
+      # `Array#include?` could be used instead to avoid code repetition.
+      #
+      # @example
+      #   # bad
+      #   a = 'a'
+      #   foo if a == 'a' || a == 'b' || a == 'c'
+      #
+      #   # good
+      #   a = 'a'
+      #   foo if ['a', 'b', 'c'].include?(a)
+      class MultipleComparison < Cop
+        MSG = 'Avoid comparing a variable with multiple items ' \
+          'in a conditional, use `Array#include?` instead.'.freeze
+
+        def on_if(node)
+          return unless nested_variable_comparison?(node.condition)
+          add_offense(node)
+        end
+
+        private
+
+        def_node_matcher :simple_double_comparison?, '(send $lvar :== $lvar)'
+        def_node_matcher :simple_comparison?, <<-PATTERN
+          {(send $lvar :== _)
+           (send _ :== $lvar)}
+        PATTERN
+
+        def nested_variable_comparison?(node)
+          return false unless nested_comparison?(node)
+          variables_in_node(node).count == 1
+        end
+
+        def variables_in_node(node)
+          if node.or_type?
+            node.node_parts
+                .flat_map { |node_part| variables_in_node(node_part) }
+                .uniq
+          else
+            variables_in_simple_node(node)
+          end
+        end
+
+        def variables_in_simple_node(node)
+          simple_double_comparison?(node) do |var1, var2|
+            return [variable_name(var1), variable_name(var2)]
+          end
+          simple_comparison?(node) do |var|
+            return [variable_name(var)]
+          end
+          []
+        end
+
+        def variable_name(node)
+          node.children[0]
+        end
+
+        def nested_comparison?(node)
+          if node.or_type?
+            node.node_parts.all? { |node_part| comparison? node_part }
+          else
+            false
+          end
+        end
+
+        def comparison?(node)
+          simple_comparison?(node) || nested_comparison?(node)
+        end
+      end
+    end
+  end
+end