rubocop 0.35.1 → 0.36.0

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -6,7 +7,7 @@ module RuboCop
       # This cop looks for *unless* expressions with *else* clauses.
       class UnlessElse < Cop
         MSG = 'Do not use `unless` with `else`. Rewrite these with the ' \
-              'positive case first.'
+              'positive case first.'.freeze
 
         def on_if(node)
           loc = node.loc

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -7,8 +8,8 @@ module RuboCop
       class UnneededCapitalW < Cop
         include PercentLiteral
 
-        MSG =
-          'Do not use `%W` unless interpolation is needed.  If not, use `%w`.'
+        MSG = 'Do not use `%W` unless interpolation is needed. ' \
+              'If not, use `%w`.'.freeze
 
         def on_array(node)
           process(node, '%W')
@@ -19,7 +20,7 @@ module RuboCop
         def on_percent_literal(node)
           requires_interpolation = node.children.any? do |string|
             string.type == :dstr ||
-            string.loc.expression.source =~ StringHelp::ESCAPED_CHAR_REGEXP
+              double_quotes_acceptable?(string.str_content)
           end
           add_offense(node, :expression) unless requires_interpolation
         end

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

@@ -0,0 +1,87 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for strings that are just an interpolated expression.
+      #
+      # @example
+      #
+      #   # bad
+      #   "#{@var}"
+      #
+      #   # good
+      #   @var.to_s
+      #
+      #   # good if @var is already a String
+      #   @var
+      class UnneededInterpolation < Cop
+        include PercentLiteral
+
+        MSG = 'Prefer `to_s` over string interpolation.'.freeze
+
+        def on_dstr(node)
+          add_offense(node, :expression, MSG) if single_interpolation?(node)
+        end
+
+        private
+
+        def single_interpolation?(node)
+          single_child?(node) &&
+            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
+        end
+
+        def interpolation?(node)
+          variable_interpolation?(node) || node.type == :begin
+        end
+
+        def variable_interpolation?(node)
+          node.variable? || node.reference?
+        end
+
+        def implicit_concatenation?(node)
+          node.parent && node.parent.type == :dstr
+        end
+
+        def embedded_in_percent_array?(node)
+          node.parent &&
+            node.parent.type == :array &&
+            percent_literal?(node.parent)
+        end
+
+        def autocorrect(node)
+          loc = node.loc
+          embedded_node = node.children.first
+          embedded_loc = embedded_node.loc
+
+          if variable_interpolation?(embedded_node)
+            replacement = "#{embedded_loc.expression.source}.to_s"
+            ->(corrector) { corrector.replace(loc.expression, replacement) }
+          elsif single_variable_interpolation?(embedded_node)
+            variable_loc = embedded_node.children.first.loc
+            replacement = "#{variable_loc.expression.source}.to_s"
+            ->(corrector) { corrector.replace(loc.expression, replacement) }
+          else
+            lambda do |corrector|
+              corrector.replace(loc.begin, '')
+              corrector.replace(loc.end, '')
+              corrector.replace(embedded_loc.begin, '(')
+              corrector.replace(embedded_loc.end, ').to_s')
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -6,8 +7,9 @@ module RuboCop
       # 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.'
-        DYNAMIC_MSG = ', or for dynamic strings that contain double quotes'
+              'double quotes%s.'.freeze
+        DYNAMIC_MSG = ', or for dynamic strings that contain ' \
+                      'double quotes'.freeze
         SINGLE_QUOTE = "'".freeze
         QUOTE = '"'.freeze
         EMPTY = ''.freeze
@@ -30,25 +32,32 @@ module RuboCop
         private
 
         def check(node)
-          src = node.loc.expression.source
+          src = node.source
           return unless start_with_percent_q_variant?(src)
           return if src.include?(SINGLE_QUOTE) && src.include?(QUOTE)
-          return if src =~ StringHelp::ESCAPED_CHAR_REGEXP
           if src.start_with?(PERCENT_Q) && src =~ STRING_INTERPOLATION_REGEXP
             return
           end
