rubocop 0.42.0 → 0.52.1

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -21,29 +20,41 @@ module RuboCop
 
         MSG = 'Prefer `to_s` over string interpolation.'.freeze
 
+        def self.autocorrect_incompatible_with
+          [Style::LineEndConcatenation]
+        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.size == 1
+          node.children.one? && variable_interpolation?(node.children.first)
         end
 
         def interpolation?(node)
-          variable_interpolation?(node) || node.type == :begin
+          variable_interpolation?(node) || node.begin_type?
         end
 
         def variable_interpolation?(node)
@@ -51,27 +62,14 @@ module RuboCop
         end
 
         def implicit_concatenation?(node)
-          node.parent && node.parent.type == :dstr
+          node.parent && node.parent.dstr_type?
         end
 
         def embedded_in_percent_array?(node)
-          node.parent &&
-            node.parent.type == :array &&
+          node.parent && node.parent.array_type? &&
             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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -6,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
@@ -19,6 +18,7 @@ module RuboCop
         ESCAPED_NON_BACKSLASH = /\\[^\\]/
 
         def on_dstr(node)
+          return unless string_literal?(node)
           check(node)
         end
 
@@ -30,17 +30,32 @@ 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)
-          src = node.source
-          return unless start_with_percent_q_variant?(src)
-          return if src.include?(SINGLE_QUOTE) && src.include?(QUOTE)
-          return if src.start_with?(PERCENT_Q) && acceptable_q?(node)
-          return if src.start_with?(PERCENT_CAPITAL_Q) &&
-                    acceptable_capital_q?(node)
+          return unless start_with_percent_q_variant?(node)
+          return if interpolated_quotes?(node) || allowed_percent_q?(node)
+
+          add_offense(node)
+        end
+
+        def interpolated_quotes?(node)
+          node.source.include?(SINGLE_QUOTE) && node.source.include?(QUOTE)
+        end
 
-          add_offense(node, :expression)
+        def allowed_percent_q?(node)
+          node.source.start_with?(PERCENT_Q) && acceptable_q?(node) ||
+            node.source.start_with?(PERCENT_CAPITAL_Q) &&
+              acceptable_capital_q?(node)
         end
 
         def message(node)
@@ -50,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)
@@ -68,7 +74,7 @@ module RuboCop
         end
 
         def start_with_percent_q_variant?(string)
-          string.start_with?(PERCENT_Q, PERCENT_CAPITAL_Q)
+          string.source.start_with?(PERCENT_Q, PERCENT_CAPITAL_Q)
         end
 
         def acceptable_q?(node)
@@ -83,7 +89,7 @@ module RuboCop
           src = node.source
           src.include?(QUOTE) &&
             (src =~ STRING_INTERPOLATION_REGEXP ||
-            (node.str_type? && double_quotes_acceptable?(node.str_content)))
+            (node.str_type? && double_quotes_required?(src)))
         end
       end
     end

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

@@ -1,13 +1,23 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 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)
@@ -21,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

@@ -1,21 +1,35 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 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 unless node.loc.begin && node.loc.begin.is?(';')
+          return if node.multiline? || node.then? || !node.body
 
-          add_offense(node, :begin)
+          add_offense(node, location: :begin)
         end
 
         def autocorrect(node)
-          ->(corrector) { corrector.replace(node.loc.begin, ' then') }
+          lambda do |corrector|
+            corrector.replace(node.loc.begin, ' then')
+          end
         end
       end
     end

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

@@ -1,11 +1,36 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 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 `%<keyword>s`.'.freeze
+
         def on_while(node)
           handle(node)
         end
@@ -15,25 +40,18 @@ module RuboCop
         end
 
         def handle(node)
-          length = node.source.lines.to_a.size
-          return unless length > 1
-          return unless node.loc.begin && node.loc.begin.is?('do')
+          return unless node.multiline? && node.do?
 
-          add_offense(node, :begin, error_message(node.type))
-        end
-
-        private
-
-        def error_message(node_type)
-          format('Do not use `do` with multi-line `%s`.', node_type)
+          add_offense(node, location: :begin,
+                            message: format(MSG, keyword: node.keyword))
         end
 
         def autocorrect(node)
-          condition_node, = *node
-          end_of_condition_range = condition_node.source_range.end
-          do_range = node.loc.begin
-          whitespaces_and_do_range = end_of_condition_range.join(do_range)
-          ->(corrector) { corrector.remove(whitespaces_and_do_range) }
+          do_range = node.condition.source_range.end.join(node.loc.begin)
+
+          lambda do |corrector|
+            corrector.remove(do_range)
+          end
         end
       end
     end

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

@@ -1,15 +1,35 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 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 `%<keyword>s` usage when ' \
+              'having a single-line body.'.freeze
+
         def on_while(node)
           check(node)
         end
@@ -19,21 +39,21 @@ module RuboCop
         end
 
         def autocorrect(node)
-          cond, body = *node
-          oneline = "#{body.source} #{node.loc.keyword.source} " + cond.source
-          ->(corrector) { corrector.replace(node.source_range, oneline) }
+          oneline = "#{node.body.source} #{node.keyword} " \
+                    "#{node.condition.source}"
+
+          lambda do |corrector|
+            corrector.replace(node.source_range, oneline)
+          end
         end
 
         private
 
         def check(node)
-          return unless node.loc.end
-          return unless fit_within_line_as_modifier_form?(node)
-          add_offense(node, :keyword, message(node.loc.keyword.source))
-        end
+          return unless node.multiline? && single_line_as_modifier?(node)
 
