rubocop 0.35.1 → 0.36.0

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -71,10 +72,10 @@ module RuboCop
           special = %w(protected private) # Extra indentation step after these.
           previous_modifier = nil
           members.first.children.each do |m|
-            if modifier_node?(m) && special.include?(m.loc.expression.source)
+            if modifier_node?(m) && special.include?(m.source)
               previous_modifier = m
             elsif previous_modifier
-              check_indentation(previous_modifier.loc.expression, m, style)
+              check_indentation(previous_modifier.source_range, m, style)
               previous_modifier = nil
             end
           end
@@ -82,9 +83,8 @@ module RuboCop
 
         def on_send(node)
           super
-          receiver, method_name, *args = *node
-          return unless modifier_and_def_on_same_line?(receiver, method_name,
-                                                       args)
+          return unless modifier_and_def_on_same_line?(node)
+          _, _, *args = *node
 
           *_, body = *args.first
 
@@ -96,7 +96,7 @@ module RuboCop
                   end
           base = style == 'def' ? args.first : node
 
-          check_indentation(base.loc.expression, body)
+          check_indentation(base.source_range, body)
           ignore_node(args.first)
         end
 
@@ -114,12 +114,12 @@ module RuboCop
 
           _condition, body = *node
           return unless node.loc.keyword.begin_pos ==
-                        node.loc.expression.begin_pos
+                        node.source_range.begin_pos
 
           check_indentation(base.loc, body)
         end
 
-        alias_method :on_until, :on_while
+        alias on_until on_while
 
         def on_case(node)
           _condition, *branches = *node
@@ -234,7 +234,7 @@ module RuboCop
         # Returns true if the given node is within another node that has
         # already been marked for auto-correction by this cop.
         def other_offense_in_same_range?(node)
-          expr = node.loc.expression
+          expr = node.source_range
           @offense_ranges ||= []
 
           return true if @offense_ranges.any? { |r| within?(expr, r) }
@@ -253,7 +253,7 @@ module RuboCop
 
           # Don't check indentation if the line doesn't start with the body.
           # For example, lines like "else do_something".
-          first_char_pos_on_line = body_node.loc.expression.source_line =~ /\S/
+          first_char_pos_on_line = body_node.source_range.source_line =~ /\S/
           return false unless body_node.loc.column == first_char_pos_on_line
 
           if [:rescue, :ensure].include?(body_node.type)
@@ -265,7 +265,7 @@ module RuboCop
         end
 
         def offending_range(body_node, indentation)
-          expr = body_node.loc.expression
+          expr = body_node.source_range
           begin_pos = expr.begin_pos
           ind = expr.begin_pos - indentation
           pos = indentation >= 0 ? ind..begin_pos : begin_pos..ind

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -16,17 +17,12 @@ module RuboCop
       #     work
       #   end
       class InfiniteLoop < Cop
-        MSG = 'Use `Kernel#loop` for infinite loops.'
-
-        TRUTHY_LITERALS = [:str, :dstr, :int, :float, :array,
-                           :hash, :regexp, :true]
-
-        FALSEY_LITERALS = [:nil, :false]
+        MSG = 'Use `Kernel#loop` for infinite loops.'.freeze
 
         def on_while(node)
           condition, = *node
 
-          return unless TRUTHY_LITERALS.include?(condition.type)
+          return unless condition.truthy_literal?
 
           add_offense(node, :keyword)
         end
@@ -34,7 +30,7 @@ module RuboCop
         def on_until(node)
           condition, = *node
 
-          return unless FALSEY_LITERALS.include?(condition.type)
+          return unless condition.falsey_literal?
 
           add_offense(node, :keyword)
         end
@@ -45,7 +41,7 @@ module RuboCop
           end_range = if node.loc.begin
                         node.loc.begin.end
                       else
