rubocop 0.78.0 → 0.82.0

data/lib/rubocop/cop/autocorrect_logic.rb

@@ -24,15 +24,18 @@ module RuboCop
         @options[:disable_uncorrectable] == true
       end
 
+      def safe_autocorrect?
+        cop_config.fetch('Safe', true) &&
+          cop_config.fetch('SafeAutoCorrect', true)
+      end
+
       def autocorrect_enabled?
         # allow turning off autocorrect on a cop by cop basis
         return true unless cop_config
 
         return false if cop_config['AutoCorrect'] == false
 
-        if @options.fetch(:safe_auto_correct, false)
-          return cop_config.fetch('SafeAutoCorrect', true)
-        end
+        return safe_autocorrect? if @options.fetch(:safe_auto_correct, false)
 
         true
       end

data/lib/rubocop/cop/badge.rb

@@ -4,11 +4,11 @@ module RuboCop
   module Cop
     # Identifier of all cops containing a department and cop name.
     #
-    # All cops are identified by their badge. For example, the badge
-    # for `RuboCop::Cop::Layout::Tab` is `Layout/Tab`. Badges can be
-    # parsed as either `Department/CopName` or just `CopName` to allow
-    # for badge references in source files that omit the department
-    # for RuboCop to infer.
+    # All cops are identified by their badge. For example, the badge for
+    # `RuboCop::Cop::Layout::IndentationStyle` is `Layout/IndentationStyle`.
+    # Badges can be parsed as either `Department/CopName` or just `CopName` to
+    # allow for badge references in source files that omit the department for
+    # RuboCop to infer.
     class Badge
       # Error raised when a badge parse fails.
       class InvalidBadge < Error

data/lib/rubocop/cop/bundler/insecure_protocol_source.rb

@@ -53,7 +53,7 @@ module RuboCop
         def autocorrect(node)
           lambda do |corrector|
             corrector.replace(
-              node.first_argument.loc.expression, "'https://rubygems.org'"
+              node.first_argument, "'https://rubygems.org'"
             )
           end
         end

data/lib/rubocop/cop/corrector.rb

@@ -72,18 +72,18 @@ module RuboCop
 
       # Removes the source range.
       #
-      # @param [Parser::Source::Range] range
-      def remove(range)
-        validate_range range
+      # @param [Parser::Source::Range, Rubocop::AST::Node] range or node
+      def remove(node_or_range)
+        range = to_range(node_or_range)
         @source_rewriter.remove(range)
       end
 
       # Inserts new code before the given source range.
       #
-      # @param [Parser::Source::Range] range
+      # @param [Parser::Source::Range, Rubocop::AST::Node] range or node
       # @param [String] content
-      def insert_before(range, content)
-        validate_range range
+      def insert_before(node_or_range, content)
+        range = to_range(node_or_range)
         # TODO: Fix Cops using bad ranges instead
         if range.end_pos > @source_buffer.source.size
           range = range.with(end_pos: @source_buffer.source.size)
@@ -94,28 +94,38 @@ module RuboCop
 
       # Inserts new code after the given source range.
       #
-      # @param [Parser::Source::Range] range
+      # @param [Parser::Source::Range, Rubocop::AST::Node] range or node
       # @param [String] content
-      def insert_after(range, content)
-        validate_range range
+      def insert_after(node_or_range, content)
+        range = to_range(node_or_range)
         @source_rewriter.insert_after(range, content)
       end
 
+      # Wraps the given source range with the given before and after texts
+      #
+      # @param [Parser::Source::Range, Rubocop::AST::Node] range or node
+      # @param [String] before
+      # @param [String] after
+      def wrap(node_or_range, before, after)
+        range = to_range(node_or_range)
+        @source_rewriter.wrap(range, before, after)
+      end
+
       # Replaces the code of the source range `range` with `content`.
       #
-      # @param [Parser::Source::Range] range
+      # @param [Parser::Source::Range, Rubocop::AST::Node] range or node
       # @param [String] content
