rubocop 0.49.1 → 0.52.0

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

@@ -4,6 +4,21 @@ module RuboCop
   module Cop
     module Style
       # This cop looks for *unless* expressions with *else* clauses.
+      #
+      # @example
+      #   # bad
+      #   unless foo_bar.nil?
+      #     # do something...
+      #   else
+      #     # do a different thing...
+      #   end
+      #
+      #   # good
+      #   if foo_bar.present?
+      #     # do something...
+      #   else
+      #     # do a different thing...
+      #   end
       class UnlessElse < Cop
         MSG = 'Do not use `unless` with `else`. Rewrite these with the ' \
               'positive case first.'.freeze
@@ -11,7 +26,7 @@ module RuboCop
         def on_if(node)
           return unless node.unless? && node.else?
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def autocorrect(node)

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

@@ -4,6 +4,16 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for usage of the %W() syntax when %w() would do.
+      #
+      # @example
+      #   # bad
+      #   %W(cat dog pig)
+      #   %W[door wall floor]
+      #
+      #   # good
+      #   %w/swim run bike/
+      #   %w[shirt pants shoes]
+      #   %W(apple #{fruit} grape)
       class UnneededCapitalW < Cop
         include PercentLiteral
 
@@ -14,12 +24,19 @@ module RuboCop
           process(node, '%W')
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            src = node.loc.begin.source
+            corrector.replace(node.loc.begin, src.tr('W', 'w'))
+          end
+        end
+
         private
 
         def on_percent_literal(node)
           return if requires_interpolation?(node)
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def requires_interpolation?(node)
@@ -28,13 +45,6 @@ module RuboCop
               double_quotes_required?(string.source)
           end
         end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            src = node.loc.begin.source
-            corrector.replace(node.loc.begin, src.tr('W', 'w'))
-          end
-        end
       end
     end
   end

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

@@ -25,24 +25,32 @@ module RuboCop
         end
 
         def on_dstr(node)
-          add_offense(node, :expression, MSG) if single_interpolation?(node)
+          add_offense(node) if single_interpolation?(node)
+        end
+
+        def autocorrect(node)
+          embedded_node = node.children.first
+
+          if variable_interpolation?(embedded_node)
+            autocorrect_variable_interpolation(embedded_node, node)
+          elsif single_variable_interpolation?(embedded_node)
+            autocorrect_single_variable_interpolation(embedded_node, node)
+          else
+            autocorrect_other(embedded_node, node)
+          end
         end
 
         private
 
         def single_interpolation?(node)
-          single_child?(node) &&
+          node.children.one? &&
             interpolation?(node.children.first) &&
             !implicit_concatenation?(node) &&
             !embedded_in_percent_array?(node)
         end
 
         def single_variable_interpolation?(node)
-          single_child?(node) && variable_interpolation?(node.children.first)
-        end
-
-        def single_child?(node)
-          node.children.one?
+          node.children.one? && variable_interpolation?(node.children.first)
         end
 
         def interpolation?(node)
@@ -62,18 +70,6 @@ module RuboCop
             percent_literal?(node.parent)
         end
 
-        def autocorrect(node)
-          embedded_node = node.children.first
-
-          if variable_interpolation?(embedded_node)
-            autocorrect_variable_interpolation(embedded_node, node)
-          elsif single_variable_interpolation?(embedded_node)
-            autocorrect_single_variable_interpolation(embedded_node, node)
-          else
-            autocorrect_other(embedded_node, node)
-          end
-        end
-
         def autocorrect_variable_interpolation(embedded_node, node)
           replacement = "#{embedded_node.loc.expression.source}.to_s"
           ->(corrector) { corrector.replace(node.loc.expression, replacement) }

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

@@ -5,8 +5,8 @@ module RuboCop
     module Style
       # This cop checks for usage of the %q/%Q syntax when '' or "" would do.
       class UnneededPercentQ < Cop
-        MSG = 'Use `%s` only for strings that contain both single quotes and ' \
-              'double quotes%s.'.freeze
+        MSG = 'Use `%<q_type>s` only for strings that contain both ' \
+              'single quotes and double quotes%<extra>s.'.freeze
         DYNAMIC_MSG = ', or for dynamic strings that contain ' \
                       'double quotes'.freeze
         SINGLE_QUOTE = "'".freeze