-        def message(keyword)
-          "Favor modifier `#{keyword}` usage when having a single-line body."
+          add_offense(node, location: :keyword,
+                            message: format(MSG, keyword: node.keyword))
         end
       end
     end

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

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 module RuboCop
@@ -9,141 +8,85 @@ module RuboCop
       #
       # Alternatively, it can check for uses of the %w() syntax, in projects
       # which do not want to include that syntax.
+      #
+      # 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)
+      #   # good
+      #   %w[foo bar baz]
+      #
+      #   # bad
+      #   ['foo', 'bar', 'baz']
+      #
+      # @example EnforcedStyle: brackets
+      #   # good
+      #   ['foo', 'bar', 'baz']
+      #
+      #   # bad
+      #   %w[foo bar baz]
       class WordArray < Cop
+        include ArrayMinSize
         include ArraySyntax
+        include ConfigurableEnforcedStyle
+        include PercentArray
+        include PercentLiteral
 
         PERCENT_MSG = 'Use `%w` or `%W` for an array of words.'.freeze
         ARRAY_MSG = 'Use `[]` for an array of words.'.freeze
         QUESTION_MARK_SIZE = '?'.size
 
+        class << self
+          attr_accessor :largest_brackets
+        end
+
         def on_array(node)
           if bracketed_array_of?(:str, node)
-            check_bracketed(node)
-          elsif percent_syntax?(node)
-            check_percent(node)
+            return if complex_content?(node.values)
+
+            check_bracketed_array(node)
+          elsif node.percent_literal?(:string)
+            check_percent_array(node)
           end
         end
 
         def autocorrect(node)
-          words = node.children
           if style == :percent
-            escape = words.any? { |w| needs_escaping?(w.children[0]) }
-            char = escape ? 'W' : 'w'
-            contents = autocorrect_words(words, escape, node.loc.line)
-            lambda do |corrector|
-              corrector.replace(node.source_range, "%#{char}(#{contents})")
-            end
+            correct_percent(node, 'w')
           else
-            words = words.map { |w| to_string_literal(w.children[0]) }
-            lambda do |corrector|
-              corrector.replace(node.source_range, "[#{words.join(', ')}]")
-            end
+            correct_bracketed(node)
           end
         end
 
         private
 
-        def check_bracketed(node)
-          array_elems = node.children
+        def check_bracketed_array(node)
+          return if allowed_bracket_array?(node)
 
-          return if complex_content?(array_elems) ||
-                    comments_in_array?(node)
-          style_detected(:brackets, array_elems.size)
-
-          if style == :percent && array_elems.size >= min_size
-            add_offense(node, :expression, PERCENT_MSG)
-          end
-        end
-
-        def check_percent(node)
-          array_elems = node.children
-
-          style_detected(:percent, array_elems.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
+          array_style_detected(:brackets, node.values.size)
+          add_offense(node) if style == :percent
         end
 
         def complex_content?(strings)
           strings.any? do |s|
             string = s.str_content
-            !string.valid_encoding? || string !~ word_regex || string =~ / /
+            !string.dup.force_encoding(::Encoding::UTF_8).valid_encoding? ||
+              string !~ word_regex || string =~ / /
           end
         end
 
-        def style
-          cop_config['EnforcedStyle'].to_sym
-        end
-
-        def min_size
-          cop_config['MinSize']
-        end
-
         def word_regex
-          cop_config['WordRegex']
-        end
-
-        def autocorrect_words(word_nodes, escape, base_line_number)
-          previous_node_line_number = base_line_number
-          word_nodes.map do |node|
-            number_of_line_breaks = node.loc.line - previous_node_line_number
-            line_breaks = "\n" * number_of_line_breaks
-            previous_node_line_number = node.loc.line
-            content = node.children[0]
-            content = escape ? escape_string(content) : content
-            content.gsub!(/\)/, '\\)')
-            line_breaks + content
-          end.join(' ')
-        end
-
-        def style_detected(style, ary_size)
-          cfg = config_to_allow_offenses
-          return if cfg['Enabled'] == false
-
-          largest_brackets = largest_brackets_size(style, ary_size)
-          smallest_percent = smallest_percent_size(style, ary_size)
-
-          if cfg['EnforcedStyle'] == style.to_s
-            # do nothing
-          elsif cfg['EnforcedStyle'].nil?
-            cfg['EnforcedStyle'] = style.to_s
-          elsif smallest_percent <= largest_brackets
-            self.config_to_allow_offenses = { 'Enabled' => false }
-          else
-            cfg['EnforcedStyle'] = 'percent'
-            cfg['MinSize'] = largest_brackets + 1
-          end
+          Regexp.new(cop_config['WordRegex'])
         end
 
-        def largest_brackets_size(style, ary_size)
-          @largest_brackets ||= -Float::INFINITY
+        def correct_bracketed(node)
+          words = node.children.map { |w| to_string_literal(w.children[0]) }
 
-          if style == :brackets && ary_size > @largest_brackets
-            @largest_brackets = ary_size
+          lambda do |corrector|
+            corrector.replace(node.source_range, "[#{words.join(', ')}]")
           end
-
-          @largest_brackets
-        end
-
-        def smallest_percent_size(style, ary_size)
-          @smallest_percent ||= Float::INFINITY
-
-          if style == :percent && ary_size < @smallest_percent
-            @smallest_percent = ary_size
-          end
-
-          @smallest_percent
         end
       end
     end