-      def replace(range, content)
-        validate_range range
+      def replace(node_or_range, content)
+        range = to_range(node_or_range)
         @source_rewriter.replace(range, content)
       end
 
       # Removes `size` characters prior to the source range.
       #
-      # @param [Parser::Source::Range] range
+      # @param [Parser::Source::Range, Rubocop::AST::Node] range or node
       # @param [Integer] size
-      def remove_preceding(range, size)
-        validate_range range
+      def remove_preceding(node_or_range, size)
+        range = to_range(node_or_range)
         to_remove = Parser::Source::Range.new(range.source_buffer,
                                               range.begin_pos - size,
                                               range.begin_pos)
@@ -126,10 +136,10 @@ module RuboCop
       # If `size` is greater than the size of `range`, the removed region can
       # overrun the end of `range`.
       #
-      # @param [Parser::Source::Range] range
+      # @param [Parser::Source::Range, Rubocop::AST::Node] range or node
       # @param [Integer] size
-      def remove_leading(range, size)
-        validate_range range
+      def remove_leading(node_or_range, size)
+        range = to_range(node_or_range)
         to_remove = Parser::Source::Range.new(range.source_buffer,
                                               range.begin_pos,
                                               range.begin_pos + size)
@@ -140,10 +150,10 @@ module RuboCop
       # If `size` is greater than the size of `range`, the removed region can
       # overrun the beginning of `range`.
       #
-      # @param [Parser::Source::Range] range
+      # @param [Parser::Source::Range, Rubocop::AST::Node] range or node
       # @param [Integer] size
-      def remove_trailing(range, size)
-        validate_range range
+      def remove_trailing(node_or_range, size)
+        range = to_range(node_or_range)
         to_remove = Parser::Source::Range.new(range.source_buffer,
                                               range.end_pos - size,
                                               range.end_pos)
@@ -153,11 +163,25 @@ module RuboCop
       private
 
       # :nodoc:
-      def validate_range(range)
-        buffer = range.source_buffer
+      def to_range(node_or_range)
+        range = case node_or_range
+                when ::RuboCop::AST::Node, ::Parser::Source::Comment
+                  node_or_range.loc.expression
+                when ::Parser::Source::Range
+                  node_or_range
+                else
+                  raise TypeError,
+                        'Expected a Parser::Source::Range, Comment or ' \
+                        "Rubocop::AST::Node, got #{node_or_range.class}"
+                end
+        validate_buffer(range.source_buffer)
+        range
+      end
+
+      def validate_buffer(buffer)
         return if buffer == @source_buffer
 
-        unless buffer.is_a?(Parser::Source::Buffer)
+        unless buffer.is_a?(::Parser::Source::Buffer)
           # actually this should be enforced by parser gem
           raise 'Corrector expected range source buffer to be a ' \
                 "Parser::Source::Buffer, but got #{buffer.class}"

data/lib/rubocop/cop/correctors/alignment_corrector.rb

@@ -51,7 +51,7 @@ module RuboCop
             unless range.resize(1).source == "\n"
               corrector.insert_before(range, ' ' * column_delta)
             end
-          elsif range.source =~ /\A[ \t]+\z/
+          elsif /\A[ \t]+\z/.match?(range.source)
             remove(range, corrector)
           end
         end
@@ -112,7 +112,7 @@ module RuboCop
           corrector.remove(range)
         rescue RuntimeError
           range = range_between(range.begin_pos + 1, range.end_pos + 1)
-          retry if range.source =~ /^ +$/
+          retry if /^ +$/.match?(range.source)
         ensure
           $stderr = original_stderr
         end

data/lib/rubocop/cop/correctors/condition_corrector.rb

@@ -10,8 +10,7 @@ module RuboCop
 
           lambda do |corrector|
             corrector.replace(node.loc.keyword, node.inverse_keyword)
