rubocop 0.51.0 → 0.87.0

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

@@ -5,9 +5,34 @@ module RuboCop
     module Layout
       # Checks that the equals signs in parameter default assignments
       # have or don't have surrounding space depending on configuration.
+      #
+      # @example EnforcedStyle: space (default)
+      #   # bad
+      #   def some_method(arg1=:default, arg2=nil, arg3=[])
+      #     # do something...
+      #   end
+      #
+      #   # good
+      #   def some_method(arg1 = :default, arg2 = nil, arg3 = [])
+      #     # do something...
+      #   end
+      #
+      # @example EnforcedStyle: no_space
+      #   # bad
+      #   def some_method(arg1 = :default, arg2 = nil, arg3 = [])
+      #     # do something...
+      #   end
+      #
+      #   # good
+      #   def some_method(arg1=:default, arg2=nil, arg3=[])
+      #     # do something...
+      #   end
       class SpaceAroundEqualsInParameterDefault < Cop
         include SurroundingSpace
         include ConfigurableEnforcedStyle
+        include RangeHelp
+
+        MSG = 'Surrounding space %<type>s in default value assignment.'
 
         def on_optarg(node)
           index = index_of_first_token(node)
@@ -15,11 +40,18 @@ module RuboCop
           check_optarg(arg, equals, value)
         end
 
+        def autocorrect(range)
+          m = range.source.match(/=\s*(\S+)/)
+          rest = m ? m.captures[0] : ''
+          replacement = style == :space ? ' = ' : '='
+          ->(corrector) { corrector.replace(range, replacement + rest) }
+        end
+
         private
 
         def check_optarg(arg, equals, value)
-          space_on_both_sides = space_on_both_sides?(arg, equals, value)
-          no_surrounding_space = no_surrounding_space?(arg, equals, value)
+          space_on_both_sides = space_on_both_sides?(arg, equals)
+          no_surrounding_space = no_surrounding_space?(arg, equals)
 
           if style == :space && space_on_both_sides ||
              style == :no_space && no_surrounding_space
@@ -32,7 +64,7 @@ module RuboCop
 
         def incorrect_style_detected(arg, value, space_on_both_sides,
                                      no_surrounding_space)
-          range = range_between(arg.pos.end_pos, value.pos.begin_pos)
+          range = range_between(arg.end_pos, value.begin_pos)
           add_offense(range, location: range) do
             if style == :space && no_surrounding_space ||
                style == :no_space && space_on_both_sides
@@ -43,24 +75,16 @@ module RuboCop
           end
         end
 
-        def space_on_both_sides?(arg, equals, value)
-          space_between?(arg, equals) && space_between?(equals, value)
+        def space_on_both_sides?(arg, equals)
+          arg.space_after? && equals.space_after?
         end
 
-        def no_surrounding_space?(arg, equals, value)
-          !space_between?(arg, equals) && !space_between?(equals, value)
+        def no_surrounding_space?(arg, equals)
+          !arg.space_after? && !equals.space_after?
         end
 
-        def message(_)
-          format('Surrounding space %s in default value assignment.',
-                 style == :space ? 'missing' : 'detected')
-        end
-
-        def autocorrect(range)
-          m = range.source.match(/=\s*(\S+)/)
-          rest = m ? m.captures[0] : ''
-          replacement = style == :space ? ' = ' : '='
-          ->(corrector) { corrector.replace(range, replacement + rest) }
+        def message(_node)
+          format(MSG, type: style == :space ? 'missing' : 'detected')
         end
       end
     end

data/lib/rubocop/cop/layout/space_around_keyword.rb

@@ -25,15 +25,17 @@ module RuboCop
       #
       #   something = 123 if test
       class SpaceAroundKeyword < Cop
-        MSG_BEFORE = 'Space before keyword `%s` is missing.'.freeze
-        MSG_AFTER = 'Space after keyword `%s` is missing.'.freeze
+        MSG_BEFORE = 'Space before keyword `%<range>s` is missing.'
+        MSG_AFTER = 'Space after keyword `%<range>s` is missing.'
 
