rubocop 0.31.0 → 0.35.0

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

@@ -6,24 +6,43 @@ module RuboCop
       # This cop checks whether method definitions are
       # separated by empty lines.
       class EmptyLineBetweenDefs < Cop
-        MSG = 'Use empty lines between defs.'
+        include OnMethodDef
+        MSG = 'Use empty lines between method definitions.'
 
-        def on_def(node)
-          if @prev_def_end && (def_start(node) - @prev_def_end) == 1
-            unless @prev_was_single_line && singe_line_def?(node) &&
-                   cop_config['AllowAdjacentOneLineDefs']
-              add_offense(node, :keyword)
-            end
-          end
+        def on_method_def(node, _method_name, _args, _body)
+          return unless node.parent && node.parent.begin_type?
 
-          @prev_def_end = def_end(node)
-          @prev_was_single_line = singe_line_def?(node)
+          nodes = [prev_node(node), node]
+
+          return unless nodes.all?(&method(:def_node?))
+          return if blank_lines_between?(*nodes)
+          return if nodes.all?(&:single_line?) &&
+                    cop_config['AllowAdjacentOneLineDefs']
+
+          add_offense(node, :keyword)
         end
 
         private
 
-        def singe_line_def?(node)
-          def_start(node) == def_end(node)
+        def def_node?(node)
+          return unless node
+          node.def_type? || node.defs_type?
+        end
+
+        def blank_lines_between?(first_def_node, second_def_node)
+          lines_between_defs(first_def_node, second_def_node).any?(&:blank?)
+        end
+
+        def prev_node(node)
+          return nil unless node.sibling_index > 0
+
+          node.parent.children[node.sibling_index - 1]
+        end
+
+        def lines_between_defs(first_def_node, second_def_node)
+          line_range = def_end(first_def_node)..(def_start(second_def_node) - 2)
+
+          processed_source.lines[line_range]
         end
 
         def def_start(node)
@@ -35,8 +54,14 @@ module RuboCop
         end
 
         def autocorrect(node)
-          range = range_with_surrounding_space(node.loc.expression, :left)
-          ->(corrector) { corrector.insert_before(range, "\n") }
+          prev_def = prev_node(node)
+          end_pos = prev_def.loc.end.end_pos
+          source_buffer = prev_def.loc.end.source_buffer
+          newline_pos = source_buffer.source.index("\n", end_pos)
+          newline = Parser::Source::Range.new(source_buffer,
+                                              newline_pos,
+                                              newline_pos + 1)
+          ->(corrector) { corrector.insert_after(newline, "\n") }
         end
       end
     end

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

@@ -16,7 +16,9 @@ module RuboCop
 
         MSG_MISSING = 'Missing utf-8 encoding comment.'
         MSG_UNNECESSARY = 'Unnecessary utf-8 encoding comment.'
-        ENCODING_PATTERN = /#.*coding\s?[:=]\s?(?:UTF|utf)-8/
+        ENCODING_PATTERN = /#.*coding\s?[:=]\s?(?:UTF|utf)-8/.freeze
+        AUTO_CORRECT_ENCODING_COMMENT = 'AutoCorrectEncodingComment'.freeze
+        SHEBANG = '#!'.freeze
 
         def investigate(processed_source)
           return if processed_source.buffer.source.empty?
@@ -31,10 +33,14 @@ module RuboCop
         end
 
         def autocorrect(node)
-          encoding = cop_config['AutoCorrectEncodingComment']
+          encoding = cop_config[AUTO_CORRECT_ENCODING_COMMENT]
           if encoding && encoding =~ ENCODING_PATTERN
             lambda do |corrector|
-              corrector.replace(node.pos, "#{encoding}\n#{node.pos.source}")
+              if encoding_line_number(processed_source) == 0
+                corrector.insert_before(node.pos, "#{encoding}\n")
+              else
+                corrector.insert_after(node.pos, "\n#{encoding}")
+              end
             end
           else
             fail "#{encoding} does not match #{ENCODING_PATTERN}"
@@ -58,7 +64,7 @@ module RuboCop
 
         def encoding_line_number(processed_source)
           line_number = 0
