rubocop 0.85.0 → 0.88.0

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

@@ -109,7 +109,7 @@ module RuboCop
 
         def own_line_comment?(comment)
           own_line = processed_source.lines[comment.loc.line - 1]
-          own_line =~ /\A\s*#/
+          /\A\s*#/.match?(own_line)
         end
 
         def line_after_comment(comment)
@@ -129,11 +129,11 @@ module RuboCop
         end
 
         def less_indented?(line)
-          line =~ /^\s*(end\b|[)}\]])/
+          /^\s*(end\b|[)}\]])/.match?(line)
         end
 
         def two_alternatives?(line)
-          line =~ /^\s*(else|elsif|when|rescue|ensure)\b/
+          /^\s*(else|elsif|when|rescue|ensure)\b/.match?(line)
         end
       end
     end

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

@@ -119,7 +119,7 @@ module RuboCop
                                     /\A(#+\n)+\z/
                                   end
 
-          !(comment_text =~ empty_comment_pattern).nil?
+          empty_comment_pattern.match?(comment_text)
         end
 
         def comment_text(comment)

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

@@ -109,6 +109,7 @@ module RuboCop
 
         def allowed_only_before_style?(node)
           if node.special_modifier?
+            return true if processed_source[node.last_line] == 'end'
             return false if next_line_empty?(node.last_line)
           end
 

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

@@ -62,6 +62,7 @@ module RuboCop
       #
       class EmptyLinesAroundAttributeAccessor < Cop
         include RangeHelp
+        include AllowedMethods
 
         MSG = 'Add an empty line after attribute accessor.'
 
@@ -96,6 +97,8 @@ module RuboCop
         end
 
         def next_line_node(node)
+          return if node.parent.if_type?
+
           node.parent.children[node.sibling_index + 1]
         end
 
@@ -112,14 +115,6 @@ module RuboCop
         def allow_alias_syntax?
           cop_config.fetch('AllowAliasSyntax', true)
         end
-
-        def allowed_method?(name)
-          allowed_methods.include?(name.to_s)
-        end
-
-        def allowed_methods
-          cop_config.fetch('AllowedMethods', [])
-        end
       end
     end
   end

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

@@ -150,9 +150,10 @@ module RuboCop
         end
 
         def alignment_node(node)
-          if style == :keyword
+          case style
+          when :keyword
             node
-          elsif style == :variable
+          when :variable
             alignment_node_for_variable_style(node)
           else
             start_line_range(node)

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

@@ -65,7 +65,7 @@ module RuboCop
 
         # If there is no LF on the last line, we don't care if there's no CR.
         def unimportant_missing_cr?(index, last_line, line)
-          style == :crlf && index == last_line - 1 && line !~ /\n$/
+          style == :crlf && index == last_line - 1 && !/\n$/.match?(line)
         end
 
         def offense_message(line)

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

@@ -168,7 +168,7 @@ module RuboCop
 
           send_node = arg_node.parent
           text = base_range(send_node, arg_node).source.strip
-          base = if text !~ /\n/ && special_inner_call_indentation?(send_node)
+          base = if !/\n/.match?(text) && special_inner_call_indentation?(send_node)
                    "`#{text}`"
                  elsif comment_line?(text.lines.reverse_each.first)
                    'the start of the previous line (not counting the comment)'
@@ -241,6 +241,10 @@ module RuboCop
             .select { |c| begins_its_line?(c.loc.expression) }
             .map { |c| c.loc.line }
         end
+
+        def on_new_investigation
+          @comment_lines = nil
+        end
       end
     end
   end

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

@@ -37,7 +37,7 @@ module RuboCop
 
         def assignment_on_same_line?(node)
           source = node.source_range.source_line[0...node.loc.column]
-          source =~ /\s*=\s*$/
+          /\s*=\s*$/.match?(source)
         end
       end
     end

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

@@ -200,7 +200,7 @@ module RuboCop
         alias on_super on_send
         alias on_yield on_send
 
-        def on_hash(node)
+        def on_hash(node) # rubocop:todo Metrics/CyclomaticComplexity
           return if ignored_node?(node)
           return if node.pairs.empty? || node.single_line?
 
@@ -219,8 +219,7 @@ module RuboCop
           correct_node(node, delta)
         end
 
-        attr_accessor :offences_by
-        attr_accessor :column_deltas
+        attr_accessor :offences_by, :column_deltas
 
         private
 

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

@@ -147,7 +147,7 @@ module RuboCop
         def indent_level(str)
           indentations = str.lines
                             .map { |line| line[/^\s*/] }
-                            .reject { |line| line == "\n" }
+                            .reject { |line| line.end_with?("\n") }
           indentations.empty? ? 0 : indentations.min_by(&:size).size
         end
 

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

@@ -95,17 +95,27 @@ module RuboCop
         end
 
         def line_break_necessary_in_args?(node)
-          needed_length = node.source_range.column +
-                          node.source.lines.first.length +
-                          block_arg_string(node, node.arguments).length +
-                          PIPE_SIZE
-          needed_length > max_line_length
+          needed_length_for_args(node) > max_line_length
+        end
+
+        def needed_length_for_args(node)
+          node.source_range.column +
+            characters_needed_for_space_and_pipes(node) +
+            node.source.lines.first.chomp.length +
+            block_arg_string(node, node.arguments).length
+        end
+
+        def characters_needed_for_space_and_pipes(node)
+          if node.source.lines.first.end_with?("|\n")
+            PIPE_SIZE
+          else
+            1 + PIPE_SIZE * 2
+          end
         end
 
         def add_offense_for_expression(node, expr, msg)
           expression = expr.source_range
           range = range_between(expression.begin_pos, expression.end_pos)
-
           add_offense(node, location: range, message: msg)
         end
 
@@ -121,7 +131,7 @@ module RuboCop
         end
 
         def autocorrect_body(corrector, node, block_body)
-          first_node = if block_body.begin_type?
+          first_node = if block_body.begin_type? && !block_body.source.start_with?('(')
                          block_body.children.first
                        else
                          block_body

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

@@ -39,7 +39,7 @@ module RuboCop
         private
 
         def followed_by_space?(colon)
-          colon.source_buffer.source[colon.end_pos] =~ /\s/
+          /\s/.match?(colon.source_buffer.source[colon.end_pos])
         end
       end
     end

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

@@ -24,9 +24,10 @@ module RuboCop
       #   # good
       #   {}.each { | x, y | puts x }
       #   ->( x, y ) { puts x }
-      class SpaceAroundBlockParameters < Cop
+      class SpaceAroundBlockParameters < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         def on_block(node)
           arguments = node.arguments
@@ -38,23 +39,6 @@ module RuboCop
           check_each_arg(arguments)
         end
 
-        # @param target [RuboCop::AST::Node,Parser::Source::Range]
-        def autocorrect(target)
-          lambda do |corrector|
-            if target.is_a?(RuboCop::AST::Node)
-              if target.parent.children.first == target
-                corrector.insert_before(target, ' ')
-              else
-                corrector.insert_after(target, ' ')
-              end
-            elsif /^\s+$/.match?(target.source)
-              corrector.remove(target)
-            else
-              corrector.insert_after(target, ' ')
-            end
-          end
-        end
-
         private
 
         def pipes(arguments)
@@ -72,11 +56,12 @@ module RuboCop
         def check_inside_pipes(arguments)
           opening_pipe, closing_pipe = pipes(arguments)
 
-          if style == :no_space
+          case style
+          when :no_space
             check_no_space_style_inside_pipes(arguments.children,
                                               opening_pipe,
                                               closing_pipe)
-          elsif style == :space
+          when :space
             check_space_style_inside_pipes(arguments.children,
                                            opening_pipe,
                                            closing_pipe)
@@ -97,7 +82,7 @@ module RuboCop
 
           check_no_space(opening_pipe.end_pos, first.begin_pos,
                          'Space before first')
-          check_no_space(last_end_pos_inside_pipes(last.end_pos),
+          check_no_space(last_end_pos_inside_pipes(last),
                          closing_pipe.begin_pos, 'Space after last')
         end
 
@@ -118,7 +103,7 @@ module RuboCop
 
         def check_closing_pipe_space(args, closing_pipe)
           last         = args.last.source_range
-          last_end_pos = last_end_pos_inside_pipes(last.end_pos)
+          last_end_pos = last_end_pos_inside_pipes(last)
 
           check_space(last_end_pos, closing_pipe.begin_pos, last,
                       'after last block parameter')
@@ -126,8 +111,9 @@ module RuboCop
                          'Extra space after last')
         end
 
-        def last_end_pos_inside_pipes(pos)
-          processed_source.buffer.source[pos] == ',' ? pos + 1 : pos
+        def last_end_pos_inside_pipes(range)
+          pos = range.end_pos
+          range.source_buffer.source[pos] == ',' ? pos + 1 : pos
         end
 
         def check_each_arg(args)
@@ -151,7 +137,14 @@ module RuboCop
           return if space_begin_pos != space_end_pos
 
           target = node || range
-          add_offense(target, location: range, message: "Space #{msg} missing.")
+          message = "Space #{msg} missing."
+          add_offense(target, message: message) do |corrector|
+            if node
+              corrector.insert_before(node, ' ')
+            else
+              corrector.insert_after(target, ' ')
+            end
+          end
         end
 
         def check_no_space(space_begin_pos, space_end_pos, msg)
@@ -160,8 +153,10 @@ module RuboCop
           range = range_between(space_begin_pos, space_end_pos)
           return if range.source.include?("\n")
 
-          add_offense(range, location: range,
-                             message: "#{msg} block parameter detected.")
+          message = "#{msg} block parameter detected."
+          add_offense(range, message: message) do |corrector|
+            corrector.remove(range)
+          end
         end
       end
     end

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

@@ -186,7 +186,7 @@ module RuboCop
           pos = range.begin_pos - 1
           return false if pos.negative?
 
-          range.source_buffer.source[pos] !~ /[\s(|{\[;,*=]/
+          !/[\s(|{\[;,*=]/.match?(range.source_buffer.source[pos])
         end
 
         def space_after_missing?(range)
@@ -198,7 +198,7 @@ module RuboCop
           return false if accept_namespace_operator?(range) &&
                           namespace_operator?(range, pos)
 
-          char !~ /[\s;,#\\)}\].]/
+          !/[\s;,#\\)}\].]/.match?(char)
         end
 
         def accepted_opening_delimiter?(range, char)

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

@@ -34,96 +34,55 @@ module RuboCop
       #   RuboCop::Cop::Cop
       #   ::RuboCop::Cop
       #
-      class SpaceAroundMethodCallOperator < Cop
-        include SurroundingSpace
+      class SpaceAroundMethodCallOperator < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        SPACES_REGEXP = /\A[ \t]+\z/.freeze
 
         MSG = 'Avoid using spaces around a method call operator.'
 
         def on_send(node)
-          return unless dot_or_safe_navigation_operator?(node)
+          return unless node.dot? || node.safe_navigation?
 
-          check_and_add_offense(node)
+          check_space_before_dot(node)
+          check_space_after_dot(node)
         end
+        alias on_csend on_send
 
         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
+          check_space_after_double_colon(node)
         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?
+        def check_space_before_dot(node)
+          receiver_pos = node.receiver.source_range.end_pos
+          dot_pos = node.loc.dot.begin_pos
+          check_space(receiver_pos, dot_pos)
         end
 
-        def valid_left_token?(left, operator)
-          left && left.line == operator.line
+        def check_space_after_dot(node)
+          dot_pos = node.loc.dot.end_pos
+          selector_pos = node.loc.selector.begin_pos
+          check_space(dot_pos, selector_pos)
         end
 
-        def valid_right_token?(right, operator)
-          right && right.line == operator.line
+        def check_space_after_double_colon(node)
+          double_colon_pos = node.loc.double_colon.end_pos
+          name_pos = node.loc.name.begin_pos
+          check_space(double_colon_pos, name_pos)
         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 check_space(begin_pos, end_pos)
+          return if end_pos <= begin_pos
 
-        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)
+          range = range_between(begin_pos, end_pos)
+          return unless range.source.match?(SPACES_REGEXP)
 
-          operator
+          add_offense(range) { |corrector| corrector.remove(range) }
         end
       end
     end