rubocop 0.27.1 → 0.28.0

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

@@ -21,27 +21,28 @@ module RuboCop
           else_range = node.loc.else
           return unless begins_its_line?(else_range)
 
-          base_range = if base
-                         base.loc.expression
-                       else
-                         base = node
-                         until %w(if unless).include?(base.loc.keyword.source)
-                           base = base.parent
-                         end
-                         base.loc.keyword
-                       end
-
-          check_alignment(base_range, else_range)
+          check_alignment(base_range(node, base), else_range)
+
+          return if else_range.source != 'elsif'
+
+          # If the `else` part is actually an `elsif`, we check the `elsif`
+          # node in case it contains an `else` within, because that `else`
+          # should have the same alignment (base).
+          _condition, _if_body, else_body = *node
+          on_if(else_body, base)
+          # The `elsif` node will get an `on_if` call from the framework later,
+          # but we're done here, so we set it to ignored.
+          ignore_node(else_body)
         end
 
         def on_rescue(node)
           return unless node.loc.else
 
           parent = node.parent
+          parent = parent.parent if parent.type == :ensure
           base = case parent.type
                  when :def, :defs then base_for_method_definition(parent)
-                 when :kwbegin    then parent.loc.begin
-                 when :ensure     then parent.parent.loc.begin
+                 when :kwbegin then parent.loc.begin
                  else node.loc.keyword
                  end
           check_alignment(base, node.loc.else)
@@ -55,6 +56,18 @@ module RuboCop
 
         private
 
+        def base_range(node, base)
+          if base
+            base.loc.expression
+          else
+            base = node
+            until %w(if unless).include?(base.loc.keyword.source)
+              base = base.parent
+            end
+            base.loc.keyword
+          end
+        end
+
         def base_for_method_definition(node)
           parent = node.parent
           if parent && parent.type == :send
@@ -81,14 +94,14 @@ module RuboCop
           ignore_node(rhs)
         end
 
-        def check_alignment(base_loc, else_range)
+        def check_alignment(base_range, else_range)
           return unless begins_its_line?(else_range)
 
-          @column_delta = base_loc.column - else_range.column
+          @column_delta = base_range.column - else_range.column
           return if @column_delta == 0
 
           add_offense(else_range, else_range,
-                      format(MSG, else_range.source, base_loc.source[/^\S*/]))
+                      format(MSG, else_range.source, base_range.source[/^\S*/]))
         end
       end
     end

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

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for empty else-clauses, possibly including comments and/or an
+      # explicit `nil`.
+      class EmptyElse < Cop
+        include OnNormalIfUnless
+
+        MSG = 'Redundant empty `else`-clause.'
+
+        def on_normal_if_unless(node)
+          check(node, if_else_clause(node))
+        end
+
+        def on_case(node)
+          check(node, case_else_clause(node))
+        end
+
+        private
+
+        def check(node, else_clause)
+          return unless node.loc.else
+          return if else_clause && else_clause.type != :nil
+
+          add_offense(node, :else, MSG)
+        end
+
+        def if_else_clause(node)
+          keyword = node.loc.keyword
+          if keyword.is?('if')
+            node.children[2]
+          elsif keyword.is?('elsif')
+            node.children[2]
+          elsif keyword.is?('unless')
+            node.children[1]
+          end
+        end
+
+        def case_else_clause(node)
+          node.children.last
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cops checks if empty lines around the bodies of blocks match
+      # the configuration.
+      #
+      # @example
+      #
+      #   something do
+      #
+      #     ...
+      #   end
+      #
+      class EmptyLinesAroundBlockBody < Cop
+        include EmptyLinesAroundBody
+
+        KIND = 'block'
+
+        def on_block(node)
+          check(node)
+        end
+
+        private
+
+        def check(node)
+          start_line = node.loc.begin.line
+          end_line = node.loc.end.line
+
+          return if start_line == end_line
+
+          check_source(start_line, end_line)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for extra/unnecessary whitespace.
+      #
+      # @example
+      #
+      #   name     = "RuboCop"
+      #   website  = "https://github.com/bbatsov/rubocop"
+      class ExtraSpacing < Cop
+        MSG = 'Unnecessary spacing detected.'
+
+        def investigate(processed_source)
+          processed_source.tokens.each_cons(2) do |t1, t2|
+            next unless t1.pos.line == t2.pos.line
+            next unless t2.pos.begin_pos - 1 > t1.pos.end_pos
+            buffer = processed_source.buffer
+            start_pos = t1.pos.end_pos
+            end_pos = t2.pos.begin_pos - 1
+            range = Parser::Source::Range.new(buffer, start_pos, end_pos)
+            add_offense(range, range, MSG)
+          end
+        end
+
+        def autocorrect(range)
+          @corrections << lambda do |corrector|
+            corrector.remove(range)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -94,7 +94,7 @@ module RuboCop
           latest_when = nil
           branches.compact.each do |b|
             if b.type == :when