-                        condition_node.loc.expression.end
+                        condition_node.source_range.end
                       end
           lambda do |corrector|
             corrector.replace(start_range.join(end_range), 'loop do')

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -6,7 +7,7 @@ module RuboCop
       # This cops checks for indentation of the first non-blank non-comment
       # line in a file.
       class InitialIndentation < Cop
-        MSG = 'Indentation of first line in file detected.'
+        MSG = 'Indentation of first line in file detected.'.freeze
 
         def investigate(processed_source)
           first_token = processed_source.tokens.find do |t|

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

@@ -1,11 +1,12 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
       # This cop checks for inline comments.
       class InlineComment < Cop
-        MSG = 'Avoid inline comments.'
+        MSG = 'Avoid inline comments.'.freeze
 
         def investigate(processed_source)
           processed_source.comments.each do |comment|

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -9,9 +10,11 @@ module RuboCop
       class Lambda < Cop
         include AutocorrectUnlessChangingAST
 
-        SINGLE_MSG = 'Use the new lambda literal syntax `->(params) {...}`.'
-        SINGLE_NO_ARG_MSG = 'Use the new lambda literal syntax `-> {...}`.'
-        MULTI_MSG = 'Use the `lambda` method for multi-line lambdas.'
+        SINGLE_MSG = 'Use the new lambda literal syntax ' \
+                     '`->(params) {...}`.'.freeze
+        SINGLE_NO_ARG_MSG = 'Use the new lambda literal syntax ' \
+                            '`-> {...}`.'.freeze
+        MULTI_MSG = 'Use the `lambda` method for multi-line lambdas.'.freeze
 
         TARGET = s(:send, nil, :lambda)
 
@@ -27,9 +30,9 @@ module RuboCop
           length = lambda_length(node)
 
           if selector != '->' && length == 1
-            add_offense_for_single_line(node, block_method.loc.expression, args)
+            add_offense_for_single_line(node, block_method.source_range, args)
           elsif selector == '->' && length > 1
-            add_offense(node, block_method.loc.expression, MULTI_MSG)
+            add_offense(node, block_method.source_range, MULTI_MSG)
           end
         end
 
@@ -54,7 +57,7 @@ module RuboCop
           lambda do |corrector|
             block_method, _args = *node
 
-            if block_method.loc.expression.source == 'lambda'
+            if block_method.source == 'lambda'
               autocorrect_old_to_new(corrector, node)
             else
               autocorrect_new_to_old(corrector, node)
@@ -69,8 +72,8 @@ module RuboCop
           if needs_whitespace?(block_method, args, node)
             corrector.insert_before(node.loc.begin, ' ')
           end
-          corrector.replace(block_method.loc.expression, 'lambda')
-          corrector.remove(args.loc.expression) if args.loc.expression
+          corrector.replace(block_method.source_range, 'lambda')
+          corrector.remove(args.source_range) if args.source_range
           return if args.children.empty?
           arg_str = " |#{lambda_arg_string(args)}|"
           corrector.insert_after(node.loc.begin, arg_str)
@@ -78,12 +81,12 @@ module RuboCop
 
         def autocorrect_old_to_new(corrector, node)
           block_method, args = *node
-          corrector.replace(block_method.loc.expression, '->')
+          corrector.replace(block_method.source_range, '->')
           return if args.children.empty?
 
           arg_str = "(#{lambda_arg_string(args)})"
           whitespace_and_old_args = node.loc.begin.end.join(args.loc.end)
-          corrector.insert_after(block_method.loc.expression, arg_str)
+          corrector.insert_after(block_method.source_range, arg_str)
           corrector.remove(whitespace_and_old_args)
         end
 
@@ -97,7 +100,7 @@ module RuboCop
         end
 
         def lambda_arg_string(args)
-          args.children.map { |a| a.loc.expression.source }.join(', ')
+          args.children.map(&:source).join(', ')
         end
       end
     end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -40,10 +41,9 @@ module RuboCop
           lambda do |corrector|
             if style == :call
               receiver_node, = *node
