rubocop 0.35.1 → 0.36.0

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -7,7 +8,7 @@ module RuboCop
       class SpaceAfterColon < Cop
         include IfNode
 
-        MSG = 'Space missing after colon.'
+        MSG = 'Space missing after colon.'.freeze
 
         def on_pair(node)
           oper = node.loc.operator

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

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

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

@@ -1,21 +1,21 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
       # Checks for various control keywords missing a space after them.
       class SpaceAfterControlKeyword < Cop
-        MSG = 'Use space after control keywords.'
+        MSG = 'Use space after control keywords.'.freeze
         # elsif and unless are handled by on_if.
-        KEYWORDS = %w(if case when while until)
+        KEYWORDS = %w(if case when while until).freeze
 
         def on_keyword(node)
           return if node.loc.is_a?(Parser::Source::Map::Ternary)
 
-          exp = node.loc.expression
           kw = node.loc.keyword
-          kw_offset = kw.begin_pos - exp.begin_pos
-          return unless exp.source[kw_offset..-1].start_with?(kw.source + '(')
+          kw_offset = kw.begin_pos - node.source_range.begin_pos
+          return unless node.source[kw_offset..-1].start_with?(kw.source + '(')
 
           add_offense(node, kw)
         end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -16,11 +17,11 @@ module RuboCop
         include OnMethodDef
 
         MSG = 'Do not put a space between a method name and the opening ' \
-              'parenthesis.'
+              'parenthesis.'.freeze
 
         def on_method_def(_node, _method_name, args, _body)
           return unless args.loc.begin && args.loc.begin.is?('(')
-          expr = args.loc.expression
+          expr = args.source_range
           pos_before_left_paren = Parser::Source::Range.new(expr.source_buffer,
                                                             expr.begin_pos - 1,
                                                             expr.begin_pos)

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -12,13 +13,13 @@ module RuboCop
       #   # good
       #   !something
       class SpaceAfterNot < Cop
-        MSG = 'Do not leave space between `!` and its argument.'
+        MSG = 'Do not leave space between `!` and its argument.'.freeze
 
         def on_send(node)
           _receiver, method_name, *_args = *node
 
           return unless method_name == :!
-          return unless node.loc.expression.source =~ /^!\s+\w+/
+          return unless node.source =~ /^!\s+\w+/
 
           # TODO: Improve source range to highlight the redundant whitespace.
           add_offense(node, :selector)
@@ -30,7 +31,7 @@ module RuboCop
             space_range =
               Parser::Source::Range.new(node.loc.selector.source_buffer,
                                         node.loc.selector.end_pos,
-                                        receiver.loc.expression.begin_pos)
+                                        receiver.source_range.begin_pos)
             corrector.remove(space_range)
           end
         end

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

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

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -24,7 +25,7 @@ module RuboCop
           check_inside_pipes(args.children, opening_pipe, closing_pipe)
 
           if body
