rubocop 0.35.1 → 0.36.0

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,177 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'pp'
+
+module RuboCop
+  module Cop
+    # Common functionality for checking multiline method calls and binary
+    # operations.
+    module MultilineExpressionIndentation
+      def on_send(node)
+        return unless relevant_node?(node)
+
+        receiver, method_name, *_args = *node
+        return unless receiver
+        return if method_name == :[] # Don't check parameters inside [].
+
+        lhs = left_hand_side(receiver)
+        rhs = right_hand_side(node)
+        range = offending_range(node, lhs, rhs, style)
+        check(range, node, lhs, rhs)
+      end
+
+      # In a chain of method calls, we regard the top send node as the base
+      # for indentation of all lines following the first. For example:
+      # a.
+      #   b c { block }.            <-- b is indented relative to a
+      #   d                         <-- d is indented relative to a
+      def left_hand_side(lhs)
+        lhs = lhs.parent while lhs.parent && lhs.parent.send_type?
+        lhs
+      end
+
+      def right_hand_side(send_node)
+        _, method_name, *args = *send_node
+        if operator?(method_name) && args.any?
+          args.first.source_range # not used for method calls
+        else
+          dot = send_node.loc.dot
+          selector = send_node.loc.selector
+          if dot && selector && dot.line == selector.line
+            dot.join(selector)
+          elsif selector
+            selector
+          elsif dot.line == send_node.loc.begin.line
+            # lambda.(args)
+            dot.join(send_node.loc.begin)
+          end
+        end
+      end
+
+      def correct_indentation(node)
+        if kw_node_with_special_indentation(node)
+          # This cop could have its own IndentationWidth configuration
+          configured_indentation_width +
+            @config.for_cop('Style/IndentationWidth')['Width']
+        else
+          configured_indentation_width
+        end
+      end
+
+      def check(range, node, lhs, rhs)
+        if range
+          incorrect_style_detected(range, node, lhs, rhs)
+        else
+          correct_style_detected
+        end
+      end
+
+      def incorrect_style_detected(range, node, lhs, rhs)
+        add_offense(range, range, message(node, lhs, rhs)) do
+          if offending_range(node, lhs, rhs, alternative_style)
+            unrecognized_style_detected
+          else
+            opposite_style_detected
+          end
+        end
+      end
+
+      def indentation(node)
+        node.source_range.source_line =~ /\S/
+      end
+
+      def operation_description(node, rhs)
+        ancestor = kw_node_with_special_indentation(node)
+        if ancestor
+          kw = ancestor.loc.keyword.source
+          kind = kw == 'for' ? 'collection' : 'condition'
+          article = kw =~ /^[iu]/ ? 'an' : 'a'
+          "a #{kind} in #{article} `#{kw}` statement"
+        else
+          'an expression' +
+            (part_of_assignment_rhs(node, rhs) ? ' in an assignment' : '')
+        end
+      end
+
+      def kw_node_with_special_indentation(node)
+        node.each_ancestor.find do |a|
+          next unless a.loc.respond_to?(:keyword)
+
+          case a.type
+          when :if, :while, :until then expression, = *a
+          when :for                then _, expression, = *a
+          when :return             then expression, = *a
+          end
+
+          within_node?(node, expression) if expression
+        end
+      end
+
+      def argument_in_method_call(node)
+        node.each_ancestor(:send).find do |a|
+          _, method_name, *args = *a
+          next if assignment_call?(method_name)
+          args.any? { |arg| within_node?(node, arg) }
+        end
+      end
+
+      def part_of_assignment_rhs(node, candidate)
+        node.each_ancestor.find do |a|
+          case a.type
+          when :if, :while, :until, :for, :return, :array
+            break # other kinds of alignment
+          when :block
+            break if part_of_block_body?(candidate, a)
+          when :send
+            _receiver, method_name, *args = *a
+
+            # The []= operator and setters (a.b = c) are parsed as :send nodes.
+            assignment_call?(method_name) &&
+              (!candidate || within_node?(candidate, args.last))
+          when *Util::ASGN_NODES
+            !candidate || within_node?(candidate, assignment_rhs(a))
+          end
+        end
+      end
+
+      def assignment_call?(method_name)
+        method_name == :[]= || method_name.to_s =~ /^\w.*=$/
+      end
+
+      def part_of_block_body?(candidate, node)
+        _method, _args, body = *node
+        body && within_node?(candidate, body)
+      end
+
+      def assignment_rhs(node)
+        case node.type
+        when :casgn   then _scope, _lhs, rhs = *node
+        when :op_asgn then _lhs, _op, rhs = *node
+        when :send    then _receiver, _method_name, *_args, rhs = *node
+        else               _lhs, rhs = *node
+        end
+        rhs
+      end
+
+      def not_for_this_cop?(node)
+        node.each_ancestor.any? do |ancestor|
+          grouped_expression?(ancestor) ||
+            inside_arg_list_parentheses?(node, ancestor)
+        end
+      end
+
+      def grouped_expression?(node)
+        node.type == :begin && node.loc.respond_to?(:begin) && node.loc.begin
+      end
+
+      def inside_arg_list_parentheses?(node, ancestor)
+        a = ancestor.loc
+        return false unless ancestor.type == :send && a.begin &&
+                            a.begin.is?('(')
+        n = node.source_range
+        n.begin_pos > a.begin.begin_pos && n.end_pos < a.end.end_pos
+      end
+    end
+  end
+end

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

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

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -19,11 +20,11 @@ module RuboCop
       # Returns true for constructs such as
       # private def my_method
       # which are allowed in Ruby 2.1 and later.