-              expr = node.loc.expression
-              receiver = receiver_node.loc.expression.source
-              replacement = expr.source.sub("#{receiver}.", "#{receiver}.call")
-              corrector.replace(expr, replacement)
+              receiver = receiver_node.source
+              replacement = node.source.sub("#{receiver}.", "#{receiver}.call")
+              corrector.replace(node.source_range, replacement)
             else
               corrector.remove(node.loc.selector)
             end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -9,7 +10,7 @@ module RuboCop
       # like #++, #--, #:nodoc, etc. Neither is it required for
       # =begin/=end comments.
       class LeadingCommentSpace < Cop
-        MSG = 'Missing space after #.'
+        MSG = 'Missing space after #.'.freeze
 
         def investigate(processed_source)
           processed_source.comments.each do |comment|

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -20,7 +21,8 @@ module RuboCop
       #              'bala'
       #
       class LineEndConcatenation < Cop
-        MSG = 'Use `\\` instead of `+` or `<<` to concatenate those strings.'
+        MSG = 'Use `\\` instead of `+` or `<<` to concatenate ' \
+              'those strings.'.freeze
         CONCAT_TOKEN_TYPES = [:tPLUS, :tLSHFT].freeze
         SIMPLE_STRING_TOKEN_TYPE = :tSTRING
         COMPLEX_STRING_EDGE_TOKEN_TYPES = [:tSTRING_BEG, :tSTRING_END].freeze

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

@@ -1,11 +1,13 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
       # This cop checks for unwanted parentheses in parameterless method calls.
       class MethodCallParentheses < Cop
-        MSG = 'Do not use parentheses for method calls with no arguments.'
+        MSG = 'Do not use parentheses for method calls with ' \
+              'no arguments.'.freeze
 
         ASGN_NODES = [:lvasgn, :masgn] + Util::SHORTHAND_ASGN_NODES
 
@@ -16,6 +18,7 @@ module RuboCop
           return if method_name =~ /\A[A-Z]/
           return unless args.empty? && node.loc.begin
           return if same_name_assignment?(node)
+          return if lambda_call_syntax?(node)
 
           add_offense(node, :begin)
         end
@@ -49,6 +52,11 @@ module RuboCop
             asgn_node.loc.name.source == method_name.to_s
           end
         end
+
+        # don't check `lambda.()` syntax; the Style/LambdaCall cop does that
+        def lambda_call_syntax?(node)
+          node.method_name == :call && node.loc.selector.nil?
+        end
       end
     end
   end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -13,7 +14,7 @@ module RuboCop
       #     b
       #   end.c
       class MethodCalledOnDoEndBlock < Cop
-        MSG = 'Avoid chaining a method call on a do...end block.'
+        MSG = 'Avoid chaining a method call on a do...end block.'.freeze
 
         def on_block(node)
           method, _args, _body = *node
@@ -33,7 +34,7 @@ module RuboCop
 
           range = Parser::Source::Range.new(receiver.loc.end.source_buffer,
                                             receiver.loc.end.begin_pos,
-                                            node.loc.expression.end_pos)
+                                            node.source_range.end_pos)
           add_offense(nil, range)
         end
       end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -32,7 +33,7 @@ module RuboCop
               corrector.replace(node.loc.begin, ' ')
               corrector.remove(node.loc.end)
             else