+          if src.start_with?(PERCENT_CAPITAL_Q) && acceptable_capital_q?(node)
+            return
+          end
+
+          add_offense(node, :expression)
+        end
 
+        def message(node)
+          src = node.source
           extra = if src.start_with?(PERCENT_CAPITAL_Q)
                     DYNAMIC_MSG
                   else
                     EMPTY
                   end
-          add_offense(node, :expression, format(MSG, src[0, 2], extra))
+          format(MSG, src[0, 2], extra)
         end
 
         def autocorrect(node)
           delimiter =
-            node.loc.expression.source =~ /^%Q[^"]+$|'/ ? QUOTE : SINGLE_QUOTE
+            node.source =~ /^%Q[^"]+$|'/ ? QUOTE : SINGLE_QUOTE
           lambda do |corrector|
             corrector.replace(node.loc.begin, delimiter)
             corrector.replace(node.loc.end, delimiter)
@@ -61,7 +70,14 @@ module RuboCop
         end
 
         def start_with_percent_q_variant?(string)
-          string.start_with?(PERCENT_Q) || string.start_with?(PERCENT_CAPITAL_Q)
+          string.start_with?(PERCENT_Q, PERCENT_CAPITAL_Q)
+        end
+
+        def acceptable_capital_q?(node)
+          src = node.source
+          src.include?(QUOTE) &&
+            (src =~ STRING_INTERPOLATION_REGEXP ||
+            (node.str_type? && double_quotes_acceptable?(node.str_content)))
         end
       end
     end

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

@@ -1,11 +1,13 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
       # This cop checks for variable interpolation (like "#@ivar").
       class VariableInterpolation < Cop
-        MSG = 'Replace interpolated variable `%s` with expression `#{%s}`.'
+        MSG = 'Replace interpolated variable `%s` ' \
+              'with expression `#{%s}`.'.freeze
 
         def on_dstr(node)
           check_for_interpolation(node)
@@ -23,19 +25,19 @@ module RuboCop
 
         def check_for_interpolation(node)
           var_nodes(node.children).each do |v|
-            var = v.loc.expression.source
-
+            var = v.source
             add_offense(v, :expression, format(MSG, var, var))
           end
         end
 
         def autocorrect(node)
-          expr = node.loc.expression
-          ->(corrector) { corrector.replace(expr, "{#{expr.source}}") }
+          lambda do |corrector|
+            corrector.replace(node.source_range, "{#{node.source}}")
+          end
         end
 
         def var_nodes(nodes)
-          nodes.select { |n| [:ivar, :cvar, :gvar, :nth_ref].include?(n.type) }
+          nodes.select { |n| n.variable? || n.reference? }
         end
       end
     end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop

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

@@ -1,11 +1,12 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
       # This cop checks for *when;* uses in *case* expressions.
       class WhenThen < Cop
-        MSG = 'Do not use `when x;`. Use `when x then` instead.'
+        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?(';')

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -14,7 +15,7 @@ module RuboCop
         end
 
         def handle(node)
-          length = node.loc.expression.source.lines.to_a.size
+          length = node.source.lines.to_a.size
           return unless length > 1
           return unless node.loc.begin && node.loc.begin.is?('do')
 
@@ -29,7 +30,7 @@ module RuboCop
 
         def autocorrect(node)
           condition_node, = *node
-          end_of_condition_range = condition_node.loc.expression.end
+          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) }

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -19,10 +20,8 @@ module RuboCop
 
         def autocorrect(node)
           cond, body = *node
-          oneline = "#{body.loc.expression.source} " \
-                    "#{node.loc.keyword.source} " +
-                    cond.loc.expression.source
-          ->(corrector) { corrector.replace(node.loc.expression, oneline) }
+          oneline = "#{body.source} #{node.loc.keyword.source} " + cond.source
+          ->(corrector) { corrector.replace(node.source_range, oneline) }
         end
 
         private

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

@@ -1,55 +1,75 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
-      # This cop checks for array literals made up of word-like
+      # This cop can check for array literals made up of word-like
       # strings, that are not using the %w() syntax.