-            check_space(closing_pipe.end_pos, body.loc.expression.begin_pos,
+            check_space(closing_pipe.end_pos, body.source_range.begin_pos,
                         closing_pipe, 'after closing `|`')
           end
 
@@ -46,8 +47,8 @@ module RuboCop
         end
 
         def check_no_space_style_inside_pipes(args, opening_pipe, closing_pipe)
-          first = args.first.loc.expression
-          last = args.last.loc.expression
+          first = args.first.source_range
+          last = args.last.source_range
 
           check_no_space(opening_pipe.end_pos, first.begin_pos,
                          'Space before first')
@@ -56,8 +57,8 @@ module RuboCop
         end
 
         def check_space_style_inside_pipes(args, opening_pipe, closing_pipe)
-          first = args.first.loc.expression
-          last = args.last.loc.expression
+          first = args.first.source_range
+          last = args.last.source_range
           last_end_pos = last_end_pos_inside_pipes(last.end_pos)
 
           check_space(opening_pipe.end_pos, first.begin_pos, first,
@@ -75,8 +76,8 @@ module RuboCop
         end
 
         def check_each_arg(args)
-          args.children[1..-1].each do |arg|
-            expr = arg.loc.expression
+          args.children.butfirst.each do |arg|
+            expr = arg.source_range
             check_no_space(range_with_surrounding_space(expr, :left).begin_pos,
                            expr.begin_pos - 1, 'Extra space before')
           end

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

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

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -6,34 +7,72 @@ module RuboCop
       # Checks that operators have space around them, except for **
       # which should not have surrounding space.
       class SpaceAroundOperators < Cop
-        TYPES = %w(and or class) + ASGN_NODES
-
-        TYPES.each { |t| define_method(:"on_#{t}") { |node| check(node) } }
+        include PrecedingFollowingAlignment
+        include HashNode # any_pairs_on_the_same_line?
 
         def on_pair(node)
-          check(node) if node.loc.operator.is?('=>')
+          return unless node.loc.operator.is?('=>')
+
+          align_hash_config = config.for_cop('Style/AlignHash')
+          return if align_hash_config['EnforcedHashRocketStyle'] == 'table' &&
+                    !any_pairs_on_the_same_line?(node.parent)
+
+          _, right = *node
+          check_operator(node.loc.operator, right.source_range)
         end
 
         def on_if(node)
           return unless node.loc.respond_to?(:question)
+          _, if_branch, else_branch = *node
 
-          check_operator(node.loc.question)
-          check_operator(node.loc.colon)
+          check_operator(node.loc.question, if_branch.source_range)
+          check_operator(node.loc.colon, else_branch.source_range)
         end
 
         def on_resbody(node)
-          check_operator(node.loc.assoc) if node.loc.assoc
+          if node.loc.assoc
+            _, variable, = *node
+            check_operator(node.loc.assoc, variable.source_range)
+          end
         end
 
         def on_send(node)
-          if node.loc.operator
-            check(node)
+          if node.loc.operator # aref assignment, attribute assignment
+            on_special_asgn(node)
           elsif !unary_operation?(node) && !called_with_dot?(node)
             op = node.loc.selector
-            check_operator(op) if operator?(op)
+            if operator?(op)
+              _, _, right, = *node
+              check_operator(node.loc.selector, right.source_range)
+            end
           end
         end
 
+        def on_binary(node)
+          _, right, = *node
+          return if right.nil?
+          check_operator(node.loc.operator, right.source_range)
+        end
+
+        def on_special_asgn(node)
+          return unless node.loc.operator
+          _, _, right, = *node
+          check_operator(node.loc.operator, right.source_range)
+        end
+
+        alias on_or       on_binary
+        alias on_and      on_binary
+        alias on_lvasgn   on_binary
+        alias on_masgn    on_binary
+        alias on_casgn    on_special_asgn
+        alias on_ivasgn   on_binary
+        alias on_cvasgn   on_binary
+        alias on_gvasgn   on_binary
+        alias on_class    on_binary
+        alias on_or_asgn  on_binary
+        alias on_and_asgn on_binary
+        alias on_op_asgn  on_special_asgn
+
         private
 
         def operator?(range)
@@ -41,21 +80,16 @@ module RuboCop
         end
 
         def unary_operation?(node)
-          whole = node.loc.expression
-          selector = node.loc.selector
-          return unless selector
-          operator?(selector) && whole.begin_pos == selector.begin_pos
+          return unless (selector = node.loc.selector)
+          operator?(selector) &&
+            node.source_range.begin_pos == selector.begin_pos
         end
 
         def called_with_dot?(node)
           node.loc.dot
         end
 
-        def check(node)
-          check_operator(node.loc.operator) if node.loc.operator
-        end
-
-        def check_operator(op)
+        def check_operator(op, right_operand)
           with_space = range_with_surrounding_space(op)
           return if with_space.source.start_with?("\n")
 
@@ -65,27 +99,33 @@ module RuboCop
                           'Space around operator `**` detected.')
             end
           elsif with_space.source !~ /^\s.*\s$/
-            add_offense(with_space, op,
-                        'Surrounding space missing for operator' \
-                        " `#{op.source}`.")
-          elsif with_space.source =~ /(^  |  $)/ && !multi_space_operator?(op)
-            add_offense(with_space, op,
-                        "Operator `#{op.source}` should be surrounded" \
-                        ' with a single space.')
+            add_offense(with_space, op, 'Surrounding space missing for ' \
+                                        "operator `#{op.source}`.")
+          elsif excess_leading_space?(op, with_space)
+            add_offense(with_space, op, "Operator `#{op.source}` should be " \
+                                        'surrounded by a single space.')
+          elsif excess_trailing_space?(right_operand, with_space)
+            add_offense(with_space, op, "Operator `#{op.source}` should be " \
+                                        'surrounded by a single space.')
           end
         end
 
-        def multi_space_operator?(op)
-          cop_config['MultiSpaceAllowedForOperators'].any? do |multi_space_op|
-            op.is?(multi_space_op)
-          end
+        def excess_leading_space?(op, with_space)
+          with_space.source =~ /^  / &&
+            (!allow_for_alignment? || !aligned_with_operator?(op))
+        end
+
+        def excess_trailing_space?(right_operand, with_space)
+          with_space.source =~ /  $/ &&
+            (!allow_for_alignment? || !aligned_with_something?(right_operand))
         end
 
         def autocorrect(range)
           lambda do |corrector|
-            case range.source
-            when /\*\*/
+            if range.source =~ /\*\*/
               corrector.replace(range, '**')
+            elsif range.source.end_with?("\n")
+              corrector.replace(range, " #{range.source.strip}\n")
             else
               corrector.replace(range, " #{range.source.strip} ")
             end

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -16,7 +17,7 @@ module RuboCop
           # auto-correct, so reporting space issues is not useful, and it
           # creates auto-correct conflicts.
           if config.for_cop('Style/BlockDelimiters')['Enabled'] &&
-             Util.block_length(node) > 0
+             block_length(node) > 0
             return
           end
 

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

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

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -6,7 +7,7 @@ module RuboCop
       # This cop checks for missing space between a token and a comment on the
       # same line.
       class SpaceBeforeComment < Cop
-        MSG = 'Put a space before an end-of-line comment.'
+        MSG = 'Put a space before an end-of-line comment.'.freeze
 
         def investigate(processed_source)
           processed_source.tokens.each_cons(2) do |t1, t2|

data/lib/rubocop/cop/style/{single_space_before_first_arg.rb → space_before_first_arg.rb}

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -6,13 +7,20 @@ module RuboCop
       # Checks that exactly one space is used between a method name and the
       # first argument for method calls without parentheses.
       #
-      # @example
+      # Alternatively, extra spaces can be added to align the argument with
+      # something on a preceding or following line, if the AllowForAlignment
+      # config parameter is true.
       #
+      # @example
+      #   @bad
       #   something  x
       #   something   y, z
       #
-      class SingleSpaceBeforeFirstArg < Cop
-        MSG = 'Put one space between the method name and the first argument.'
+      class SpaceBeforeFirstArg < Cop
+        include PrecedingFollowingAlignment
+
+        MSG = 'Put one space between the method name and ' \
+              'the first argument.'.freeze
 
         def on_send(node)
           return if parentheses?(node)
@@ -22,8 +30,9 @@ module RuboCop
           return if operator?(method_name)
           return if node.asgn_method_call?
 
-          arg1 = args.first.loc.expression
+          arg1 = args.first.source_range
           return if arg1.line > node.loc.line
+          return if allow_for_alignment? && aligned_with_something?(arg1)
 
           arg1_with_space = range_with_surrounding_space(arg1, :left)
           space = Parser::Source::Range.new(arg1.source_buffer,

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

@@ -1,11 +1,12 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
     module Style
       # Here we check if modifier keywords are preceded by a space.
       class SpaceBeforeModifierKeyword < Cop
-        MSG = 'Put a space before the modifier keyword.'
+        MSG = 'Put a space before the modifier keyword.'.freeze
 
         def on_if(node)
           return unless modifier?(node)
@@ -15,8 +16,8 @@ module RuboCop
           left_of_kw = Parser::Source::Range.new(kw.source_buffer, b - 1, b)
           add_offense(node, left_of_kw) unless left_of_kw.is?(' ')
         end
-        alias_method :on_while, :on_if
-        alias_method :on_until, :on_if
+        alias on_while on_if
+        alias on_until on_if
 
         private
 

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

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

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

@@ -1,4 +1,5 @@
 # encoding: utf-8
+# frozen_string_literal: true
 
 module RuboCop
   module Cop
@@ -19,7 +20,7 @@ module RuboCop
           # auto-correct, so reporting space issues is not useful, and it
           # creates auto-correct conflicts.
           if config.for_cop('Style/BlockDelimiters')['Enabled'] &&
-             Util.block_length(node) > 0
+             block_length(node) > 0
             return
           end
 
@@ -32,7 +33,7 @@ module RuboCop
         private
 
         def check_inside(node, left_brace, right_brace)
-          sb = node.loc.expression.source_buffer
+          sb = node.source_range.source_buffer
 
           if left_brace.end_pos == right_brace.begin_pos
             adjacent_braces(sb, left_brace, right_brace)