-            corrector.replace(condition.source_range,
-                              condition.children.first.source)
+            corrector.replace(condition, condition.children.first.source)
           end
         end
 

data/lib/rubocop/cop/correctors/empty_line_corrector.rb

@@ -18,7 +18,7 @@ module RuboCop
         end
 
         def insert_before(node)
-          ->(corrector) { corrector.insert_before(node.source_range, "\n") }
+          ->(corrector) { corrector.insert_before(node, "\n") }
         end
       end
     end

data/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb

@@ -44,13 +44,13 @@ module RuboCop
       end
 
       def replace_selector(corrector)
-        corrector.replace(method.source_range, 'lambda')
+        corrector.replace(method, 'lambda')
       end
 
       def remove_arguments(corrector)
         return if arguments.empty_and_without_delimiters?
 
-        corrector.remove(arguments.source_range)
+        corrector.remove(arguments)
       end
 
       def insert_arguments(corrector)
@@ -62,7 +62,7 @@ module RuboCop
 
       def remove_leading_whitespace(corrector)
         corrector.remove_preceding(
-          arguments.source_range,
+          arguments,
           arguments.source_range.begin_pos -
             block_node.send_node.source_range.end_pos
         )

data/lib/rubocop/cop/correctors/line_break_corrector.rb

@@ -38,9 +38,9 @@ module RuboCop
           return unless eol_comment
 
           text = eol_comment.loc.expression.source
