rubocop 0.49.1 → 0.52.0

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

@@ -7,30 +7,26 @@ module RuboCop
       # 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
+      # @example EnforcedStyle: separated (default)
+      #   # bad
       #   class Foo
       #     include Bar, Qox
       #   end
       #
-      #   @good
+      #   # good
       #   class Foo
       #     include Qox
       #     include Bar
       #   end
       #
-      #   EnforcedStyle: grouped
-      #
-      #   @bad
+      # @example EnforcedStyle: grouped
+      #   # bad
       #   class Foo
       #     extend Bar
       #     extend Qox
       #   end
       #
-      #   @good
+      #   # good
       #   class Foo
       #     extend Qox, Bar
       #   end
@@ -38,7 +34,7 @@ module RuboCop
         include ConfigurableEnforcedStyle
 
         MIXIN_METHODS = %i[extend include prepend].freeze
-        MSG = 'Put `%s` mixins in %s.'.freeze
+        MSG = 'Put `%<mixin>s` mixins in %<suffix>s.'.freeze
 
         def on_send(node)
           return unless node.macro? && MIXIN_METHODS.include?(node.method_name)
@@ -47,15 +43,17 @@ module RuboCop
         end
 
         def autocorrect(node)
+          range = node.loc.expression
           if separated_style?
-            range = node.loc.expression
             correction = separate_mixins(node)
           else
             mixins = sibling_mixins(node)
-            mixins.unshift(node)
-
-            range = node.loc.expression.join(mixins.last.loc.expression)
-            correction = group_mixins(node, mixins)
+            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) }
@@ -63,6 +61,18 @@ module RuboCop
 
         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)
@@ -72,20 +82,20 @@ module RuboCop
         end
 
         def check_grouped_style(send_node)
-          return if sibling_mixins(send_node).empty?
+          return if sibling_mixins(send_node).size == 1
 
-          add_offense(send_node, :expression)
+          add_offense(send_node)
         end
 
         def check_separated_style(send_node)
           return if send_node.arguments.one?
 
-          add_offense(send_node, :expression)
+          add_offense(send_node)
         end
 
         def sibling_mixins(send_node)
           siblings = send_node.parent.each_child_node(:send)
-                              .reject { |sibling| sibling == send_node }
+                              .select(&:macro?)
 
           siblings.select do |sibling_node|
             sibling_node.method_name == send_node.method_name
@@ -96,7 +106,7 @@ module RuboCop
           suffix =
             separated_style? ? 'separate statements' : 'a single statement'
 
-          format(MSG, send_node.method_name, suffix)
+          format(MSG, mixin: send_node.method_name, suffix: suffix)
         end
 
         def grouped_style?

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

@@ -0,0 +1,71 @@
+# 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?
+            return if accepted_include?(node)
+
+            add_offense(node, message: format(MSG, statement: statement))
+          end
+        end
+
+        private
+
+        def accepted_include?(node)
+          node.parent && node.macro?
+        end
+      end
+    end
+  end
+end

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

@@ -8,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 if EnforcedStyle is module_function
+      #   # good
       #   module Test
       #     module_function
-      #     ...
+      #     # ...
       #   end
       #
-      #   # Good if EnforcedStyle is extend_self
+      # @example EnforcedStyle: extend_self
+      #   # bad
+      #   module Test
+      #     module_function
+      #     # ...
+      #   end
+      #
+      #   # good
       #   module Test
       #     extend self
-      #     ...
+      #     # ...
       #   end
       #
       # These offenses are not auto-corrected since there are different
@@ -32,15 +44,15 @@ module RuboCop
         EXTEND_SELF_MSG =
           'Use `extend self` instead of `module_function`.'.freeze
 
-        def_node_matcher :module_function_node?, '(send nil :module_function)'
-        def_node_matcher :extend_self_node?, '(send nil :extend 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.begin_type?
 
-          each_wrong_style(body.children) do |child_node, msg|
-            add_offense(child_node, :expression, msg)
+          each_wrong_style(body.children) do |child_node|
+            add_offense(child_node)
           end
         end
 
@@ -50,14 +62,18 @@ module RuboCop
           case style
           when :module_function
             nodes.each do |node|
-              yield node, MODULE_FUNCTION_MSG if extend_self_node?(node)
+              yield node if extend_self_node?(node)
             end
           when :extend_self
             nodes.each do |node|
-              yield node, EXTEND_SELF_MSG if module_function_node?(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

@@ -25,7 +25,7 @@ module RuboCop
             range = range_between(receiver.loc.end.begin_pos,
                                   node.send_node.source_range.end_pos)
 
-            add_offense(nil, range)
+            add_offense(nil, location: range)
 
             # Done. If there are more blocks in the chain, they will be
             # found by subsequent calls to on_block.

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

@@ -18,23 +18,27 @@ module RuboCop
         include StatementModifier
         include AutocorrectAlignment
 
-        MSG = 'Favor a normal %s-statement over a modifier' \
+        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, :expression, format(MSG, node.keyword))
+          add_offense(node)
         end
 
-        private
-
         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}"

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

@@ -5,13 +5,14 @@ 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
@@ -20,27 +21,28 @@ module RuboCop
 
         NON_MODIFIER_THEN = /then\s*(#.*)?$/
 
-        MSG = 'Do not use `then` for multi-line `%s`.'.freeze
+        MSG = 'Do not use `then` for multi-line `%<keyword>s`.'.freeze
 
         def on_normal_if_unless(node)
           return unless non_modifier_then?(node)
 
-          add_offense(node, :begin, format(MSG, node.keyword))
-        end
-
-        private
-
-        def non_modifier_then?(node)
-          node.loc.begin && node.loc.begin.source_line =~ NON_MODIFIER_THEN
+          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)
+              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

@@ -5,33 +5,27 @@ module RuboCop
     module Style
       # This cop checks expressions wrapping styles for multiline memoization.
       #
-      # @example
-      #
-      #   # EnforcedStyle: keyword (default)
-      #
-      #   @bad
+      # @example EnforcedStyle: keyword (default)
+      #   # bad
       #   foo ||= (
       #     bar
       #     baz
       #   )
       #
-      #   @good
+      #   # good
       #   foo ||= begin
       #     bar
       #     baz
       #   end
       #
-      # @example
-      #
-      #   # EnforcedStyle: braces
-      #
-      #   @bad
+      # @example EnforcedStyle: braces
+      #   # bad
       #   foo ||= begin
       #     bar
       #     baz
       #   end
       #
-      #   @good
+      #   # good
       #   foo ||= (
       #     bar
       #     baz
@@ -46,16 +40,13 @@ module RuboCop
 
           return unless bad_rhs?(rhs)
 
-          add_offense(rhs, node.source_range, MSG)
+          add_offense(rhs, location: node.source_range)
         end
 
-        private
-
         def autocorrect(node)
           lambda do |corrector|
             if style == :keyword
-              corrector.replace(node.loc.begin, 'begin')
-              corrector.replace(node.loc.end, 'end')
+              keyword_autocorrect(node, corrector)
             else
               corrector.replace(node.loc.begin, '(')
               corrector.replace(node.loc.end, ')')
@@ -63,6 +54,8 @@ module RuboCop
           end
         end
 
+        private
+
         def bad_rhs?(rhs)
           return false unless rhs.multiline?
           if style == :keyword
@@ -71,6 +64,29 @@ module RuboCop
             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