-              # TODO: Revert to the original expresson once the fix in Rubinius
+              # TODO: Revert to the original expression once the fix in Rubinius
               #   is released.
               #
               # Originally this expression was:

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

@@ -12,7 +12,7 @@ module RuboCop
 
         def investigate(processed_source)
           processed_source.comments.each do |comment|
-            next unless comment.text =~ /^#+[^#\s:+-]/
+            next unless comment.text =~ /^#+[^#\s=:+-]/
             next if comment.text.start_with?('#!') && comment.loc.line == 1
 
             add_offense(comment, :expression)

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

@@ -63,7 +63,11 @@ module RuboCop
           return false unless node.loc.respond_to?(:begin)
 
           # we care only about quotes-delimited literals
-          node.loc.begin && ["'", '"'].include?(node.loc.begin.source)
+          if node.loc.begin
+            ["'", '"'].include?(node.loc.begin.source)
+          elsif node.children.any?
+            node.children.map { |child| string_type?(child) }.all?
+          end
         end
 
         def final_node_is_string_type?(node)

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

@@ -12,7 +12,7 @@ module RuboCop
       #   b
       #     something
       #   end
-      class MultilineOperationIndentation < Cop
+      class MultilineOperationIndentation < Cop # rubocop:disable ClassLength
         include ConfigurableEnforcedStyle
         include AutocorrectAlignment
 
@@ -51,7 +51,9 @@ module RuboCop
 
         def incorrect_style_detected(range, node, lhs, rhs)
           add_offense(range, range, message(node, lhs, rhs)) do
-            unless offending_range(node, lhs, rhs, alternative_style)
+            if offending_range(node, lhs, rhs, alternative_style)
+              unrecognized_style_detected
+            else
               opposite_style_detected
             end
           end
@@ -105,7 +107,11 @@ module RuboCop
         #   d                         <-- d is indented relative to a
         def left_hand_side(receiver)
           lhs = receiver
-          lhs = lhs.parent while lhs.parent && lhs.parent.type == :send
+          while lhs.parent && lhs.parent.type == :send
+            _receiver, method_name, *_args = *lhs.parent
+            break if operator?(method_name)
+            lhs = lhs.parent
+          end
           lhs
         end
 
@@ -151,7 +157,17 @@ module RuboCop
         end
 
         def assignment?(node)
-          node.each_ancestor.find { |a| ASGN_NODES.include?(a.type) }
+          node.each_ancestor.find do |a|
+            case a.type
+            when :send
+              _receiver, method_name, *_args = *a
+              # The []= operator is the only assignment operator that is parsed
+              # as a :send node.
+              method_name == :[]=
+            when *ASGN_NODES
+              true
+            end
+          end
         end
 
         def not_for_this_cop?(node)

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

@@ -30,7 +30,9 @@ module RuboCop
         def autocorrect(node)
           @corrections << lambda do |corrector|
             condition, _body, _rest = *node