-              args_expr = args_node(node).loc.expression
+              args_expr = args_node(node).source_range
               args_with_space = range_with_surrounding_space(args_expr, :left)
               just_space = Parser::Source::Range.new(args_expr.source_buffer,
                                                      args_with_space.begin_pos,
@@ -46,7 +47,7 @@ module RuboCop
         private
 
         def missing_parentheses(node, args)
-          add_offense(node, args.loc.expression,
+          add_offense(node, args.source_range,
                       'Use def with parentheses when there are parameters.') do
             unexpected_style_detected(:require_no_parentheses)
           end
@@ -61,11 +62,10 @@ module RuboCop
         def args_node(def_node)
           if def_node.type == :def
             _method_name, args, _body = *def_node
-            args
           else
             _scope, _method_name, args, _body = *def_node
-            args
           end
+          args
         end
 
         def arguments?(args)

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

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

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -32,9 +33,10 @@ module RuboCop
         include OnNormalIfUnless
         include ConfigurableEnforcedStyle
 
-        MSG = '`%s` condition requires an `else`-clause.'
-        MSG_NIL = '`%s` condition requires an `else`-clause with `nil` in it.'
-        MSG_EMPTY = '`%s` condition requires an empty `else`-clause.'
+        MSG = '`%s` condition requires an `else`-clause.'.freeze
+        MSG_NIL = '`%s` condition requires an `else`-clause with ' \
+                  '`nil` in it.'.freeze
+        MSG_EMPTY = '`%s` condition requires an empty `else`-clause.'.freeze
 
         def on_normal_if_unless(node)
           unless_else_cop = config.for_cop('Style/UnlessElse')

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -13,7 +14,7 @@ module RuboCop
       #     ...
       # end
       class ModuleFunction < Cop
-        MSG = 'Use `module_function` instead of `extend self`.'
+        MSG = 'Use `module_function` instead of `extend self`.'.freeze
 
         TARGET_NODE = s(:send, nil, :extend, s(:self))
 

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

@@ -0,0 +1,95 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks that the closing brace in an array literal is
+      # symmetrical with respect to the opening brace and the array
+      # elements.
+      #
+      # If an array's opening brace is on the same line as the first element
+      # of the array, then the closing brace should be on the same line as
+      # the last element of the array.
+      #
+      # If an array's opening brace is on a separate line from the first
+      # element of the array, then the closing brace should be on the line
+      # after the last element of the array.
+      #
+      # @example
+      #
+      #     # bad
+      #     [ :a,
+      #       :b
+      #     ]
+      #
+      #     # bad
+      #     [
+      #       :a,
+      #       :b ]
+      #
+      #     # good
+      #     [ :a,
+      #       :b ]
+      #
+      #     #good
+      #     [
+      #       :a,
+      #       :b
+      #     ]
+      class MultilineArrayBraceLayout < Cop
+        SAME_LINE_MESSAGE = 'Closing array brace must be on the same line as ' \
+          'the last array element when opening brace is on the same line as ' \
+          'the first array element.'.freeze
+
+        NEW_LINE_MESSAGE = 'Closing array brace must be on the line after ' \
+          'the last array element when opening brace is on a separate line ' \
+          'from the first array element.'.freeze
+
+        def on_array(node)
+          return unless node.loc.begin # Ignore implicit arrays.
+          return if node.children.empty? # Ignore empty arrays.
+
+          if opening_brace_on_same_line?(node)
+            return if closing_brace_on_same_line?(node)
+
+            add_offense(node, :expression, SAME_LINE_MESSAGE)
+          else
+            return unless closing_brace_on_same_line?(node)
+
+            add_offense(node, :expression, NEW_LINE_MESSAGE)
+          end
+        end
+
+        def autocorrect(node)
+          if closing_brace_on_same_line?(node)
+            lambda do |corrector|
+              corrector.insert_before(node.loc.end, "\n".freeze)
+            end
+          else
+            range = Parser::Source::Range.new(
+              node.source_range.source_buffer,
+              node.children.last.source_range.end_pos,
+              node.loc.end.begin_pos)
+
+            ->(corrector) { corrector.remove(range) }
+          end
+        end
+
+        private
+
+        # This method depends on the fact that we have guarded
+        # against implicit and empty arrays.
+        def opening_brace_on_same_line?(node)
+          node.loc.begin.line == node.children.first.loc.first_line
+        end
+
+        # This method depends on the fact that we have guarded
+        # against implicit and empty arrays.
+        def closing_brace_on_same_line?(node)
+          node.loc.end.line == node.children.last.loc.last_line
+        end
+      end
+    end
+  end
+end