-          line_number += 1 if processed_source[line_number].start_with?('#!')
+          line_number += 1 if processed_source[line_number].start_with?(SHEBANG)
           line_number
         end
       end

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

@@ -7,19 +7,36 @@ module RuboCop
       #
       # @example
       #
-      #   name     = "RuboCop"
+      #   # good if AllowForAlignment is true
+      #   name      = "RuboCop"
+      #   # Some comment and an empty line
+      #
+      #   website  += "/bbatsov/rubocop" unless cond
+      #   puts        "rubocop"          if     debug
+      #
+      #   # bad for any configuration
+      #   set_app("RuboCop")
       #   website  = "https://github.com/bbatsov/rubocop"
       class ExtraSpacing < Cop
         MSG = 'Unnecessary spacing detected.'
 
         def investigate(processed_source)
+          ast = processed_source.ast
+
           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
+            next if t2.type == :tNL
+            next if t1.pos.line != t2.pos.line
+            next if t2.pos.begin_pos - 1 <= t1.pos.end_pos
+            next if allow_for_alignment? && aligned_with_something?(t2)
             start_pos = t1.pos.end_pos
+            next if ignored_ranges(ast).find { |r| r.include?(start_pos) }
+
             end_pos = t2.pos.begin_pos - 1
-            range = Parser::Source::Range.new(buffer, start_pos, end_pos)
+            range = Parser::Source::Range.new(processed_source.buffer,
+                                              start_pos, end_pos)
+            # Unary + doesn't appear as a token and needs special handling.
+            next if unary_plus_non_offense?(range)
+
             add_offense(range, range, MSG)
           end
         end
@@ -27,6 +44,110 @@ module RuboCop
         def autocorrect(range)
           ->(corrector) { corrector.remove(range) }
         end
+
+        private
+
+        def unary_plus_non_offense?(range)
+          range.resize(range.size + 1).source =~ /^ ?\+$/
+        end
+
+        # Returns an array of ranges that should not be reported. It's the
+        # extra spaces between the keys and values in a hash, since those are
+        # handled by the Style/AlignHash cop.
+        def ignored_ranges(ast)
+          return [] unless ast
+
+          @ignored_ranges ||= begin
+            ranges = []
+            on_node(:pair, ast) do |pair|
+              key, value = *pair
+              r = key.loc.expression.end_pos...value.loc.expression.begin_pos
+              ranges << r
+            end
+            ranges
+          end
+        end
+
+        def allow_for_alignment?
+          cop_config['AllowForAlignment']
+        end
+
+        def aligned_with_something?(token)
+          return aligned_comments?(token) if token.type == :tCOMMENT
+
+          pre = (token.pos.line - 2).downto(0)
+          post = token.pos.line.upto(processed_source.lines.size - 1)
+          return true if aligned_with?(pre, token) || aligned_with?(post, token)
+
+          # If no aligned token was found, search for an aligned token on the
+          # nearest line with the same indentation as the checked line.
+          base_indentation = processed_source.lines[token.pos.line - 1] =~ /\S/
+          aligned_with?(pre, token, base_indentation) ||
+            aligned_with?(post, token, base_indentation)
+        end
+
+        def aligned_comments?(token)
+          ix = processed_source.comments.index do |c|
+            c.loc.expression.begin_pos == token.pos.begin_pos
+          end
+          aligned_with_previous_comment?(ix) || aligned_with_next_comment?(ix)
+        end
+
+        def aligned_with_previous_comment?(ix)
+          ix > 0 && comment_column(ix - 1) == comment_column(ix)
+        end
+
+        def aligned_with_next_comment?(ix)
+          ix < processed_source.comments.length - 1 &&
+            comment_column(ix + 1) == comment_column(ix)
+        end
+
+        def comment_column(ix)
+          processed_source.comments[ix].loc.column
+        end
+
+        # Returns true if the previous or next line, not counting empty or
+        # comment lines, contains a token that's aligned with the given
+        # token. If base_indentation is given, lines with different indentation
+        # than the base indentation are also skipped.
+        def aligned_with?(indices_to_check, token, base_indentation = nil)
+          indices_to_check.each do |ix|
+            next if comment_lines.include?(ix + 1)
+            line = processed_source.lines[ix]
+            next if line.strip.empty?
+            if base_indentation
+              indentation = line =~ /\S/
+              next if indentation != base_indentation
+            end
+            return (aligned_words?(token, line) ||
+                    aligned_assignments?(token, line) ||
+                    aligned_same_character?(token, line))
+          end
+          false # No line to check was found.
+        end
+
+        def comment_lines
+          @comment_lines ||=
+            begin
+              whole_line_comments = processed_source.comments.select do |c|
+                begins_its_line?(c.loc.expression)
+              end
+              whole_line_comments.map { |c| c.loc.line }
+            end
+        end
+
+        def aligned_words?(token, line)
+          line[token.pos.column - 1, 2] =~ /\s\S/
+        end
+
+        def aligned_assignments?(token, line)
+          token.type == :tOP_ASGN &&
+            line[token.pos.column + token.text.length] == '='
+        end
+
+        def aligned_same_character?(token, line)
+          line[token.pos.column] == token.text.to_s[0]
+        end
       end
     end
   end

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