-            # unwrap the negated portion of the condition (a send node)
+            # Look inside parentheses around the condition, if any.
+            condition, _ = *condition while condition.type == :begin
+            # Unwrap the negated portion of the condition (a send node).
             pos_condition, _method, = *condition
             corrector.replace(
               node.loc.keyword,

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

@@ -15,9 +15,14 @@ module RuboCop
         def autocorrect(node)
           @corrections << lambda do |corrector|
             backref, = *node
-
-            corrector.replace(node.loc.expression,
-                              "Regexp.last_match[#{backref}]")
+            parent_type = node.parent ? node.parent.type : nil
+            if [:dstr, :xstr, :regexp].include?(parent_type)
+              corrector.replace(node.loc.expression,
+                                "{Regexp.last_match[#{backref}]}")
+            else
+              corrector.replace(node.loc.expression,
+                                "Regexp.last_match[#{backref}]")
+            end
           end
         end
       end

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

@@ -53,7 +53,13 @@ module RuboCop
         def args_match?(method_name, args)
           actual_args = args.flat_map(&:to_a)
 
-          actual_args == target_args(method_name).map(&:to_sym)
+          # Prepending an underscore to mark an unused parameter is allowed, so
+          # we remove any leading underscores before comparing.
+          actual_args_no_underscores = actual_args.map do |arg|
+            arg.to_s.sub(/^_+/, '')
+          end
+
+          actual_args_no_underscores == target_args(method_name)
         end
       end
     end

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

@@ -73,9 +73,14 @@ module RuboCop
         def autocorrect(node)
           @corrections << lambda do |corrector|
             global_var, = *node
-
-            corrector.replace(node.loc.expression,
-                              PREFERRED_VARS[global_var].first)
+            parent_type = node.parent ? node.parent.type : nil
+            if [:dstr, :xstr, :regexp].include?(parent_type)
+              corrector.replace(node.loc.expression,
+                                "{#{PREFERRED_VARS[global_var].first}}")
+            else
+              corrector.replace(node.loc.expression,
+                                PREFERRED_VARS[global_var].first)
+            end
           end
         end
       end

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

@@ -8,17 +8,6 @@ module RuboCop
         include ConfigurableEnforcedStyle
         include StringLiteralsHelp
 
-        def on_dstr(node)
-          # A dstr node with dstr and str children is a concatenated
-          # string. Don't ignore the whole thing.
-          return if node.children.find { |child| child.type == :str }
-
-          # Dynamic strings can not use single quotes, and quotes inside
-          # interpolation expressions are checked by the
-          # StringLiteralsInInterpolation cop, so ignore.
-          ignore_node(node)
-        end
-
         private
 
         def message(*)
@@ -32,6 +21,10 @@ module RuboCop
         end
 
         def offense?(node)
+          # If it's a string within an interpolation, then it's not an offense
+          # for this cop.
+          return false if inside_interpolation?(node)
+
           wrong_quotes?(node, style)
         end
       end

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

@@ -19,13 +19,8 @@ module RuboCop
 
         def offense?(node)
           # If it's not a string within an interpolation, then it's not an
-          # offense for this cop. A :begin node inside a :dstr node is an
-          # interpolation.
-          begin_found = false
-          return false unless node.each_ancestor.find do |a|
-            begin_found = true if a.type == :begin
-            begin_found && a.type == :dstr
-          end
+          # offense for this cop.
+          return false unless inside_interpolation?(node)
 
           wrong_quotes?(node, style)
         end

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

@@ -14,13 +14,18 @@ module RuboCop
       class SymbolProc < Cop
         MSG = 'Pass `&:%s` as an argument to `%s` instead of a block.'
 
+        PROC_NODE = s(:send, s(:const, nil, :Proc), :new)
+
         def on_block(node)
           block_send, block_args, block_body = *node
 
           _breceiver, bmethod_name, bargs = *block_send
 
-          # we should ignore lambdas
-          return if bmethod_name == :lambda
+          # TODO: Rails-specific handling that we should probably make
+          # configurable - https://github.com/bbatsov/rubocop/issues/1485
+          # we should ignore lambdas & procs
+          return if block_send == PROC_NODE
+          return if [:lambda, :proc].include?(bmethod_name)
           return if ignored_method?(bmethod_name)
           # File.open(file) { |f| f.readlines }
           return if bargs
@@ -36,13 +41,16 @@ module RuboCop
 
         def autocorrect(node)
           @corrections << lambda do |corrector|
-            block_method, _block_args, block_body = *node
+            _block_method, _block_args, block_body = *node
             _receiver, method_name, _args = *block_body
 
-            replacement = "#{block_method.loc.expression.source}" \
-                          "(&:#{method_name})"
+            block_range =
+              Parser::Source::Range.new(node.loc.expression.source_buffer,
+                                        node.loc.begin.begin_pos,
+                                        node.loc.end.end_pos)
 
-            corrector.replace(node.loc.expression, replacement)
+            corrector.replace(range_with_surrounding_space(block_range, :left),
+                              "(&:#{method_name})")
           end
         end
 

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

@@ -28,7 +28,8 @@ module RuboCop
 
         def autocorrect(node)
           @corrections << lambda do |corrector|
-            corrector.replace(node.loc.begin, '%w(')
+            src = node.loc.begin.source
+            corrector.replace(node.loc.begin, src.tr('W', 'w'))
           end
         end
       end