lambda.rb in rubocop-0.36.0

- old
+ new

@@ -1,19 +1,22 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
       # This cop checks for uses of the pre 1.9 lambda syntax for one-line
       # anonymous functions and uses of the 1.9 lambda syntax for multi-line
       # anonymous functions.
       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)
 
         def on_block(node)
           # We're looking for
@@ -25,13 +28,13 @@
           return unless block_method == TARGET
           selector = block_method.loc.selector.source
           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
 
         private
 
@@ -52,11 +55,11 @@
 
         def correction(node)
           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)
             end
           end
@@ -67,25 +70,25 @@
           # Avoid correcting to `lambdado` by inserting whitespace
           # if none exists before or after the lambda arguments.
           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)
         end
 
         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
 
         def needs_whitespace?(block_method, args, node)
           selector_end = block_method.loc.selector.end.end_pos
@@ -95,10 +98,10 @@
           (block_begin == args_end && selector_end == args_begin) ||
             (block_begin == selector_end)
         end
 
         def lambda_arg_string(args)
-          args.children.map { |a| a.loc.expression.source }.join(', ')
+          args.children.map(&:source).join(', ')
         end
       end
     end
   end
 end