+      #
+      # Alternatively, it can check for uses of the %w() syntax, in projects
+      # which do not want to include that syntax.
       class WordArray < Cop
         include ArraySyntax
-        # The parameter is called MinSize (meaning the minimum array size for
-        # which an offense can be registered), but essentially it's a Max
-        # parameter (the maximum number of something that's allowed).
-        include ConfigurableMax
 
-        MSG = 'Use `%w` or `%W` for array of words.'
+        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
 
         def on_array(node)
           array_elems = node.children
-          return unless array_of?(:str, node) &&
-                        !complex_content?(array_elems) &&
-                        array_elems.size > min_size && !comments_in_array?(node)
 
-          add_offense(node, :expression) { self.max = array_elems.size }
+          if bracketed_array_of?(:str, 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
+          elsif node.loc.begin && node.loc.begin.source =~ /\A%[wW]/
+            style_detected(:percent, array_elems.size)
+            add_offense(node, :expression, ARRAY_MSG) if style == :brackets
+          end
         end
 
-        private
-
-        def parameter_name
-          'MinSize'
+        def autocorrect(node)
+          words = node.children
+          if style == :percent
+            escape = words.any? { |w| double_quotes_required?(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
+          else
+            words = words.map { |w| to_string_literal(w.children[0]) }
+            lambda do |corrector|
+              corrector.replace(node.source_range, "[#{words.join(', ')}]")
+            end
+          end
         end
 
+        private
+
         def comments_in_array?(node)
           comments = processed_source.comments
-
-          array_range = node.loc.expression.to_a
+          array_range = node.source_range.to_a
 
           comments.any? do |comment|
             !(comment.loc.expression.to_a & array_range).empty?
           end
         end
 
-        def complex_content?(arr_sexp)
-          arr_sexp.each do |s|
-            source = s.loc.expression.source
-            next if source.start_with?('?') # %W(\r \n) can replace [?\r, ?\n]
-
-            str_content = Util.strip_quotes(source)
-            return true unless str_content =~ word_regex
+        def complex_content?(strings)
+          strings.any? do |s|
+            string = s.str_content
+            string !~ word_regex || string =~ / /
           end
+        end
 
-          false
+        def style
+          cop_config['EnforcedStyle'].to_sym
         end
 
         def min_size
@@ -60,43 +80,46 @@ module RuboCop
           cop_config['WordRegex']
         end
 
-        def autocorrect(node)
-          @interpolated = false
-          contents = autocorrect_words(node.children, node.loc.line)
-
-          char = @interpolated ? 'W' : 'w'
-
-          lambda do |corrector|
-            corrector.replace(node.loc.expression, "%#{char}(#{contents})")
-          end
-        end
-
-        def autocorrect_words(word_nodes, base_line_number)
+        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
-
-            line_breaks + source_for(node)
+            content = node.children[0]
+            content = escape ? escape_string(content) : content
+            content.gsub!(/\)/, '\\)')
+            line_breaks + content
           end.join(' ')
         end
 
-        def source_for(str_node)
-          if character_literal?(str_node)
-            @interpolated = true
-            begin_pos = str_node.loc.expression.begin_pos + QUESTION_MARK_SIZE
-            end_pos = str_node.loc.expression.end_pos
-          else
-            begin_pos = str_node.loc.begin.end_pos
-            end_pos = str_node.loc.end.begin_pos
-          end
-          Parser::Source::Range.new(str_node.loc.expression.source_buffer,
-                                    begin_pos, end_pos).source
+        def escape_string(string)
+          string.inspect[1..-2].tap { |s| s.gsub!(/\\"/, '"') }
         end
 
-        def character_literal?(node)
-          node.loc.end.nil?
+        def style_detected(style, ary_size)
+          cfg = config_to_allow_offenses
+          return if cfg['Enabled'] == false
+
+          @largest_brackets ||= -Float::INFINITY
+          @smallest_percent ||= Float::INFINITY
+
+          if style == :percent
+            @smallest_percent = ary_size if ary_size < @smallest_percent
+          elsif ary_size > @largest_brackets
+            @largest_brackets = ary_size
+          end
+
+          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
         end
       end
     end