@@ -0,0 +1,41 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for a line break before the first element in a
+      # multi-line array.
+      #
+      # @example
+      #
+      #     # bad
+      #     [ :a,
+      #       :b]
+      #
+      #     # good
+      #     [
+      #       :a,
+      #       :b]
+      #
+      class FirstArrayElementLineBreak < Cop
+        include FirstElementLineBreak
+
+        MSG = 'Add a line break before the first element of a ' \
+              'multi-line array.'
+
+        def on_array(node)
+          return if !node.loc.begin && !assignment_on_same_line?(node)
+
+          check_children_line_break(node, node.children)
+        end
+
+        private
+
+        def assignment_on_same_line?(node)
+          source = node.loc.expression.source_line[0...node.loc.column]
+          source =~ /\s*\=\s*$/
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for a line break before the first element in a
+      # multi-line hash.
+      #
+      # @example
+      #
+      #     # bad
+      #     { a: 1,
+      #       b: 2}
+      #
+      #     # good
+      #     {
+      #       a: 1,
+      #       b: 2 }
+      class FirstHashElementLineBreak < Cop
+        include FirstElementLineBreak
+
+        MSG = 'Add a line break before the first element of a ' \
+              'multi-line hash.'
+
+        def on_hash(node)
+          if node.loc.begin
+            check_children_line_break(node, node.children)
+          elsif method_uses_parens?(node.parent, node)
+            check_children_line_break(node, node.children, node.parent)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for a line break before the first argument in a
+      # multi-line method call.
+      #
+      # @example
+      #
+      #     # bad
+      #     method(foo, bar,
+      #       baz)
+      #
+      #     # good
+      #     method(
+      #       foo, bar,
+      #       baz)
+      #
+      #     # ignored
+      #     method foo, bar,
+      #       baz
+      class FirstMethodArgumentLineBreak < Cop
+        include FirstElementLineBreak
+
+        MSG = 'Add a line break before the first argument of a ' \
+              'multi-line method argument list.'
+
+        def on_send(node)
+          _receiver, _name, *args = *node
+
+          check_method_line_break(node, args)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for a line break before the first parameter in a
+      # multi-line method parameter definition.
+      #
+      # @example
+      #
+      #     # bad
+      #     def method(foo, bar,
+      #         baz)
+      #       do_something
+      #     end
+      #
+      #     # good
+      #     def method(
+      #         foo, bar,
+      #         baz)
+      #       do_something
+      #     end
+      #
+      #     # ignored
+      #     def method foo,
+      #         bar
+      #       do_something
+      #     end
+      class FirstMethodParameterLineBreak < Cop
+        include OnMethodDef
+        include FirstElementLineBreak
+
+        MSG = 'Add a line break before the first parameter of a ' \
+              'multi-line method parameter list.'
+
+        def on_method_def(node, _method_name, args, _body)
+          check_method_line_break(node, args.to_a)
+        end
+      end
+    end
+  end
+end

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

@@ -39,14 +39,16 @@ module RuboCop
         private
 
         def message(arg_node)
