rubocop 0.35.1 → 0.36.0

data/lib/rubocop/cop/mixin/string_help.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -7,10 +8,6 @@ module RuboCop
     # adding offenses for the faulty string nodes, and with filtering out
     # nodes.
     module StringHelp
-      # Regex matches IF there is a ' or there is a \\ in the string that is
-      # not preceded/followed by another \\ (e.g. "\\x34") but not "\\\\".
-      ESCAPED_CHAR_REGEXP = /(?<! \\) \\{2}* \\ (?! \\)/x
-
       def on_str(node)
         # Constants like __FILE__ are handled as strings,
         # but don't respond to begin.
@@ -30,11 +27,7 @@ module RuboCop
 
       def inside_interpolation?(node)
         # A :begin node inside a :dstr node is an interpolation.
-        begin_found = false
-        node.each_ancestor.any? do |a|
-          begin_found = true if a.type == :begin
-          begin_found && a.type == :dstr
-        end
+        node.ancestors.drop_while { |a| !a.begin_type? }.any?(&:dstr_type?)
       end
     end
   end

data/lib/rubocop/cop/mixin/string_literals_help.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -6,21 +7,26 @@ module RuboCop
     module StringLiteralsHelp
       include StringHelp
 
-      def wrong_quotes?(node, style)
-        src = node.loc.expression.source
-        return false if src.start_with?('%') || src.start_with?('?')
+      def wrong_quotes?(node)
+        src = node.source
+        return false if src.start_with?('%', '?')
         if style == :single_quotes
-          src !~ /'/ && src !~ StringHelp::ESCAPED_CHAR_REGEXP
+          src !~ /'/ && !double_quotes_acceptable?(node.str_content)
         else
           src !~ /" | \\ | \#/x
         end
       end
 
       def autocorrect(node)
+        return if node.dstr_type?
+
         lambda do |corrector|
-          replacement = node.loc.begin.is?('"') ? "'" : '"'
-          corrector.replace(node.loc.begin, replacement)
-          corrector.replace(node.loc.end, replacement)
+          str = node.str_content
+          if style == :single_quotes
+            corrector.replace(node.source_range, to_string_literal(str))
+          else
+            corrector.replace(node.source_range, str.inspect)
+          end
         end
       end
     end

data/lib/rubocop/cop/mixin/surrounding_space.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -16,12 +17,12 @@ module RuboCop
       end
 
       def index_of_first_token(node)
-        b = node.loc.expression.begin
+        b = node.source_range.begin
         token_table[b.line][b.column]
       end
 
       def index_of_last_token(node)
-        e = node.loc.expression.end
+        e = node.source_range.end
         (0...e.column).to_a.reverse_each do |c|
           ix = token_table[e.line][c]
           return ix if ix

data/lib/rubocop/cop/mixin/trailing_comma.rb

