rubocop 0.82.0 → 0.86.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/condition_position.rb

@@ -23,6 +23,8 @@ module RuboCop
       #     do_something
       #   end
       class ConditionPosition < Cop
+        include RangeHelp
+
         MSG = 'Place the condition on the same line as `%<keyword>s`.'
 
         def on_if(node)
@@ -34,9 +36,17 @@ module RuboCop
         def on_while(node)
           check(node)
         end
+        alias on_until on_while
 
-        def on_until(node)
-          check(node)
+        def autocorrect(node)
+          lambda do |corrector|
+            range = range_by_whole_lines(
+              node.source_range, include_final_newline: true
+            )
+
+            corrector.insert_after(node.parent.loc.keyword, " #{node.source}")
+            corrector.remove(range)
+          end
         end
 
         private

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

@@ -99,9 +99,7 @@ module RuboCop
           lambda do |corrector|
             line = range_by_whole_lines(node.source_range)
 
-            unless previous_line_empty?(node.first_line)
-              corrector.insert_before(line, "\n")
-            end
+            corrector.insert_before(line, "\n") unless previous_line_empty?(node.first_line)
 
             correct_next_line_if_denied_style(corrector, node, line)
           end
@@ -120,9 +118,7 @@ module RuboCop
         def correct_next_line_if_denied_style(corrector, node, line)
           case style
           when :around
-            unless next_line_empty?(node.last_line)
-              corrector.insert_after(line, "\n")
-            end
+            corrector.insert_after(line, "\n") unless next_line_empty?(node.last_line)
           when :only_before
             if next_line_empty?(node.last_line)
               range = next_empty_line_range(node)

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

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Layout
+      # Checks for a newline after an attribute accessor or a group of them.
+      # `alias` syntax and `alias_method`, `public`, `protected`, and `private` methods are allowed
+      # by default. These are customizable with `AllowAliasSyntax` and `AllowedMethods` options.
+      #
+      # @example
+      #   # bad
+      #   attr_accessor :foo
+      #   def do_something
+      #   end
+      #
+      #   # good
+      #   attr_accessor :foo
+      #
+      #   def do_something
+      #   end
+      #
+      #   # good
+      #   attr_accessor :foo
+      #   attr_reader :bar
+      #   attr_writer :baz
+      #   attr :qux
+      #
+      #   def do_something
+      #   end
+      #
+      # @example AllowAliasSyntax: true (default)
+      #   # good
+      #   attr_accessor :foo
+      #   alias :foo? :foo
+      #
+      #   def do_something
+      #   end
+      #
+      # @example AllowAliasSyntax: false
+      #   # bad
+      #   attr_accessor :foo
+      #   alias :foo? :foo
+      #
+      #   def do_something
+      #   end
+      #
+      #   # good
+      #   attr_accessor :foo
+      #
+      #   alias :foo? :foo
+      #
+      #   def do_something
+      #   end
+      #
+      # @example AllowedMethods: ['private']
+      #   # good
+      #   attr_accessor :foo
+      #   private :foo
+      #
+      #   def do_something
+      #   end
+      #
+      class EmptyLinesAroundAttributeAccessor < Cop
+        include RangeHelp
+
+        MSG = 'Add an empty line after attribute accessor.'
+
+        def on_send(node)
+          return unless node.attribute_accessor?
+          return if next_line_empty?(node.last_line)
+
+          next_line_node = next_line_node(node)
+          return unless require_empty_line?(next_line_node)
+
+          add_offense(node)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            range = range_by_whole_lines(node.source_range)
+
+            corrector.insert_after(range, "\n")
+          end
+        end
+
+        private
+
+        def next_line_empty?(line)
+          processed_source[line].blank?
+        end
+
+        def require_empty_line?(node)
+          return false unless node&.respond_to?(:type)
+
+          !allow_alias?(node) && !attribute_or_allowed_method?(node)
+        end
+
+        def next_line_node(node)
+          return if node.parent.if_type?
+
+          node.parent.children[node.sibling_index + 1]
+        end
+
+        def allow_alias?(node)
+          allow_alias_syntax? && node.alias_type?
+        end
+
+        def attribute_or_allowed_method?(node)
+          return false unless node.send_type?
+
+          node.attribute_accessor? || allowed_method?(node.method_name)
+        end
+
+        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
+end

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)
@@ -75,8 +75,8 @@ module RuboCop
                               style
                             end
           case effective_style
-          when :lf then MSG_DETECTED if /\r$/.match?(line)
-          else MSG_MISSING unless /\r$/.match?(line)
+          when :lf then MSG_DETECTED if line.end_with?("\r", "\r\n")
+          else MSG_MISSING unless line.end_with?("\r\n")
           end
         end
 

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

@@ -2,13 +2,12 @@
 
 module RuboCop
   module Cop
-    # rubocop:disable Layout/LineLength
     module Layout
       # This cop checks the indentation of the first argument in a method call.
       # Arguments after the first one are checked by Layout/ArgumentAlignment,
       # not by this cop.
       #
