rubocop 0.23.0 → 0.24.0

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

@@ -23,25 +23,25 @@ module RuboCop
         include ConfigurableEnforcedStyle
 
         MSG = 'Use `next` to skip iteration.'
-        METHODS = [:collect, :detect, :downto, :each, :find, :find_all,
-                   :inject, :loop, :map!, :map, :reduce, :reverse_each,
-                   :select, :times, :upto]
+        ENUMERATORS = [:collect, :detect, :downto, :each, :find, :find_all,
+                       :inject, :loop, :map!, :map, :reduce, :reverse_each,
+                       :select, :times, :upto]
 
         def on_block(node)
-          method, _, body = *node
-          return unless method.type == :send
+          block_owner, _, body = *node
+          return unless block_owner.type == :send
           return if body.nil?
 
-          _, method_name = *method
-          return unless method?(method_name)
+          _, method_name = *block_owner
+          return unless enumerator?(method_name)
           return unless ends_with_condition?(body)
 
-          add_offense(method, :selector, MSG)
+          add_offense(block_owner, :selector, MSG)
         end
 
         def on_while(node)
           _, body = *node
-          return unless ends_with_condition?(body)
+          return unless body && ends_with_condition?(body)
 
           add_offense(node, :keyword, MSG)
         end
@@ -56,8 +56,8 @@ module RuboCop
 
         private
 
-        def method?(method_name)
-          METHODS.include?(method_name) || /\Aeach_/.match(method_name)
+        def enumerator?(method_name)
+          ENUMERATORS.include?(method_name) || /\Aeach_/.match(method_name)
         end
 
         def ends_with_condition?(body)
@@ -66,14 +66,14 @@ module RuboCop
           body.type == :begin && simple_if_without_break?(body.children.last)
         end
 
-        def simple_if_without_break?(body)
-          return false if ternary_op?(body)
-          return false if if_else?(body)
-          return false unless body.type == :if
-          return false if style == :skip_modifier_ifs && modifier_if?(body)
+        def simple_if_without_break?(node)
+          return false if ternary_op?(node)
+          return false if if_else?(node)
+          return false unless node.type == :if
+          return false if style == :skip_modifier_ifs && modifier_if?(node)
 
-          _, return_method, return_body  = *body
-          (return_method || return_body).type != :break
+          _conditional, if_body, else_body = *node
+          ![:break, :return].include?((if_body || else_body).type)
         end
       end
     end

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

@@ -47,15 +47,28 @@ module RuboCop
 
         def autocorrect(node)
           @corrections << lambda do |corrector|
-            int = node.loc.expression.source.to_i
-            formatted_int = int
-              .abs
-              .to_s
-              .reverse
-              .gsub(/...(?=.)/, '\&_')
-              .reverse
-            formatted_int.insert(0, '-') if int < 0
-            corrector.replace(node.loc.expression, formatted_int)
+            corrector.replace(
+              node.loc.expression,
+              format_number(node)
+            )
+          end
+        end
+
+        def format_number(node)
+          int_part, float_part = node.loc.expression.source.split('.')
+          int_part = int_part.to_i
+          formatted_int = int_part
+                          .abs
+                          .to_s
+                          .reverse
+                          .gsub(/...(?=.)/, '\&_')
+                          .reverse
+          formatted_int.insert(0, '-') if int_part < 0
+
+          if float_part
+            format('%s.%s', formatted_int, float_part)
+          else
+            formatted_int
           end
         end
 

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

@@ -39,6 +39,7 @@ module RuboCop
         end
 
         def modifier_op?(node)
+          return false if ternary_op?(node)
           return true if node.type == :rescue
 
           [:if, :while, :until].include?(node.type) &&

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

@@ -27,7 +27,7 @@ module RuboCop
       #
       #   def foo2
       #     bar = 1
-      #     self.bar # resolves name class with local variable
+      #     self.bar # resolves name clash with local variable
       #   end
       #
       # * Calling an attribute writer to prevent an local variable assignment

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

@@ -50,9 +50,7 @@ module RuboCop
         end
 
         def convention_on(line, column, last_on_line)
-          range = source_range(@processed_source.buffer,
-                               @processed_source[0...(line - 1)], column,
-                               1)
+          range = source_range(@processed_source.buffer, line, column)
           add_offense(last_on_line ? range : nil, range)
         end
 

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