@@ -0,0 +1,134 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common methods shared by Style/TrailingCommaInArguments and
+    # Style/TrailingCommaInLiteral
+    module TrailingComma
+      include ConfigurableEnforcedStyle
+
+      MSG = '%s comma after the last %s'.freeze
+
+      def parameter_name
+        'EnforcedStyleForMultiline'
+      end
+
+      def check(node, items, kind, begin_pos, end_pos)
+        sb = node.source_range.source_buffer
+        after_last_item = Parser::Source::Range.new(sb, begin_pos, end_pos)
+
+        return if heredoc?(after_last_item.source)
+
+        comma_offset = after_last_item.source =~ /,/
+
+        if comma_offset && !inside_comment?(after_last_item, comma_offset)
+          unless should_have_comma?(style, node)
+            extra_info = case style
+                         when :comma
+                           ', unless each item is on its own line'
+                         when :consistent_comma
+                           ', unless items are split onto multiple lines'
+                         else
+                           ''
+                         end
+            avoid_comma(kind, after_last_item.begin_pos + comma_offset, sb,
+                        extra_info)
+          end
+        elsif should_have_comma?(style, node)
+          put_comma(items, kind, sb)
+        end
+      end
+
+      def should_have_comma?(style, node)
+        [:comma, :consistent_comma].include?(style) &&
+          multiline?(node)
+      end
+
+      def inside_comment?(range, comma_offset)
+        processed_source.comments.any? do |comment|
+          comment_offset = comment.loc.expression.begin_pos - range.begin_pos
+          comment_offset >= 0 && comment_offset < comma_offset
+        end
+      end
+
+      def heredoc?(source_after_last_item)
+        source_after_last_item =~ /\w/
+      end
+
+      # Returns true if the node has round/square/curly brackets.
+      def brackets?(node)
+        node.loc.end
+      end
+
+      # Returns true if the round/square/curly brackets of the given node are
+      # on different lines, and each item within is on its own line, and the
+      # closing bracket is on its own line.
+      def multiline?(node)
+        elements = if node.type == :send
+                     _receiver, _method_name, *args = *node
+                     args.flat_map do |a|
+                       # For each argument, if it is a multi-line hash,
+                       # then promote the hash elements to method arguments
+                       # for the purpose of determining multi-line-ness.
+                       if a.hash_type? && a.loc.first_line != a.loc.last_line
+                         a.children
+                       else
+                         a
+                       end
+                     end
+                   else
+                     node.children
+                   end
+
+        # Without this check, Foo.new({}) is considered multiline, which
+        # it should not be. Essentially, if there are no elements, the
+        # expression can not be multiline.
+        return if elements.empty?
+
+        items = elements.map(&:source_range)
+        if style == :consistent_comma
+          items.one? || items.each_cons(2).any? { |a, b| !on_same_line?(a, b) }
+        else
+          items << node.loc.end
+          items.each_cons(2).all? { |a, b| !on_same_line?(a, b) }
+        end
+      end
+
+      def on_same_line?(a, b)
+        a.last_line == b.line
+      end
+
+      def avoid_comma(kind, comma_begin_pos, sb, extra_info)
+        range = Parser::Source::Range.new(sb, comma_begin_pos,
+                                          comma_begin_pos + 1)
+        article = kind =~ /array/ ? 'an' : 'a'
+        add_offense(range, range,
+                    format(MSG, 'Avoid', format(kind, article)) +
+                    "#{extra_info}.")
+      end
+
+      def put_comma(items, kind, sb)
+        last_item = items.last
+        return if last_item.type == :block_pass
+
+        last_expr = last_item.source_range
+        ix = last_expr.source.rindex("\n") || 0
+        ix += last_expr.source[ix..-1] =~ /\S/
+        range = Parser::Source::Range.new(sb, last_expr.begin_pos + ix,
+                                          last_expr.end_pos)
+        add_offense(range, range,
+                    format(MSG, 'Put a', format(kind, 'a multiline') + '.'))
+      end
+
+      def autocorrect(range)
+        lambda do |corrector|
+          case range.source
+          when ',' then corrector.remove(range)
+          else          corrector.insert_after(range, ',')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/mixin/unused_argument.rb

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

data/lib/rubocop/cop/offense.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -7,7 +8,8 @@ module RuboCop
       include Comparable
 
       # @api private
-      COMPARISON_ATTRIBUTES = [:line, :column, :cop_name, :message, :severity]
+      COMPARISON_ATTRIBUTES = [:line, :column, :cop_name,
+                               :message, :severity].freeze
 
       # @api public
       #
@@ -50,6 +52,20 @@ module RuboCop
       #   'LineLength'
       attr_reader :cop_name
 
+      # @api private
+      attr_reader :status
+
+      # @api private
+      def initialize(severity, location, message, cop_name,
+                     status = :uncorrected)
+        @severity = RuboCop::Cop::Severity.new(severity)
+        @location = location
+        @message = message.freeze
+        @cop_name = cop_name.freeze
+        @status = status
+        freeze
+      end
+
       # @api public
       #
       # @!attribute [r] corrected
@@ -59,7 +75,7 @@ module RuboCop
       def corrected
         @status == :unsupported ? nil : @status == :corrected
       end
-      alias_method :corrected?, :corrected
+      alias corrected? corrected
 
       # @api public
       #
@@ -71,17 +87,6 @@ module RuboCop
         @status == :disabled
       end
 
-      # @api private
-      def initialize(severity, location, message, cop_name,
-                     status = :uncorrected)
-        @severity = RuboCop::Cop::Severity.new(severity)
-        @location = location
-        @message = message.freeze
-        @cop_name = cop_name.freeze
-        @status = status
-        freeze
-      end
-
       # @api private
       # This is just for debugging purpose.
       def to_s
@@ -118,7 +123,7 @@ module RuboCop
         end
       end
 
-      alias_method :eql?, :==
+      alias eql? ==
 
       def hash
         COMPARISON_ATTRIBUTES.reduce(0) do |hash, attribute|

data/lib/rubocop/cop/performance/case_when_splat.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -71,7 +72,7 @@ module RuboCop
             end
 
           splat_offenses(when_conditions).reverse_each do |condition|
-            range = condition.parent.loc.keyword.join(condition.loc.expression)
+            range = condition.parent.loc.keyword.join(condition.source_range)
             variable, = *condition
             message = variable.array_type? ? ARRAY_MSG : MSG
             add_offense(condition.parent, range, message)
@@ -116,7 +117,7 @@ module RuboCop
               corrector.remove(variable.loc.begin)
               corrector.remove(variable.loc.end)
             else