+          return 'Bad indentation of the first parameter.' if arg_node.nil?
+
           send_node = arg_node.parent
           text = base_range(send_node, arg_node).source.strip
           base = if text !~ /\n/ && special_inner_call_indentation?(send_node)
                    "`#{text}`"
                  elsif text.lines.reverse_each.first =~ /^\s*#/
-                   'the previous line (not counting the comment)'
+                   'the start of the previous line (not counting the comment)'
                  else
-                   'the previous line'
+                   'the start of the previous line'
                  end
           format('Indent the first parameter one step more than %s.', base)
         end
@@ -97,7 +99,7 @@ module RuboCop
             .map { |c| c.loc.line }
 
           line = ''
-          while line =~ /^\s*$/ || @comment_lines.include?(line_number)
+          while line.blank? || @comment_lines.include?(line_number)
             line_number -= 1
             line = processed_source.lines[line_number - 1]
           end

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

@@ -9,6 +9,7 @@ module RuboCop
       # allowed, however.
       class For < Cop
         include ConfigurableEnforcedStyle
+        EACH_LENGTH = 'each'.length
 
         def on_for(node)
           if style == :each
@@ -32,7 +33,7 @@ module RuboCop
           if style == :for
             end_pos = method.loc.expression.end_pos
             range = Parser::Source::Range.new(processed_source.buffer,
-                                              end_pos - 'each'.length,
+                                              end_pos - EACH_LENGTH,
                                               end_pos)
             add_offense(range, range, 'Prefer `for` over `each`.') do
               opposite_style_detected

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

@@ -101,6 +101,11 @@ module RuboCop
 
         def valid_19_syntax_symbol?(sym_name)
           sym_name.sub!(/\A:/, '')
+
+          # Most hash keys can be matched against a simple regex.
+          return true if sym_name =~ /\A[_a-z]\w*[?!]?\z/i
+
+          # For more complicated hash keys, let the Parser validate the syntax.
           RuboCop::ProcessedSource.new("{ #{sym_name}: :foo }").valid_syntax?
         end
 

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

@@ -9,6 +9,8 @@ module RuboCop
       class IfUnlessModifier < Cop
         include StatementModifier
 
+        ASSIGNMENT_TYPES = [:lvasgn, :casgn, :cvasgn, :gvasgn, :ivasgn, :masgn]
+
         def message(keyword)
           "Favor modifier `#{keyword}` usage when having a single-line body." \
           ' Another good alternative is the usage of control flow `&&`/`||`.'
@@ -20,17 +22,41 @@ module RuboCop
           return if modifier_if?(node)
           return if elsif?(node)
           return if if_else?(node)
+          return if chained?(node)
           return unless fit_within_line_as_modifier_form?(node)
           add_offense(node, :keyword, message(node.loc.keyword.source))
         end
 
-        def autocorrect(node)
-          if node.loc.keyword.is?('if')
-            cond, body = *node
-          else
-            cond, _else, body = *node
+        def chained?(node)
+          # Don't register offense for `if ... end.method`
+          return false if node.parent.nil? || !node.parent.send_type?
+          receiver = node.parent.children[0]
+          node.equal?(receiver)
+        end
+
+        def parenthesize?(node)
+          # Parenthesize corrected expression if changing to modifier-if form
+          # would change the meaning of the parent expression
+          # (due to the low operator precedence of modifier-if)
+          return false if node.parent.nil?
+          return true if ASSIGNMENT_TYPES.include?(node.parent.type)
+
+          if node.parent.send_type?
+            _receiver, _name, *args = *node.parent
+            return !method_uses_parens?(node.parent, args.first)
           end
 
+          false
+        end
+
+        def method_uses_parens?(node, limit)
+          source = node.loc.expression.source_line[0...limit.loc.column]
+          source =~ /\s*\(\s*$/
+        end
+
+        def autocorrect(node)
+          cond, body, _else = if_node_parts(node)
+
           oneline =
             "#{body.loc.expression.source} #{node.loc.keyword.source} " +
             cond.loc.expression.source
@@ -40,6 +66,7 @@ module RuboCop
           if first_line_comment
             oneline << ' ' << first_line_comment.loc.expression.source
           end
+          oneline = "(#{oneline})" if parenthesize?(node)
 
           ->(corrector) { corrector.replace(node.loc.expression, oneline) }
         end