@@ -18,6 +18,7 @@ module RuboCop
         ESCAPED_NON_BACKSLASH = /\\[^\\]/
 
         def on_dstr(node)
+          return unless string_literal?(node)
           check(node)
         end
 
@@ -29,13 +30,22 @@ module RuboCop
           check(node)
         end
 
+        def autocorrect(node)
+          delimiter =
+            node.source =~ /^%Q[^"]+$|'/ ? QUOTE : SINGLE_QUOTE
+          lambda do |corrector|
+            corrector.replace(node.loc.begin, delimiter)
+            corrector.replace(node.loc.end, delimiter)
+          end
+        end
+
         private
 
         def check(node)
           return unless start_with_percent_q_variant?(node)
           return if interpolated_quotes?(node) || allowed_percent_q?(node)
 
-          add_offense(node, :expression)
+          add_offense(node)
         end
 
         def interpolated_quotes?(node)
@@ -55,16 +65,7 @@ module RuboCop
                   else
                     EMPTY
                   end
-          format(MSG, src[0, 2], extra)
-        end
-
-        def autocorrect(node)
-          delimiter =
-            node.source =~ /^%Q[^"]+$|'/ ? QUOTE : SINGLE_QUOTE
-          lambda do |corrector|
-            corrector.replace(node.loc.begin, delimiter)
-            corrector.replace(node.loc.end, delimiter)
-          end
+          format(MSG, q_type: src[0, 2], extra: extra)
         end
 
         def string_literal?(node)

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

@@ -4,9 +4,20 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for variable interpolation (like "#@ivar").
+      #
+      # @example
+      #   # bad
+      #   "His name is #$name"
+      #   /check #$pattern/
+      #   "Let's go to the #@store"
+      #
+      #   # good
+      #   "His name is #{$name}"
+      #   /check #{$pattern}/
+      #   "Let's go to the #{@store}"
       class VariableInterpolation < Cop
-        MSG = 'Replace interpolated variable `%s` ' \
-              'with expression `#{%s}`.'.freeze
+        MSG = 'Replace interpolated variable `%<variable>s` ' \
+              'with expression `#{%<variable>s}`.'.freeze
 
         def on_dstr(node)
           check_for_interpolation(node)
@@ -20,19 +31,22 @@ module RuboCop
           check_for_interpolation(node)
         end
 
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node.source_range, "{#{node.source}}")
+          end
+        end
+
         private
 
         def check_for_interpolation(node)
-          var_nodes(node.children).each do |v|
-            var = v.source
-            add_offense(v, :expression, format(MSG, var, var))
+          var_nodes(node.children).each do |var_node|
+            add_offense(var_node)
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.source_range, "{#{node.source}}")
-          end
+        def message(node)
+          format(MSG, variable: node.source)
         end
 
         def var_nodes(nodes)

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

@@ -4,13 +4,26 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for *when;* uses in *case* expressions.
+      #
+      # @example
+      #   # bad
+      #   case foo
+      #   when 1; 'baz'
+      #   when 2; 'bar'
+      #   end
+      #
+      #   # good
+      #   case foo
+      #   when 1 then 'baz'
+      #   when 2 then 'bar'
+      #   end
       class WhenThen < Cop
         MSG = 'Do not use `when x;`. Use `when x then` instead.'.freeze
 
         def on_when(node)
           return if node.multiline? || node.then? || !node.body
 
-          add_offense(node, :begin)
+          add_offense(node, location: :begin)
         end
 
         def autocorrect(node)

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

@@ -4,8 +4,32 @@ module RuboCop
   module Cop
     module Style
       # Checks for uses of `do` in multi-line `while/until` statements.
+      #
+      # @example
+      #
+      #   # bad
+      #   while x.any? do
+      #     do_something(x.pop)
+      #   end
+      #
+      #   # good
+      #   while x.any?
+      #     do_something(x.pop)
+      #   end
+      #
+      # @example
+      #
+      #   # bad
+      #   until x.empty? do
+      #     do_something(x.pop)
+      #   end
+      #
+      #   # good
+      #   until x.empty?
+      #     do_something(x.pop)
+      #   end
       class WhileUntilDo < Cop
-        MSG = 'Do not use `do` with multi-line `%s`.'.freeze
+        MSG = 'Do not use `do` with multi-line `%<keyword>s`.'.freeze
 
         def on_while(node)
           handle(node)