@@ -11,20 +11,24 @@ module RuboCop
 
         def on_pair(node)
           oper = node.loc.operator
-          return unless oper.is?(':') &&
-            oper.source_buffer.source[oper.end_pos] =~ /\S/
+          return unless oper.is?(':') && followed_by_space?(oper)
 
           add_offense(oper, oper)
         end
 
         def on_if(node)
           return unless ternary_op?(node)
+
           colon = node.loc.colon
-          return unless colon.source_buffer.source[colon.end_pos] =~ /\S/
+          return unless followed_by_space?(colon)
 
           add_offense(colon, colon)
         end
 
+        def followed_by_space?(colon)
+          colon.source_buffer.source[colon.end_pos] =~ /\S/
+        end
+
         def autocorrect(range)
           @corrections << lambda do |corrector|
             corrector.insert_after(range, ' ')

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

@@ -57,9 +57,11 @@ module RuboCop
         end
 
         def autocorrect(range)
+          m = range.source.match(/=\s*(\S+)/)
+          rest = m ? m.captures[0] : ''
           replacement = style == :space ? ' = ' : '='
           @corrections << lambda do |corrector|
-            corrector.replace(range, replacement)
+            corrector.replace(range, replacement + rest)
           end
         end
       end

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

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for comma (,) preceded by space.
+      class SpaceBeforeComma < Cop
+        include SpaceBeforePunctuation
+
+        def kind(token)
+          'comma' if token.type == :tCOMMA
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for semicolon (;) preceded by space.
+      class SpaceBeforeSemicolon < Cop
+        include SpaceBeforePunctuation
+
+        def kind(token)
+          'semicolon' if token.type == :tSEMI
+        end
+      end
+    end
+  end
+end

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

@@ -13,11 +13,12 @@ module RuboCop
             next unless match
 
             spaces = match.captures[0]
-            add_offense(nil,
-                        source_range(processed_source.buffer,
-                                     processed_source[0...index],
-                                     spaces.length, 1),
-                        MSG)
+
+            range = source_range(processed_source.buffer,
+                                 index + 1,
+                                 spaces.length)
+
+            add_offense(nil, range, MSG)
           end
         end
       end

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

@@ -4,11 +4,31 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for trailing comma in parameter lists and literals.
+      #
+      # @example
+      #   # always bad
+      #   a = [1, 2,]
+      #   b = [
+      #     1, 2,
+      #     3,
+      #   ]
+      #
+      #   # good if EnforcedStyleForMultiline is comma
+      #   a = [
+      #     1,
+      #     2,
+      #   ]
+      #
+      #   # good if EnforcedStyleForMultiline is no_comma
+      #   a = [
+      #     1,
+      #     2
+      #   ]
       class TrailingComma < Cop
         include ArraySyntax
         include ConfigurableEnforcedStyle
 
-        MSG = '%s comma after the last %s.'
+        MSG = '%s comma after the last %s'
 
         def on_array(node)
           check_literal(node, 'item of %s array') if square_brackets?(node)
@@ -56,7 +76,13 @@ module RuboCop
           should_have_comma = style == :comma && multiline?(node)
           if comma_offset
             unless should_have_comma
-              avoid_comma(kind, after_last_item.begin_pos + comma_offset, sb)
+              extra_info = if style == :comma
+                             ', unless each item is on its own line'
+                           else
+                             ''
+                           end
+              avoid_comma(kind, after_last_item.begin_pos + comma_offset, sb,
+                          extra_info)
             end
           elsif should_have_comma
             put_comma(items, kind, sb)
@@ -88,15 +114,16 @@ module RuboCop
         end
 
         def on_same_line?(a, b)
-          [a, b].map(&:line).uniq.size == 1
+          a.line + a.source.count("\n") == b.line
         end
 
-        def avoid_comma(kind, comma_begin_pos, sb)
+        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(nil, range,
-                      format(MSG, 'Avoid', format(kind, article)))
+                      format(MSG, 'Avoid', format(kind, article)) +
+                      extra_info + '.')
         end
 
         def put_comma(items, kind, sb)
@@ -106,7 +133,7 @@ module RuboCop
           range = Parser::Source::Range.new(sb, last_expr.begin_pos + ix,
                                             last_expr.end_pos)
           add_offense(nil, range,
-                      format(MSG, 'Put a', format(kind, 'a multiline')))
+                      format(MSG, 'Put a', format(kind, 'a multiline') + '.'))
         end
       end
     end

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