-        DO = 'do'.freeze
-        SAFE_NAVIGATION = '&.'.freeze
+        DO = 'do'
+        SAFE_NAVIGATION = '&.'
+        NAMESPACE_OPERATOR = '::'
         ACCEPT_LEFT_PAREN =
           %w[break defined? next not rescue return super yield].freeze
         ACCEPT_LEFT_SQUARE_BRACKET =
           %w[super yield].freeze
+        ACCEPT_NAMESPACE_OPERATOR = 'super'
 
         def on_and(node)
           check(node, [:operator].freeze) if node.keyword?
@@ -60,7 +62,7 @@ module RuboCop
         end
 
         def on_if(node)
-          check(node, %i[keyword else begin end].freeze, 'then'.freeze)
+          check(node, %i[keyword else begin end].freeze, 'then')
         end
 
         def on_kwbegin(node)
@@ -96,7 +98,7 @@ module RuboCop
         end
 
         def on_send(node)
-          check(node, [:selector].freeze) if node.keyword_not?
+          check(node, [:selector].freeze) if node.prefix_not?
         end
 
         def on_super(node)
@@ -127,11 +129,20 @@ module RuboCop
           check(node, [:keyword].freeze)
         end
 
+        def autocorrect(range)
+          if space_before_missing?(range)
+            ->(corrector) { corrector.insert_before(range, ' ') }
+          else
+            ->(corrector) { corrector.insert_after(range, ' ') }
+          end
+        end
+
         private
 
         def check(node, locations, begin_keyword = DO)
           locations.each do |loc|
             next unless node.loc.respond_to?(loc)
+
             range = node.loc.public_send(loc)
             next unless range
 
@@ -156,7 +167,7 @@ module RuboCop
         end
 
         def do?(node)
-          node.loc.begin && node.loc.begin.is?(DO)
+          node.loc.begin&.is?(DO)
         end
 
         def check_keyword(node, range)
@@ -166,13 +177,16 @@ module RuboCop
         end
 
         def offense(range, msg)
-          add_offense(range, location: range, message: msg % range.source)
+          add_offense(range,
+                      location: range,
+                      message: format(msg, range: range.source))
         end
 
         def space_before_missing?(range)
           pos = range.begin_pos - 1
