rubocop 0.35.1 → 0.36.0

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -13,13 +14,13 @@ module RuboCop
       #   # good
       #   Person = Struct.new(:first_name, :last_name)
       class StructInheritance < Cop
-        MSG = "Don't extend an instance initialized by `Struct.new`."
+        MSG = "Don't extend an instance initialized by `Struct.new`.".freeze
 
         def on_class(node)
           _name, superclass, _body = *node
           return unless struct_constructor?(superclass)
 
-          add_offense(node, superclass.loc.expression, MSG)
+          add_offense(node, superclass.source_range, MSG)
         end
 
         private

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

@@ -1,21 +1,88 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
-      # This cop checks for array literals made up of symbols
-      # that are not using the %i() syntax.
+      # This cop can check for array literals made up of symbols that are not
+      # using the %i() syntax.
       #
-      # This check makes sense only on Ruby 2.0+.
+      # Alternatively, it checks for symbol arrays using the %i() syntax on
+      # projects which do not want to use that syntax, perhaps because they
+      # support a version of Ruby lower than 2.0.
       class SymbolArray < Cop
+        include ConfigurableEnforcedStyle
         include ArraySyntax
 
-        MSG = 'Use %i or %I for array of symbols.'
+        PERCENT_MSG = 'Use `%i` or `%I` for an array of symbols.'.freeze
+        ARRAY_MSG = 'Use `[]` for an array of symbols.'.freeze
 
         def on_array(node)