-      # For indenting the first parameter of method *definitions*, check out
+      # For indenting the first parameter of method _definitions_, check out
       # Layout/FirstParameterIndentation.
       #
       # @example
@@ -143,7 +142,6 @@ module RuboCop
       #   second_param
       #
       class FirstArgumentIndentation < Cop
-        # rubocop:enable Layout/LineLength
         include Alignment
         include ConfigurableEnforcedStyle
         include RangeHelp
@@ -170,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)'

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

@@ -125,9 +125,7 @@ module RuboCop
 
         def check_right_bracket(right_bracket, left_bracket, left_parenthesis)
           # if the right bracket is on the same line as the last value, accept
-          if /\S/.match?(right_bracket.source_line[0...right_bracket.column])
-            return
-          end
+          return if /\S/.match?(right_bracket.source_line[0...right_bracket.column])
 
           expected_column = base_column(left_bracket, left_parenthesis)
           @column_delta = expected_column - right_bracket.column

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/first_method_argument_line_break.rb

@@ -36,9 +36,7 @@ module RuboCop
           # ...then each key/value pair is treated as a method 'argument'
           # when determining where line breaks should appear.
           if (last_arg = args.last)
-            if last_arg.hash_type? && !last_arg.braces?
-              args = args.concat(args.pop.children)
-            end
+            args = args.concat(args.pop.children) if last_arg.hash_type? && !last_arg.braces?
           end
 
           check_method_line_break(node, args)

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

@@ -7,9 +7,9 @@ module RuboCop
       # definition. Parameters after the first one are checked by
       # Layout/ParameterAlignment, not by this cop.
       #
-      # For indenting the first argument of method *calls*, check out
+      # For indenting the first argument of method _calls_, check out
       # Layout/FirstArgumentIndentation, which supports options related to
-      # nesting that are irrelevant for method *definitions*.
+      # nesting that are irrelevant for method _definitions_.
       #
       # @example
       #

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

@@ -7,16 +7,16 @@ module RuboCop
       # literal are aligned according to configuration. The configuration
       # options are:
       #
-      #   - key (left align keys, one space before hash rockets and values)
-      #   - separator (align hash rockets and colons, right align keys)
-      #   - table (left align keys, hash rockets, and values)
+      # * key (left align keys, one space before hash rockets and values)
+      # * separator (align hash rockets and colons, right align keys)
+      # * table (left align keys, hash rockets, and values)
       #
       # The treatment of hashes passed as the last argument to a method call
       # can also be configured. The options are:
       #
-      #   - always_inspect
-      #   - always_ignore
-      #   - ignore_implicit (without curly braces)
+      # * always_inspect
+      # * always_ignore
+      # * ignore_implicit (without curly braces)
       #
       # Alternatively you can specify multiple allowed styles. That's done by
       # passing a list of styles to EnforcedStyles.
@@ -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?
 

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

@@ -98,13 +98,9 @@ module RuboCop
           lambda do |corrector|
             fix_closing_parenthesis(node, corrector)
 
-            if internal_trailing_comma?(node)
-              remove_internal_trailing_comma(node, corrector)
-            end
+            remove_internal_trailing_comma(node, corrector) if internal_trailing_comma?(node)
 
-            if external_trailing_comma?(node)
-              fix_external_trailing_comma(node, corrector)
-            end
+            fix_external_trailing_comma(node, corrector) if external_trailing_comma?(node)
           end
         end
 
@@ -194,7 +190,7 @@ module RuboCop
         def safe_to_remove_line_containing_closing_paren?(node)
           last_line = processed_source[node.loc.end.line - 1]
           # Safe to remove if last line only contains `)`, `,`, and whitespace.
-          last_line.match(/^[ ]*\)[ ]{0,20},{0,1}[ ]*$/)
+          last_line.match?(/^ *\) {0,20},{0,1} *$/)
         end
 
         def incorrect_parenthesis_removal_end(node)

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

@@ -5,66 +5,29 @@ module RuboCop
     module Layout
       # This cop checks the indentation of the here document bodies. The bodies
       # are indented one step.
-      # In Ruby 2.3 or newer, squiggly heredocs (`<<~`) should be used. If you
-      # use the older rubies, you should introduce some library to your project
-      # (e.g. ActiveSupport, Powerpack or Unindent).
-      # Note: When `Layout/LineLength`'s `AllowHeredoc` is false (not default),
+      #
+      # Note: When ``Layout/LineLength``'s `AllowHeredoc` is false (not default),
       #       this cop does not add any offenses for long here documents to
       #       avoid `Layout/LineLength`'s offenses.
       #
-      # @example EnforcedStyle: squiggly (default)
+      # @example
       #   # bad
       #   <<-RUBY
       #   something
       #   RUBY
       #
       #   # good
-      #   # When EnforcedStyle is squiggly, bad code is auto-corrected to the
-      #   # following code.
       #   <<~RUBY
       #     something
       #   RUBY
       #