-          return false if pos < 0
-          range.source_buffer.source[pos] !~ /[\s\(\|\{\[;,\*\=]/
+          return false if pos.negative?
+
+          !/[\s(|{\[;,*=]/.match?(range.source_buffer.source[pos])
         end
 
         def space_after_missing?(range)
@@ -181,8 +195,10 @@ module RuboCop
 
           return false if accepted_opening_delimiter?(range, char)
           return false if safe_navigation_call?(range, pos)
+          return false if accept_namespace_operator?(range) &&
+                          namespace_operator?(range, pos)
 
-          char !~ /[\s;,#\\\)\}\]\.]/
+          !/[\s;,#\\)}\].]/.match?(char)
         end
 
         def accepted_opening_delimiter?(range, char)
@@ -200,28 +216,28 @@ module RuboCop
           ACCEPT_LEFT_SQUARE_BRACKET.include?(range.source)
         end
 
+        def accept_namespace_operator?(range)
+          ACCEPT_NAMESPACE_OPERATOR == range.source
+        end
+
         def safe_navigation_call?(range, pos)
           range.source_buffer.source[pos, 2].start_with?(SAFE_NAVIGATION)
         end
 
+        def namespace_operator?(range, pos)
+          range.source_buffer.source[pos, 2].start_with?(NAMESPACE_OPERATOR)
+        end
+
         def preceded_by_operator?(node, _range)
           # regular dotted method calls bind more tightly than operators
           # so we need to climb up the AST past them
           node.each_ancestor do |ancestor|
             return true if ancestor.and_type? || ancestor.or_type?
             return false unless ancestor.send_type?
-            return true if operator?(ancestor.method_name)
+            return true if ancestor.operator_method?
           end
           false
         end
-
-        def autocorrect(range)
-          if space_before_missing?(range)
-            ->(corrector) { corrector.insert_before(range, ' '.freeze) }
-          else
-            ->(corrector) { corrector.insert_after(range, ' '.freeze) }
-          end
-        end
       end
     end
   end

data/lib/rubocop/cop/layout/space_around_method_call_operator.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks method call operators to not have spaces around them.
+      #
+      # @example
+      #   # bad
+      #   foo. bar
+      #   foo .bar
+      #   foo . bar
+      #   foo. bar .buzz
+      #   foo
+      #     . bar
+      #     . buzz
+      #   foo&. bar
+      #   foo &.bar
+      #   foo &. bar
+      #   foo &. bar&. buzz
+      #   RuboCop:: Cop
+      #   RuboCop:: Cop:: Cop
+      #   :: RuboCop::Cop
+      #
+      #   # good
+      #   foo.bar
+      #   foo.bar.buzz
+      #   foo
+      #     .bar
+      #     .buzz
+      #   foo&.bar
+      #   foo&.bar&.buzz
+      #   RuboCop::Cop
+      #   RuboCop::Cop::Cop
+      #   ::RuboCop::Cop
+      #
+      class SpaceAroundMethodCallOperator < Cop
+        include SurroundingSpace
+
+        MSG = 'Avoid using spaces around a method call operator.'
+
+        def on_send(node)
+          return unless dot_or_safe_navigation_operator?(node)
+
+          check_and_add_offense(node)
+        end
+
+        def on_const(node)
+          return unless node.loc.double_colon
+
+          check_and_add_offense(node, false)
+        end
+
+        def autocorrect(node)
+          operator = operator_token(node)
+          left = left_token_for_auto_correction(node, operator)
+          right = right_token_for_auto_correction(operator)
+
+          lambda do |corrector|
+            SpaceCorrector.remove_space(
+              processed_source, corrector, left, right
+            )
+          end
+        end
+
+        alias on_csend on_send
+
+        private
+
+        def check_and_add_offense(node, add_left_offense = true)
+          operator = operator_token(node)
+          left = previous_token(operator)
+          right = next_token(operator)
+
+          if !right.comment? && valid_right_token?(right, operator)
+            no_space_offenses(node, operator, right, MSG)
+          end
+          return unless valid_left_token?(left, operator)
+
+          no_space_offenses(node, left, operator, MSG) if add_left_offense
+        end
+
+        def operator_token(node)
+          operator_location =
+            node.const_type? ? node.loc.double_colon : node.loc.dot
+
+          processed_source.find_token do |token|
+            token.pos == operator_location
+          end
+        end
+
+        def previous_token(current_token)
+          index = processed_source.tokens.index(current_token)
+          index.zero? ? nil : processed_source.tokens[index - 1]
+        end
+
+        def next_token(current_token)
+          index = processed_source.tokens.index(current_token)
+          processed_source.tokens[index + 1]
+        end
+
+        def dot_or_safe_navigation_operator?(node)
+          node.dot? || node.safe_navigation?
+        end
+
+        def valid_left_token?(left, operator)
+          left && left.line == operator.line
+        end
+
+        def valid_right_token?(right, operator)
+          right && right.line == operator.line
+        end
+
+        def left_token_for_auto_correction(node, operator)
+          left_token = previous_token(operator)
+          return operator if node.const_type?
+          return left_token if valid_left_token?(left_token, operator)
+
+          operator
+        end
+
+        def right_token_for_auto_correction(operator)
+          right_token = next_token(operator)
+          return right_token if !right_token.comment? && valid_right_token?(right_token, operator)
+
+          operator
+        end
+      end
+    end
+  end
+end

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

@@ -3,12 +3,58 @@
 module RuboCop
   module Cop
     module Layout
-      # Checks that operators have space around them, except for **
-      # which should not have surrounding space.
+      # Checks that operators have space around them, except for ** which
+      # should or shouldn't have surrounding space depending on configuration.
+      #
+      # This cop has `AllowForAlignment` option. When `true`, allows most
+      # uses of extra spacing if the intent is to align with an operator on
+      # the previous or next line, not counting empty lines or comment lines.
+      #
+      # @example
+      #   # bad
+      #   total = 3*4
+      #   "apple"+"juice"
+      #   my_number = 38/4
+      #
+      #   # good
+      #   total = 3 * 4
+      #   "apple" + "juice"
+      #   my_number = 38 / 4
+      #
+      # @example AllowForAlignment: true (default)
+      #   # good
+      #   {
+      #     1 =>  2,
+      #     11 => 3
+      #   }
+      #
+      # @example AllowForAlignment: false
+      #   # bad
+      #   {
+      #     1 =>  2,
+      #     11 => 3
+      #   }
+      #
+      # @example EnforcedStyleForExponentOperator: no_space (default)
+      #   # bad
+      #   a ** b
+      #
+      #   # good
+      #   a**b
+      #
+      # @example EnforcedStyleForExponentOperator: space
+      #   # bad
+      #   a**b
+      #
+      #   # good
+      #   a ** b
       class SpaceAroundOperators < Cop
         include PrecedingFollowingAlignment
+        include RangeHelp
+        include RationalLiteral
 
         IRREGULAR_METHODS = %i[[] ! []=].freeze
+        EXCESSIVE_SPACE = '  '
 
         def self.autocorrect_incompatible_with
           [Style::SelfAssignment]
@@ -19,14 +65,14 @@ module RuboCop
 
           return if hash_table_style? && !node.parent.pairs_on_same_line?
 
-          check_operator(node.loc.operator, node.source_range)
+          check_operator(:pair, node.loc.operator, node.source_range)
         end
 
         def on_if(node)
           return unless node.ternary?
 
-          check_operator(node.loc.question, node.if_branch.source_range)
-          check_operator(node.loc.colon, node.else_branch.source_range)
+          check_operator(:if, node.loc.question, node.if_branch.source_range)
+          check_operator(:if, node.loc.colon, node.else_branch.source_range)
         end
 
         def on_resbody(node)
@@ -34,45 +80,70 @@ module RuboCop
 
           _, variable, = *node
 
-          check_operator(node.loc.assoc, variable.source_range)
+          check_operator(:resbody, node.loc.assoc, variable.source_range)
         end
 
         def on_send(node)
+          return if rational_literal?(node)
+
           if node.setter_method?
             on_special_asgn(node)
           elsif regular_operator?(node)
-            check_operator(node.loc.selector, node.first_argument.source_range)
+            check_operator(:send,
+                           node.loc.selector,
+                           node.first_argument.source_range)
           end
         end
 
+        def on_assignment(node)
+          _, rhs, = *node
+
+          return unless rhs
+
+          check_operator(:assignment, node.loc.operator, rhs.source_range)
+        end
+
         def on_binary(node)
           _, rhs, = *node
 
           return unless rhs
 
-          check_operator(node.loc.operator, rhs.source_range)
+          check_operator(:binary, node.loc.operator, rhs.source_range)
         end
 
         def on_special_asgn(node)
           _, _, right, = *node
 
           return unless right
-          check_operator(node.loc.operator, right.source_range)
+
+          check_operator(:special_asgn, 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_lvasgn   on_assignment
+        alias on_masgn    on_assignment
         alias on_casgn    on_special_asgn
-        alias on_ivasgn   on_binary
-        alias on_cvasgn   on_binary
-        alias on_gvasgn   on_binary
+        alias on_ivasgn   on_assignment
+        alias on_cvasgn   on_assignment
+        alias on_gvasgn   on_assignment
         alias on_class    on_binary
-        alias on_or_asgn  on_binary
-        alias on_and_asgn on_binary
+        alias on_or_asgn  on_assignment
+        alias on_and_asgn on_assignment
         alias on_op_asgn  on_special_asgn
 
+        def autocorrect(range)
+          lambda do |corrector|
+            if /\*\*/.match?(range.source) && !space_around_exponent_operator?
+              corrector.replace(range, '**')
+            elsif range.source.end_with?("\n")
+              corrector.replace(range, " #{range.source.strip}\n")
+            else
+              enclose_operator_with_space(corrector, range)
+            end
+          end
+        end
+
         private
 
         def regular_operator?(send_node)
@@ -85,61 +156,86 @@ module RuboCop
             !IRREGULAR_METHODS.include?(send_node.method_name)
         end
 
-        def check_operator(op, right_operand)
-          with_space = range_with_surrounding_space(op)
+        def check_operator(type, operator, right_operand)
+          with_space = range_with_surrounding_space(range: operator)
           return if with_space.source.start_with?("\n")
 
-          offense(op, with_space, right_operand) do |msg|
-            add_offense(with_space, location: op, message: msg)
+          offense(type, operator, with_space, right_operand) do |msg|
+            add_offense(with_space, location: operator, message: msg)
           end
         end
 
-        def offense(op, with_space, right_operand)
-          msg = offense_message(op, with_space, right_operand)
+        def offense(type, operator, with_space, right_operand)
+          msg = offense_message(type, operator, with_space, right_operand)
           yield msg if msg
         end
 
-        def offense_message(op, with_space, right_operand)
-          if op.is?('**')
-            'Space around operator `**` detected.' unless with_space.is?('**')
-          elsif with_space.source !~ /^\s.*\s$/
-            "Surrounding space missing for operator `#{op.source}`."
-          elsif excess_leading_space?(op, with_space) ||
+        def enclose_operator_with_space(corrector, range)
+          operator = range.source
+
+          # If `ForceEqualSignAlignment` is true, `Layout/ExtraSpacing` cop
+          # inserts spaces before operator. If `Layout/SpaceAroundOperators` cop
+          # inserts a space, it collides and raises the infinite loop error.
+          if force_equal_sign_alignment?
+            corrector.insert_after(range, ' ') unless operator.end_with?(' ')
+          else
+            corrector.replace(range, " #{operator.strip} ")
+          end
+        end
+
+        def offense_message(type, operator, with_space, right_operand)
+          if should_not_have_surrounding_space?(operator)
+            return if with_space.is?(operator.source)
+
+            "Space around operator `#{operator.source}` detected."
+          elsif !/^\s.*\s$/.match?(with_space.source)
+            "Surrounding space missing for operator `#{operator.source}`."
+          elsif excess_leading_space?(type, operator, with_space) ||
                 excess_trailing_space?(right_operand, with_space)
-            "Operator `#{op.source}` should be surrounded by a single space."
+            "Operator `#{operator.source}` should be surrounded " \
+            'by a single space.'
           end
         end
 
-        def excess_leading_space?(op, with_space)
-          with_space.source =~ /^  / &&
-            (!allow_for_alignment? || !aligned_with_operator?(op))
+        def excess_leading_space?(type, operator, with_space)
+          return false unless allow_for_alignment?
+          return false unless with_space.source.start_with?(EXCESSIVE_SPACE)
+
+          return !aligned_with_operator?(operator) unless type == :assignment
+
+          token            = Token.new(operator, nil, operator.source)
+          align_preceding  = aligned_with_preceding_assignment(token)
+
+          return align_preceding == :no unless align_preceding == :none
+
+          aligned_with_subsequent_assignment(token) != :yes
         end
 
         def excess_trailing_space?(right_operand, with_space)
-          with_space.source =~ /  $/ &&
+          with_space.source.end_with?(EXCESSIVE_SPACE) &&
             (!allow_for_alignment? || !aligned_with_something?(right_operand))
         end
 
-        def autocorrect(range)
-          lambda do |corrector|
-            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
-          end
-        end
-
         def align_hash_cop_config
-          config.for_cop('Layout/AlignHash')
+          config.for_cop('Layout/HashAlignment')
         end
 
         def hash_table_style?
           align_hash_cop_config &&
             align_hash_cop_config['EnforcedHashRocketStyle'] == 'table'
         end
+
+        def space_around_exponent_operator?
+          cop_config['EnforcedStyleForExponentOperator'] == 'space'
+        end
+
+        def force_equal_sign_alignment?
+          config.for_cop('Layout/ExtraSpacing')['ForceEqualSignAlignment']
+        end
+
+        def should_not_have_surrounding_space?(operator)
+          operator.is?('**') ? !space_around_exponent_operator? : false
+        end
       end
     end
   end