@@ -18,11 +42,10 @@ module RuboCop
         def handle(node)
           return unless node.multiline? && node.do?
 
-          add_offense(node, :begin, format(MSG, node.keyword))
+          add_offense(node, location: :begin,
+                            message: format(MSG, keyword: node.keyword))
         end
 
-        private
-
         def autocorrect(node)
           do_range = node.condition.source_range.end.join(node.loc.begin)
 

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

@@ -4,12 +4,31 @@ module RuboCop
   module Cop
     module Style
       # Checks for while and until statements that would fit on one line
-      # if written as a modifier while/until.
-      # The maximum line length is configurable.
+      # if written as a modifier while/until. The maximum line length is
+      # configured in the `Metrics/LineLength` cop.
+      #
+      # @example
+      #   # bad
+      #   while x < 10
+      #     x += 1
+      #   end
+      #
+      #   # good
+      #   x += 1 while x < 10
+      #
+      # @example
+      #   # bad
+      #   until x > 10
+      #     x += 1
+      #   end
+      #
+      #   # good
+      #   x += 1 until x > 10
       class WhileUntilModifier < Cop
         include StatementModifier
 
-        MSG = 'Favor modifier `%s` usage when having a single-line body.'.freeze
+        MSG = 'Favor modifier `%<keyword>s` usage when ' \
+              'having a single-line body.'.freeze
 
         def on_while(node)
           check(node)
@@ -19,8 +38,6 @@ module RuboCop
           check(node)
         end
 
-        private
-
         def autocorrect(node)
           oneline = "#{node.body.source} #{node.keyword} " \
                     "#{node.condition.source}"
@@ -30,10 +47,13 @@ module RuboCop
           end
         end
 
+        private
+
         def check(node)
           return unless node.multiline? && single_line_as_modifier?(node)
 
-          add_offense(node, :keyword, format(MSG, node.keyword))
+          add_offense(node, location: :keyword,
+                            message: format(MSG, keyword: node.keyword))
         end
       end
     end

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

@@ -11,21 +11,17 @@ module RuboCop
       #
       # Configuration option: MinSize
       # If set, arrays with fewer elements than this value will not trigger the
-      # cop. For example, a `MinSize of `3` will not enforce a style on an array
-      # of 2 or fewer elements.
-      #
-      # @example
-      #   EnforcedStyle: percent (default)
+      # cop. For example, a `MinSize` of `3` will not enforce a style on an
+      # array of 2 or fewer elements.
       #
+      # @example EnforcedStyle: percent (default)
       #   # good
       #   %w[foo bar baz]
       #
       #   # bad
       #   ['foo', 'bar', 'baz']
       #
-      # @example
-      #   EnforcedStyle: brackets
-      #
+      # @example EnforcedStyle: brackets
       #   # good
       #   ['foo', 'bar', 'baz']
       #
@@ -35,6 +31,7 @@ module RuboCop
         include ArrayMinSize
         include ArraySyntax
         include ConfigurableEnforcedStyle
+        include PercentArray
         include PercentLiteral
 
         PERCENT_MSG = 'Use `%w` or `%W` for an array of words.'.freeze
@@ -47,6 +44,8 @@ module RuboCop
 
         def on_array(node)
           if bracketed_array_of?(:str, node)
+            return if complex_content?(node.values)
+
             check_bracketed_array(node)
           elsif node.percent_literal?(:string)
             check_percent_array(node)
@@ -64,30 +63,10 @@ module RuboCop
         private
 
         def check_bracketed_array(node)
-          return if complex_content?(node.values) ||
-                    comments_in_array?(node) ||
-                    below_array_length?(node)
+          return if allowed_bracket_array?(node)
 
           array_style_detected(:brackets, node.values.size)
-          add_offense(node, :expression, PERCENT_MSG) if style == :percent
-        end
-
-        def check_percent_array(node)
-          array_style_detected(:percent, node.values.size)
-          add_offense(node, :expression, ARRAY_MSG) if style == :brackets
-        end
-
-        def percent_syntax?(node)
-          node.loc.begin && node.loc.begin.source =~ /\A%[wW]/
-        end
-
-        def comments_in_array?(node)
-          comments = processed_source.comments
-          array_range = node.source_range.to_a
-
-          comments.any? do |comment|
-            !(comment.loc.expression.to_a & array_range).empty?
-          end
+          add_offense(node) if style == :percent
         end
 
         def complex_content?(strings)