-      # @example EnforcedStyle: active_support
-      #   # good
-      #   # When EnforcedStyle is active_support, bad code is auto-corrected to
-      #   # the following code.
-      #   <<-RUBY.strip_heredoc
-      #     something
-      #   RUBY
-      #
-      # @example EnforcedStyle: powerpack
-      #   # good
-      #   # When EnforcedStyle is powerpack, bad code is auto-corrected to
-      #   # the following code.
-      #   <<-RUBY.strip_indent
-      #     something
-      #   RUBY
-      #
-      # @example EnforcedStyle: unindent
-      #   # good
-      #   # When EnforcedStyle is unindent, bad code is auto-corrected to
-      #   # the following code.
-      #   <<-RUBY.unindent
-      #     something
-      #   RUBY
       #
       class HeredocIndentation < Cop
         include Heredoc
-        include ConfigurableEnforcedStyle
 
-        RUBY23_TYPE_MSG = 'Use %<indentation_width>d spaces for indentation ' \
-                          'in a heredoc by using `<<~` instead of ' \
-                          '`%<current_indent_type>s`.'
-        RUBY23_WIDTH_MSG = 'Use %<indentation_width>d spaces for '\
-                           'indentation in a heredoc.'
-        LIBRARY_MSG = 'Use %<indentation_width>d spaces for indentation in a ' \
-                      'heredoc by using %<method>s.'
-        STRIP_METHODS = {
-          unindent: 'unindent',
-          active_support: 'strip_heredoc',
-          powerpack: 'strip_indent'
-        }.freeze
+        TYPE_MSG = 'Use %<indentation_width>d spaces for indentation in a ' \
+                   'heredoc by using `<<~` instead of `%<current_indent_type>s`.'
+        WIDTH_MSG = 'Use %<indentation_width>d spaces for indentation in a heredoc.'
 
         def on_heredoc(node)
           body = heredoc_body(node)
@@ -85,59 +48,38 @@ module RuboCop
         end
 
         def autocorrect(node)
-          check_style!
-
-          case style
-          when :squiggly
-            correct_by_squiggly(node)
-          else
-            correct_by_library(node)
+          lambda do |corrector|
+            if heredoc_indent_type(node) == '~'
+              adjust_squiggly(corrector, node)
+            else
+              adjust_minus(corrector, node)
+            end
           end
         end
 
         private
 
         def message(node)
-          case style
-          when :squiggly
-            current_indent_type = "<<#{heredoc_indent_type(node)}"
-            ruby23_message(indentation_width, current_indent_type)
-          when nil
-            method = "some library(e.g. ActiveSupport's `String#strip_heredoc`)"
-            library_message(indentation_width, method)
-          else
-            method = "`String##{STRIP_METHODS[style]}`"
-            library_message(indentation_width, method)
-          end
-        end
-
-        def library_message(indentation_width, method)
-          format(
-            LIBRARY_MSG,
-            indentation_width: indentation_width,
-            method: method
-          )
-        end
+          current_indent_type = "<<#{heredoc_indent_type(node)}"
 
-        def ruby23_message(indentation_width, current_indent_type)
           if current_indent_type == '<<~'
-            ruby23_width_message(indentation_width)
+            width_message(indentation_width)
           else
-            ruby23_type_message(indentation_width, current_indent_type)
+            type_message(indentation_width, current_indent_type)
           end
         end
 
-        def ruby23_type_message(indentation_width, current_indent_type)
+        def type_message(indentation_width, current_indent_type)
           format(
-            RUBY23_TYPE_MSG,
+            TYPE_MSG,
             indentation_width: indentation_width,
             current_indent_type: current_indent_type
           )
         end
 
-        def ruby23_width_message(indentation_width)
+        def width_message(indentation_width)
           format(
-            RUBY23_WIDTH_MSG,
+            WIDTH_MSG,
             indentation_width: indentation_width
           )
         end
@@ -166,16 +108,6 @@ module RuboCop
           config.for_cop('Layout/LineLength')['Max']
         end
 
-        def correct_by_squiggly(node)
-          lambda do |corrector|
-            if heredoc_indent_type(node) == '~'
-              adjust_squiggly(corrector, node)
-            else
-              adjust_minus(corrector, node)
-            end
-          end
-        end
-
         def adjust_squiggly(corrector, node)
           corrector.replace(node.loc.heredoc_body, indented_body(node))
           corrector.replace(node.loc.heredoc_end, indented_end(node))
@@ -187,21 +119,6 @@ module RuboCop
           corrector.replace(node, corrected)
         end
 
-        def correct_by_library(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.heredoc_body, indented_body(node))
-            corrected = ".#{STRIP_METHODS[style]}"
-            corrector.insert_after(node, corrected)
-          end
-        end
-
-        def check_style!
-          return if style
-
-          raise Warning, "Auto-correction does not work for #{cop_name}. " \
-                         'Please configure EnforcedStyle.'
-        end
-
         def indented_body(node)
           body = heredoc_body(node)
           body_indent_level = indent_level(body)
@@ -230,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