-      def modifier_and_def_on_same_line?(receiver, method_name, args)
-        !receiver &&
-          method_name != :def &&
-          args.size == 1 &&
-          [:def, :defs].include?(args.first.type)
+      def modifier_and_def_on_same_line?(send_node)
+        send_node.receiver.nil? &&
+          send_node.method_name != :def &&
+          send_node.method_args.size == 1 &&
+          [:def, :defs].include?(send_node.method_args.first.type)
       end
     end
   end

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

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

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

@@ -0,0 +1,22 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for handling parentheses.
+    module Parentheses
+      def parens_required?(node)
+        source_buffer = node.source_range.source_buffer
+        source_buffer.source[node.source_range.begin_pos - 1] =~ /[a-z]/ ||
+          source_buffer.source[node.source_range.end_pos] =~ /[a-z]/
+      end
+
+      def autocorrect(node)
+        lambda do |corrector|
+          corrector.remove(node.loc.begin)
+          corrector.remove(node.loc.end)
+        end
+      end
+    end
+  end
+end

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

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

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

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

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

@@ -0,0 +1,79 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Common functionality for checking whether an AST node/token is aligned
+    # with something on a preceding or following line
+    module PrecedingFollowingAlignment
+      def allow_for_alignment?
+        cop_config['AllowForAlignment']
+      end
+
+      def aligned_with_something?(range)
+        aligned_with_adjacent_line?(range, method(:aligned_token?))
+      end
+
+      def aligned_with_operator?(range)
+        aligned_with_adjacent_line?(range, method(:aligned_operator?))
+      end
+
+      def aligned_with_adjacent_line?(range, predicate)
+        # minus 2 because node.loc.line is zero-based
+        pre  = (range.line - 2).downto(0)
+        post = range.line.upto(processed_source.lines.size - 1)
+        return true if aligned_with_line?(pre, range, &predicate) ||
+                       aligned_with_line?(post, range, &predicate)
+
+        # 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[range.line - 1] =~ /\S/
+        aligned_with_line?(pre, range, base_indentation, &predicate) ||
+          aligned_with_line?(post, range, base_indentation, &predicate)
+      end
+
+      def aligned_with_line?(line_nos, range, indent = nil)
+        line_nos.each do |lineno|
+          next if comment_lines.include?(lineno + 1)
+          line = processed_source.lines[lineno]
+          next if line =~ /\A\s*\Z/
+          next if indent && indent != (line =~ /\S/)
+          return yield(range, line)
+        end
+        false
+      end
+
+      def comment_lines
+        @comment_lines ||= processed_source.comments.map(&:loc).select do |r|
+          begins_its_line?(r.expression)
+        end.map(&:line)
+      end
+
+      def aligned_token?(range, line)
+        aligned_words?(range, line) ||
+          aligned_char?(range, line) ||
+          aligned_assignment?(range, line)
+      end
+
+      def aligned_operator?(range, line)
+        (aligned_identical?(range, line) || aligned_assignment?(range, line))
+      end
+
+      def aligned_words?(range, line)
+        line[range.column - 1, 2] =~ /\s\S/
+      end
+
+      def aligned_char?(range, line)
+        line[range.column] == range.source[0]
+      end
+
+      def aligned_assignment?(range, line)
+        range.source[-1] == '=' && line[range.last_column - 1] == '='
+      end
+
+      def aligned_identical?(range, line)
+        range.source == line[range.column, range.size]
+      end
+    end
+  end
+end

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

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

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

@@ -1,11 +1,12 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     # Common functionality for cops checking for missing space after
     # punctuation.
     module SpaceAfterPunctuation
-      MSG = 'Space missing after %s.'
+      MSG = 'Space missing after %s.'.freeze
 
       def investigate(processed_source)
         processed_source.tokens.each_cons(2) do |t1, t2|

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

@@ -1,11 +1,12 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     # Common functionality for cops checking for space before
     # punctuation.
     module SpaceBeforePunctuation
-      MSG = 'Space found before %s.'
+      MSG = 'Space found before %s.'.freeze
 
       def investigate(processed_source)
         processed_source.tokens.each_cons(2) do |t1, t2|

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -6,7 +7,7 @@ module RuboCop
     # kinds of brackets.
     module SpaceInside
       include SurroundingSpace
-      MSG = 'Space inside %s detected.'
+      MSG = 'Space inside %s detected.'.freeze
 
       def investigate(processed_source)
         @processed_source = processed_source

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -21,7 +22,7 @@ module RuboCop
 
         indentation = node.loc.keyword.column
         kw_length = node.loc.keyword.size
-        cond_length = cond.loc.expression.size
+        cond_length = cond.source_range.size
         space = 1
         total = indentation + body_length + space + kw_length + space +
                 cond_length
@@ -35,19 +36,19 @@ module RuboCop
       end
 
       def length(node)
-        node.loc.expression.source.lines.grep(/\S/).size
+        node.source.lines.grep(/\S/).size
       end
 
       def body_length(body)
-        if body && body.loc.expression
-          body.loc.expression.size
+        if body && body.source_range
+          body.source_range.size
         else
           0
         end
       end
 
       def body_has_comment?(body)
-        comment_lines.include?(body.loc.expression.line)
+        comment_lines.include?(body.source_range.line)
       end
 
       def end_keyword_has_comment?(node)