-          # %i and %I were introduced in Ruby 2.0
-          return if RUBY_VERSION < '2.0.0'
-          add_offense(node, :expression) if array_of?(:sym, node)
+          if bracketed_array_of?(:sym, node)
+            return if comments_in_array?(node)
+            return if symbols_contain_spaces?(node)
+            style_detected(:brackets)
+            add_offense(node, :expression, PERCENT_MSG) if style == :percent
+          elsif node.loc.begin && node.loc.begin.source =~ /\A%[iI]/
+            style_detected(:percent)
+            add_offense(node, :expression, ARRAY_MSG) if style == :brackets
+          end
+        end
+
+        def validate_config
+          if style == :percent && target_ruby_version < 2.0
+            fail ValidationError, 'The default `percent` style for the ' \
+                                  '`Style/SymbolArray` cop is only compatible' \
+                                  ' with Ruby 2.0 and up, but the target Ruby' \
+                                  " version for your project is 1.9.\nPlease " \
+                                  'either disable this cop, configure it to ' \
+                                  'use `array` style, or adjust the ' \
+                                  '`TargetRubyVersion` parameter in your ' \
+                                  'configuration.'
+          end
+        end
+
+        private
+
+        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
+        end
+
+        def symbols_contain_spaces?(node)
+          node.children.any? do |sym|
+            content, = *sym
+            content =~ / /
+          end
+        end
+
+        def autocorrect(node)
+          syms = node.children.map { |c| c.children[0].to_s }
+          corrected = if style == :percent
+                        escape = syms.any? { |s| double_quotes_required?(s) }
+                        syms = syms.map { |s| escape_string(s) } if escape
+                        syms = syms.map { |s| s.gsub(/\)/, '\\)') }
+                        if escape
+                          "%I(#{syms.join(' ')})"
+                        else
+                          "%i(#{syms.join(' ')})"
+                        end
+                      else
+                        syms = syms.map { |s| to_symbol_literal(s) }
+                        "[#{syms.join(', ')}]"
+                      end
+
+          lambda do |corrector|
+            corrector.replace(node.source_range, corrected)
+          end
+        end
+
+        def escape_string(string)
+          string.inspect[1..-2].tap { |s| s.gsub!(/\\"/, '"') }
         end
       end
     end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -13,21 +14,17 @@ module RuboCop
       #   # good
       #   :symbol
       class SymbolLiteral < Cop
-        MSG = 'Do not use strings for word-like symbol literals.'
+        MSG = 'Do not use strings for word-like symbol literals.'.freeze
 
         def on_sym(node)
-          sym_name = node.loc.expression.source
-
-          return unless sym_name =~ /\A:["'][A-Za-z_]\w*["']\z/
+          return unless node.source =~ /\A:["'][A-Za-z_]\w*["']\z/
 
           add_offense(node, :expression)
         end
 
         def autocorrect(node)
           lambda do |corrector|
-            current_name = node.loc.expression.source
-            corrector.replace(node.loc.expression,
-                              current_name.delete(%q('")))
+            corrector.replace(node.source_range, node.source.delete(%q('")))
           end
         end
       end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -12,7 +13,7 @@ module RuboCop
       #   # good
       #   something.map(&:upcase)
       class SymbolProc < Cop
-        MSG = 'Pass `&:%s` as an argument to `%s` instead of a block.'
+        MSG = 'Pass `&:%s` as an argument to `%s` instead of a block.'.freeze
 
         PROC_NODE = s(:send, s(:const, nil, :Proc), :new)
 
@@ -35,7 +36,7 @@ module RuboCop
 
           _receiver, method_name, _args = *block_body
 
-          sb = node.loc.expression.source_buffer
+          sb = node.source_range.source_buffer
           block_start = node.loc.begin.begin_pos
           block_end = node.loc.end.end_pos
           range = Parser::Source::Range.new(sb, block_start, block_end)
@@ -54,11 +55,10 @@ module RuboCop
 
             if super?(block_send_or_super)
               args = *block_send_or_super
-              autocorrect_method(corrector, node, args, method_name)
             else
               _breceiver, _bmethod_name, *args = *block_send_or_super
-              autocorrect_method(corrector, node, args, method_name)
             end
+            autocorrect_method(corrector, node, args, method_name)
           end
         end
 
@@ -75,13 +75,17 @@ module RuboCop
         end
 
         def autocorrect_with_args(corrector, node, args, method_name)
-          corrector.insert_after(args.last.loc.expression, ", &:#{method_name}")
+          arg_range = args.last.source_range
+          arg_range = range_with_surrounding_comma(arg_range, :right)
+          replacement = " &:#{method_name}"
+          replacement = ',' + replacement unless arg_range.source.end_with?(',')
+          corrector.insert_after(arg_range, replacement)
           corrector.remove(block_range_with_space(node))
         end
 
         def block_range_with_space(node)
           block_range =
-            Parser::Source::Range.new(node.loc.expression.source_buffer,
+            Parser::Source::Range.new(node.source_range.source_buffer,
                                       begin_pos_for_replacement(node),
                                       node.loc.end.end_pos)
           range_with_surrounding_space(block_range, :left)
@@ -89,7 +93,7 @@ module RuboCop
 
         def begin_pos_for_replacement(node)
           block_send_or_super, _block_args, _block_body = *node
-          expr = block_send_or_super.loc.expression
+          expr = block_send_or_super.source_range
 
           if (paren_pos = (expr.source =~ /\(\s*\)$/))
             expr.begin_pos + paren_pos

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

@@ -1,19 +1,24 @@
 # encoding: utf-8
+# frozen_string_literal: true
+
+require 'set'
 
 module RuboCop
   module Cop
     module Style
       # This cop checks for tabs inside the source code.
       class Tab < Cop
-        MSG = 'Tab detected.'
+        MSG = 'Tab detected.'.freeze
 
         def investigate(processed_source)
+          str_lines = string_literal_lines(processed_source.ast)
+
           processed_source.lines.each_with_index do |line, index|
             match = line.match(/^( *)[\t ]*\t/)
             next unless match
+            next if str_lines.include?(index + 1)
 
             spaces = match.captures[0]
-
             range = source_range(processed_source.buffer,
                                  index + 1,
                                  (spaces.length)...(match.end(0)))
@@ -29,6 +34,24 @@ module RuboCop
             corrector.replace(range, range.source.gsub(/\t/, '  '))
           end
         end
+
+        def string_literal_lines(ast)
+          # which lines start inside a string literal?
+          return [] if ast.nil?
+
+          ast.each_node(:str, :dstr).each_with_object(Set.new) do |str, lines|
+            loc = str.location
+
+            str_lines = if loc.is_a?(Parser::Source::Map::Heredoc)
+                          body = loc.heredoc_body
+                          (body.first_line)..(body.last_line)
+                        else
+                          (loc.first_line + 1)..(loc.last_line)
+                        end
+
+            lines.merge(str_lines.to_a)
+          end
+        end
       end
     end
   end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -42,8 +43,6 @@ module RuboCop
                       message(wanted_blank_lines, blank_lines))
         end
 
-        private
-
         def ends_in_end?(processed_source)
           sb = processed_source.buffer
 

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

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for trailing comma in argument lists.
+      #
+      # @example
+      #   # always bad
+      #   method(1, 2,)
+      #
+      #   # good if EnforcedStyleForMultiline is consistent_comma
+      #   method(
+      #     1, 2,
+      #     3,
+      #   )
+      #
+      #   # good if EnforcedStyleForMultiline is comma or consistent_comma
+      #   method(
+      #     1,
+      #     2,
+      #   )
+      #
+      #   # good if EnforcedStyleForMultiline is no_comma
+      #   method(
+      #     1,
+      #     2
+      #   )
+      class TrailingCommaInArguments < Cop
+        include TrailingComma
+
+        def on_send(node)
+          _receiver, _method_name, *args = *node
+          return if args.empty?
+          # It's impossible for a method call without parentheses to have
+          # a trailing comma.
+          return unless brackets?(node)
+
+          check(node, args, 'parameter of %s method call',
+                args.last.source_range.end_pos, node.source_range.end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for trailing comma in array and hash literals.
+      #
+      # @example
+      #   # always bad
+      #   a = [1, 2,]
+      #
+      #   # good if EnforcedStyleForMultiline is consistent_comma
+      #   a = [
+      #     1, 2,
+      #     3,
+      #   ]
+      #
+      #   # good if EnforcedStyleForMultiline is comma or consistent_comma
+      #   a = [
+      #     1,
+      #     2,
+      #   ]
+      #
+      #   # good if EnforcedStyleForMultiline is no_comma
+      #   a = [
+      #     1,
+      #     2
+      #   ]
+      class TrailingCommaInLiteral < Cop
+        include ArraySyntax
+        include TrailingComma
+
+        def on_array(node)
+          check_literal(node, 'item of %s array') if square_brackets?(node)
+        end
+
+        def on_hash(node)
+          check_literal(node, 'item of %s hash')
+        end
+
+        private
+
+        def check_literal(node, kind)
+          return if node.children.empty?
+          # A braceless hash is the last parameter of a method call and will be
+          # checked as such.
+          return unless brackets?(node)
+
+          check(node, node.children, kind,
+                node.children.last.source_range.end_pos,
+                node.loc.end.begin_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -31,9 +32,9 @@ module RuboCop
           return if first_offense.nil?
 
           range =
-            Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                      first_offense.loc.expression.begin_pos,
-                                      variables.last.loc.expression.end_pos)
+            Parser::Source::Range.new(node.source_range.source_buffer,
+                                      first_offense.source_range.begin_pos,
+                                      variables.last.source_range.end_pos)
           add_offense(node, range)
         end
 
@@ -43,15 +44,15 @@ module RuboCop
           first_offense = find_first_offense(variables)
 
           end_position =
-            if first_offense.loc.expression == variables.first.loc.expression
-              right.loc.expression.begin_pos
+            if first_offense.source_range == variables.first.source_range
+              right.source_range.begin_pos
             else
               node.loc.operator.begin_pos
             end
 
           range =
-            Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                      first_offense.loc.expression.begin_pos,
+            Parser::Source::Range.new(node.source_range.source_buffer,
+                                      first_offense.source_range.begin_pos,
                                       end_position)
 
           ->(corrector) { corrector.remove(range) unless range.nil? }

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

@@ -1,11 +1,12 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
       # This cop looks for trailing whitespace in the source code.
       class TrailingWhitespace < Cop
-        MSG = 'Trailing whitespace detected.'
+        MSG = 'Trailing whitespace detected.'.freeze
 
         def investigate(processed_source)
           processed_source.lines.each_with_index do |line, index|

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -6,16 +7,16 @@ module RuboCop
       # This cop looks for trivial reader/writer methods, that could
       # have been created with the attr_* family of functions automatically.
       class TrivialAccessors < Cop
-        MSG = 'Use `attr_%s` to define trivial %s methods.'
+        MSG = 'Use `attr_%s` to define trivial %s methods.'.freeze
 
         def on_def(node)
-          return if in_module?(node)
+          return if in_module_or_instance_eval?(node)
           method_name, args, body = *node
           on_method_def(node, method_name, args, body)
         end
 
         def on_defs(node)
-          return if in_module?(node)
+          return if in_module_or_instance_eval?(node)
           return if ignore_class_methods?
           _scope, method_name, args, body = *node
           on_method_def(node, method_name, args, body)
@@ -23,10 +24,18 @@ module RuboCop
 
         private
 
-        def in_module?(node)
-          pnode = node.parent
-          pnode = pnode.parent if pnode && pnode.type == :begin
-          !pnode.nil? && pnode.type == :module
+        def in_module_or_instance_eval?(node)
+          node.each_ancestor(:block, :class, :sclass, :module).each do |pnode|
+            case pnode.type
+            when :class, :sclass
+              return false
+            when :module
+              return true
+            else
+              return true if pnode.method_name == :instance_eval
+            end
+          end
+          false
         end
 
         def on_method_def(node, method_name, args, body)
@@ -141,7 +150,7 @@ module RuboCop
           end
 
           lambda do |corrector|
-            corrector.replace(node.loc.expression, accessor(kind, method_name))
+            corrector.replace(node.source_range, accessor(kind, method_name))
           end
         end
 
@@ -155,7 +164,7 @@ module RuboCop
           lambda do |corrector|
             indent = ' ' * node.loc.column
             corrector.replace(
-              node.loc.expression,
+              node.source_range,
               ['class << self',
                "#{indent}  #{accessor(kind, method_name)}",
                "#{indent}end"].join("\n")