-              corrector.replace(condition.loc.expression,
+              corrector.replace(condition.source_range,
                                 expand_percent_array(variable))
             end
           end
@@ -126,23 +127,22 @@ module RuboCop
           _case_branch, *when_branches, _else_branch = *node.parent
           current_index = when_branches.index { |branch| branch == node }
           next_branch = when_branches[current_index + 1]
-          correction = "\n#{offset(node)}#{node.loc.expression.source}"
+          correction = "\n#{offset(node)}#{node.source}"
           range =
             Parser::Source::Range.new(node.parent,
-                                      node.loc.expression.begin_pos,
-                                      next_branch.loc.expression.begin_pos)
+                                      node.source_range.begin_pos,
+                                      next_branch.source_range.begin_pos)
 
           lambda do |corrector|
             corrector.remove(range)
-            corrector.insert_after(when_branches.last.loc.expression,
-                                   correction)
+            corrector.insert_after(when_branches.last.source_range, correction)
           end
         end
 
         def expand_percent_array(array)
           array_start = array.loc.begin.source
           elements = *array
-          elements = elements.map { |e| e.loc.expression.source }
+          elements = elements.map(&:source)
 
           if array_start.start_with?(PERCENT_W)
             "'#{elements.join("', '")}'"

data/lib/rubocop/cop/performance/casecmp.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Performance
+      # This cop identifies places where a case-insensitive string comparison
+      # can better be implemented using `casecmp`.
+      #
+      # @example
+      #   @bad
+      #   'abc'.downcase == 'ABC'
+      #   'abc'.upcase.eql? 'ABC'
+      #
+      #   @good
+      #   'abc'.casecmp('ABC')
+      class Casecmp < Cop
+        MSG = 'Use `casecmp` instead of `%s %s`.'.freeze
+
+        def_node_matcher :downcase_eq, <<-END
+          (send $(send _ ${:downcase :upcase}) ${:== :eql?} _)
+        END
+
+        def on_send(node)
+          downcase_eq(node) do |send_downcase, case_method, eq_method|
+            range = node.loc.selector.join(send_downcase.loc.selector)
+            add_offense(node, range, format(MSG, case_method, eq_method))
+          end
+        end
+
+        def autocorrect(node)
+          receiver, _method, arg = *node
+          range = Parser::Source::Range.new(node.source_range.source_buffer,
+                                            receiver.loc.selector.begin_pos,
+                                            arg.loc.begin.begin_pos)
+
+          lambda do |corrector|
+            # we want resulting call to be parenthesized
+            # if arg already includes one or more sets of parens, don't add more
+            # or if method call already used parens, again, don't add more
+            if arg.loc.begin.source == '('
+              corrector.replace(range, 'casecmp')
+            elsif range.source =~ /\(/
+              corrector.replace(range, 'casecmp(')
+            else
+              corrector.replace(range, 'casecmp(')
+              corrector.insert_after(arg.source_range, ')')
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/performance/count.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -24,10 +25,10 @@ module RuboCop
       #   Model.select('field AS field_one').count
       #   Model.select(:value).count
       class Count < Cop
-        MSG = 'Use `count` instead of `%s...%s`.'
+        MSG = 'Use `count` instead of `%s...%s`.'.freeze
 
-        SELECTORS = [:reject, :select]
-        COUNTERS = [:count, :length, :size]
+        SELECTORS = [:reject, :select].freeze
+        COUNTERS = [:count, :length, :size].freeze
 
         def on_send(node)
           selector, selector_loc, params, counter = parse(node)
@@ -36,9 +37,9 @@ module RuboCop
           return if params && !params.block_pass_type?
           return if node.parent && node.parent.block_type?
 
-          range = Parser::Source::Range.new(node.loc.expression.source_buffer,
+          range = Parser::Source::Range.new(node.source_range.source_buffer,
                                             selector_loc.begin_pos,
-                                            node.loc.expression.end_pos)
+                                            node.source_range.end_pos)
 
           add_offense(node, range, format(MSG, selector, counter))
         end
@@ -48,9 +49,9 @@ module RuboCop
 
           return if selector == :reject
 
-          range = Parser::Source::Range.new(node.loc.expression.source_buffer,
+          range = Parser::Source::Range.new(node.source_range.source_buffer,
                                             node.loc.dot.begin_pos,
-                                            node.loc.expression.end_pos)
+                                            node.source_range.end_pos)
 
           lambda do |corrector|
             corrector.remove(range)
@@ -68,8 +69,8 @@ module RuboCop
             if selector.is_a?(Symbol)
               if expression && expression.parent.loc.respond_to?(:selector)
                 expression.parent.loc.selector
-              else
-                left.loc.selector if left.loc.respond_to?(:selector)
+              elsif left.loc.respond_to?(:selector)
+                left.loc.selector
               end
             else
               _enumerable, selector, params = *expression