-          corrector.insert_before(node.source_range,
+          corrector.insert_before(node,
                                   text + "\n" + (' ' * node.loc.keyword.column))
-          corrector.remove(eol_comment.loc.expression)
+          corrector.remove(eol_comment)
         end
 
         private

data/lib/rubocop/cop/correctors/percent_literal_corrector.rb

@@ -26,7 +26,7 @@ module RuboCop
       def wrap_contents(node, contents, char, delimiters)
         lambda do |corrector|
           corrector.replace(
-            node.source_range,
+            node,
             "%#{char}#{delimiters[0]}#{contents}#{delimiters[1]}"
           )
         end

data/lib/rubocop/cop/correctors/string_literal_corrector.rb

@@ -13,9 +13,9 @@ module RuboCop
           lambda do |corrector|
             str = node.str_content
             if style == :single_quotes
-              corrector.replace(node.source_range, to_string_literal(str))
+              corrector.replace(node, to_string_literal(str))
             else
-              corrector.replace(node.source_range, str.inspect)
+              corrector.replace(node, str.inspect)
             end
           end
         end

data/lib/rubocop/cop/gemspec/ordered_dependencies.rb

@@ -98,7 +98,7 @@ module RuboCop
         end
 
         def_node_search :dependency_declarations, <<~PATTERN
-          (send (lvar _) {:add_dependency :add_runtime_dependency :add_development_dependency} ...)
+          (send (lvar _) {:add_dependency :add_runtime_dependency :add_development_dependency} (str _) ...)
         PATTERN
       end
     end

data/lib/rubocop/cop/generator.rb

@@ -104,10 +104,9 @@ module RuboCop
         end
       SPEC
 
-      CONFIGURATION_ADDED_MESSAGE = <<~MESSAGE
-        [modify] A configuration for the cop is added into %<configuration_file_path>s.
-                 If you want to disable the cop by default, set `Enabled` option to false.
-      MESSAGE
+      CONFIGURATION_ADDED_MESSAGE =
+        '[modify] A configuration for the cop is added into ' \
+          '%<configuration_file_path>s.'
 
       def initialize(name, github_user, output: $stdout)
         @badge = Badge.parse(name)

data/lib/rubocop/cop/generator/configuration_injector.rb

@@ -10,7 +10,7 @@ module RuboCop
         TEMPLATE = <<~YAML
           %<badge>s:
             Description: 'TODO: Write a description of the cop.'
-            Enabled: true
+            Enabled: pending
             VersionAdded: '%<version_added>s'
         YAML
 

data/lib/rubocop/cop/internal_affairs/offense_location_keyword.rb

@@ -28,7 +28,7 @@ module RuboCop
         def autocorrect(node)
           (*, keyword) = offending_location_argument(node.parent)
 
-          ->(corrector) { corrector.replace(node.source_range, ":#{keyword}") }
+          ->(corrector) { corrector.replace(node, ":#{keyword}") }
         end
 
         private

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

@@ -6,33 +6,76 @@ module RuboCop
       # Here we check if the elements of a multi-line array literal are
       # aligned.
       #
-      # @example
+      # @example EnforcedStyle: with_first_element (default)
+      #   # good
+      #
+      #   array = [1, 2, 3,
+      #            4, 5, 6]
+      #   array = ['run',
+      #            'forrest',
+      #            'run']
+      #
       #   # bad
-      #   a = [1, 2, 3,
+      #
+      #   array = [1, 2, 3,
       #     4, 5, 6]
       #   array = ['run',
       #        'forrest',
       #        'run']
       #
+      # @example EnforcedStyle: with_fixed_indentation
       #   # good
-      #   a = [1, 2, 3,
-      #        4, 5, 6]
-      #   a = ['run',
-      #        'forrest',
-      #        'run']
+      #
+      #   array = [1, 2, 3,
+      #     4, 5, 6]
+      #
+      #   # bad
+      #
+      #   array = [1, 2, 3,
+      #            4, 5, 6]
       class ArrayAlignment < Cop
         include Alignment
 
-        MSG = 'Align the elements of an array literal if they span more ' \
-              'than one line.'
+        ALIGN_ELEMENTS_MSG = 'Align the elements of an array literal ' \
+          'if they span more than one line.'
+
+        FIXED_INDENT_MSG = 'Use one level of indentation for elements ' \
+          'following the first line of a multi-line array.'
 
         def on_array(node)
-          check_alignment(node.children)
+          return if node.children.size < 2
+
+          check_alignment(node.children, base_column(node, node.children))
         end
 
         def autocorrect(node)
           AlignmentCorrector.correct(processed_source, node, column_delta)
         end
+
+        private
+
+        def message(_node)
+          fixed_indentation? ? FIXED_INDENT_MSG : ALIGN_ELEMENTS_MSG
+        end
+
+        def fixed_indentation?
+          cop_config['EnforcedStyle'] == 'with_fixed_indentation'
+        end
+
+        def base_column(node, args)
+          if fixed_indentation?
+            lineno = target_method_lineno(node)
+            line = node.source_range.source_buffer.source_line(lineno)
+            indentation_of_line = /\S.*/.match(line).begin(0)
+            indentation_of_line + configured_indentation_width
+          else
+            display_column(args.first.source_range)
+          end
+        end
+
+        def target_method_lineno(node)
+          node.loc.line
+        end
       end
     end
   end

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

@@ -52,9 +52,11 @@ module RuboCop
         end
 
         def delimiter_range(node)
-          Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                    node.children.last.loc.expression.end_pos,
-                                    node.loc.expression.end_pos)
+          Parser::Source::Range.new(
+            node.loc.expression.source_buffer,
+            node.children.compact.last.loc.expression.end_pos,
+            node.loc.expression.end_pos
+          )
         end
       end
     end

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

@@ -44,7 +44,7 @@ module RuboCop
             when :leading
               corrector.insert_before(selector_range(node), dot)
             when :trailing
-              corrector.insert_after(node.receiver.source_range, dot)
+              corrector.insert_after(node.receiver, dot)
             end
           end
         end

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

@@ -59,6 +59,14 @@ module RuboCop
           check_alignment(node.when_branches.last.loc.keyword, node.loc.else)
         end
 
+        def on_case_match(node)
+          return unless node.else?
+
+          check_alignment(
+            node.in_pattern_branches.last.loc.keyword, node.loc.else
+          )
+        end
+
         def autocorrect(node)
           AlignmentCorrector.correct(processed_source, node, column_delta)
         end