@@ -10,10 +10,11 @@ module RuboCop
         def investigate(processed_source)
           processed_source.lines.each_with_index do |line, index|
             next unless line =~ /.*[ \t]+$/
+
             range = source_range(processed_source.buffer,
-                                 processed_source[0...index],
-                                 line.rstrip.length,
-                                 line.length - line.rstrip.length)
+                                 index + 1,
+                                 (line.rstrip.length)...(line.length))
+
             add_offense(range, range)
           end
         end

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

@@ -23,6 +23,12 @@ module RuboCop
 
           add_offense(node, :expression)
         end
+
+        def autocorrect(node)
+          @corrections << lambda do |corrector|
+            corrector.replace(node.loc.begin, '%w(')
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    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.'
+
+        def on_dstr(node)
+          # Using %Q to avoid escaping inner " is ok.
+          check(node) unless node.loc.expression.source =~ /"/
+        end
+
+        def on_str(node)
+          check(node)
+        end
+
+        private
+
+        def check(node)
+          src = node.loc.expression.source
+          return unless src =~ /^%q/i
+          return if src =~ /'/ && src =~ /"/
+
+          extra = if src =~ /^%Q/
+                    ', or for dynamic strings that contain double quotes'
+                  else
+                    ''
+                  end
+          add_offense(node, :expression, format(MSG, src[0, 2], extra))
+        end
+
+        def autocorrect(node)
+          delimiter = node.loc.expression.source =~ /^%Q[^"]+$|'/ ? '"' : "'"
+          @corrections << lambda do |corrector|
+            corrector.replace(node.loc.begin, delimiter)
+            corrector.replace(node.loc.end, delimiter)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -14,10 +14,9 @@ module RuboCop
         private
 
         def autocorrect(node)
-          string, = *node
           @corrections << lambda do |corrector|
-            corrector.replace(node.loc.expression,
-                              "`#{string.loc.expression.source}`")
+            corrector.replace(node.loc.begin, '`')
+            corrector.replace(node.loc.end, '`')
           end
         end
       end

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

@@ -45,7 +45,7 @@ module RuboCop
             next if source.start_with?('?') # %W(\r \n) can replace [?\r, ?\n]
 
             str_content = Util.strip_quotes(source)
-            return true unless str_content =~ /\A[\w-]+\z/
+            return true unless str_content =~ /\A[\p{Word}]+\z/
           end
 
           false

data/lib/rubocop/cop/team.rb

@@ -25,27 +25,21 @@ module RuboCop
 
       def inspect_file(processed_source)
         # If we got any syntax errors, return only the syntax offenses.
-        # Parser may return nil for AST even though there are no syntax errors.
-        # e.g. sources which contain only comments
         unless processed_source.valid_syntax?
-          diagnostics = processed_source.diagnostics
-          return Lint::Syntax.offenses_from_diagnostics(diagnostics)
+          return Lint::Syntax.offenses_from_processed_source(processed_source)
         end
 
         commissioner = Commissioner.new(cops, forces)
         offenses = commissioner.investigate(processed_source)
-        process_commissioner_errors(
-          processed_source.file_path, commissioner.errors)
+        process_commissioner_errors(processed_source.path, commissioner.errors)
         autocorrect(processed_source.buffer, cops)
         offenses
       end
 
       def cops
-        @cops ||= begin
-          @cop_classes.each_with_object([]) do |cop_class, instances|
-            next unless cop_enabled?(cop_class)
-            instances << cop_class.new(@config, @options)
-          end
+        @cops ||= @cop_classes.each_with_object([]) do |cop_class, instances|
+          next unless cop_enabled?(cop_class)
+          instances << cop_class.new(@config, @options)
         end
       end
 
@@ -80,7 +74,7 @@ module RuboCop
                        # We raise RuntimeError ourselves if the rewritten code
                        # is not parsable ruby. We don't want to write that code
                        # to file.
-                       fail unless SourceParser.parse(s).valid_syntax?
+                       fail unless ProcessedSource.new(s).valid_syntax?
                        s
                      rescue RangeError, RuntimeError
                        # Handle all errors by limiting the changes to one