rubocop 0.52.1 → 0.53.0

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

@@ -26,11 +26,13 @@ module RuboCop
       #   # good
       #   gem 'rubocop', groups: [:development, :test]
       class DuplicatedGem < Cop
+        include RangeHelp
+
         MSG = 'Gem `%<gem_name>s` requirements already given on line '\
           '%<line_of_first_occurrence>d of the Gemfile.'.freeze
 
         def investigate(processed_source)
-          return unless processed_source.ast
+          return if processed_source.blank?
 
           duplicated_gem_nodes.each do |nodes|
             nodes[1..-1].each do |node|

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

@@ -26,6 +26,8 @@ module RuboCop
       #   source 'https://rubygems.org' # strongly recommended
       #   source 'http://rubygems.org'
       class InsecureProtocolSource < Cop
+        include RangeHelp
+
         MSG = 'The source `:%<source>s` is deprecated because HTTP requests ' \
               'are insecure. ' \
               "Please change your source to 'https://rubygems.org' " \
@@ -42,7 +44,7 @@ module RuboCop
 
             add_offense(
               node,
-              location: source_range(node.first_argument.loc.expression),
+              location: range(node.first_argument.loc.expression),
               message: message
             )
           end
@@ -58,7 +60,7 @@ module RuboCop
 
         private
 
-        def source_range(node)
+        def range(node)
           range_between(node.begin_pos, node.end_pos)
         end
       end

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

@@ -33,7 +33,7 @@ module RuboCop
               'Gem `%<previous>s` should appear before `%<current>s`.'.freeze
 
         def investigate(processed_source)
-          return if processed_source.ast.nil?
+          return if processed_source.blank?
           gem_declarations(processed_source.ast)
             .each_cons(2) do |previous, current|
             next unless consecutive_lines(previous, current)

data/lib/rubocop/cop/commissioner.rb

@@ -52,12 +52,12 @@ module RuboCop
 
       def investigate(processed_source)
         reset_errors
-        remove_irrelevant_cops(processed_source.buffer.name)
+        remove_irrelevant_cops(processed_source.file_path)
         reset_callbacks
         prepare(processed_source)
         invoke_custom_processing(@cops, processed_source)
         invoke_custom_processing(@forces, processed_source)
-        walk(processed_source.ast) if processed_source.ast
+        walk(processed_source.ast) unless processed_source.blank?
         @cops.flat_map(&:offenses)
       end
 

data/lib/rubocop/cop/cop.rb

@@ -97,6 +97,8 @@ module RuboCop
 
         @offenses = []
         @corrections = []
+        @corrected_nodes = {}
+        @corrected_nodes.compare_by_identity
         @processed_source = nil
       end
 
@@ -145,7 +147,9 @@ module RuboCop
       def correct(node)
         return :unsupported unless support_autocorrect?
         return :uncorrected unless autocorrect?
+        return :already_corrected if @corrected_nodes.key?(node)
 
+        @corrected_nodes[node] = true
         correction = autocorrect(node)
         return :uncorrected unless correction
         @corrections << correction

data/lib/rubocop/cop/corrector.rb

@@ -33,7 +33,12 @@ module RuboCop
       def initialize(source_buffer, corrections = [])
         @source_buffer = source_buffer
         @corrections = corrections
-        @source_rewriter = Parser::Source::Rewriter.new(source_buffer)
+        @source_rewriter = Parser::Source::TreeRewriter.new(
+          source_buffer,
+          different_replacements: :raise,
+          swallowed_insertions: :raise,
+          crossing_deletions: :accept
+        )
 
         @diagnostics = []
         # Don't print warnings to stderr if corrections conflict with each other
@@ -75,6 +80,11 @@ module RuboCop
       # @param [Parser::Source::Range] range
       # @param [String] content
       def insert_before(range, content)
+        # TODO: Fix Cops using bad ranges instead
+        if range.end_pos > @source_buffer.source.size
+          range = range.with(end_pos: @source_buffer.source.size)
+        end
+
         @source_rewriter.insert_before(range, content)
       end
 

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

@@ -6,7 +6,7 @@ module RuboCop
     # the left or to the right, amount being determined by the instance
     # variable column_delta.
     class AlignmentCorrector
-      extend Util
+      extend RangeHelp
       extend Alignment
 
       class << self
@@ -45,7 +45,8 @@ module RuboCop
 
           if column_delta > 0
             unless range.source == "\n"
-              corrector.insert_before(range, ' ' * column_delta)
+              # TODO: Fix ranges instead of using `begin`
+              corrector.insert_before(range.begin, ' ' * column_delta)
             end
           elsif range.source =~ /\A[ \t]+\z/
             remove(range, corrector)
@@ -96,10 +97,6 @@ module RuboCop
           end
         end
 
-        def begins_its_line?(range)
-          (range.source_line =~ /\S/) == range.column
-        end
-
         def whitespace_range(node)
           begin_pos = node.loc.end.begin_pos
 

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This class handles autocorrection for code that needs to be moved
+    # to new lines.
+    class LineBreakCorrector
+      extend Alignment
+      extend TrailingBody
+      extend Util
+
+      class << self
+        attr_reader :processed_source
+
+        def correct_trailing_body(configured_width:, corrector:, node:,
+                                  processed_source:)
+          @processed_source = processed_source
+          range = first_part_of(node.to_a.last)
+          eol_comment = end_of_line_comment(node.source_range.line)
+
+          break_line_before(range: range, node: node, corrector: corrector,
+                            configured_width: configured_width)
+          move_comment(eol_comment: eol_comment, node: node,
+                       corrector: corrector)
+          remove_semicolon(node, corrector)
+        end
+
+        def break_line_before(range:, node:, corrector:, indent_steps: 1,
+                              configured_width:)
+          corrector.insert_before(
+            range,
+            "\n" + ' ' * (node.loc.keyword.column +
+                          indent_steps * configured_width)
+          )
+        end
+
+        def move_comment(eol_comment:, node:, corrector:)
+          return unless eol_comment
+          text = eol_comment.loc.expression.source
+          corrector.insert_before(node.source_range,
+                                  text + "\n" + (' ' * node.loc.keyword.column))
+          corrector.remove(eol_comment.loc.expression)
+        end
+
+        private
+
+        def remove_semicolon(node, corrector)
+          return unless semicolon(node)
+          corrector.remove(semicolon(node).pos)
+        end
+
+        def semicolon(node)
+          @semicolon ||= {}
+          @semicolon[node.object_id] ||= tokens(node).find(&:semicolon?)
+        end
+      end
+    end
+  end
+end

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

@@ -6,7 +6,7 @@ module RuboCop
     # on the same line as the last contained elements, or a new line.
     class MultilineLiteralBraceCorrector
       extend MultilineLiteralBraceLayout
-      extend Util
+      extend RangeHelp
 
       class << self
         attr_reader :processed_source

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

@@ -9,6 +9,19 @@ module RuboCop
       class << self
         attr_reader :processed_source
 
+        def empty_corrections(processed_source, corrector, empty_config,
+                              left_token, right_token)
+          @processed_source = processed_source
+          if offending_empty_space?(empty_config, left_token, right_token)
+            range = side_space_range(range: left_token.pos, side: :right)
+            corrector.remove(range)
+            corrector.insert_after(left_token.pos, ' ')
+          elsif offending_empty_no_space?(empty_config, left_token, right_token)
+            range = side_space_range(range: left_token.pos, side: :right)
+            corrector.remove(range)
+          end
+        end
+
         def remove_space(processed_source, corrector, left_token, right_token)
           @processed_source = processed_source
           if left_token.space_after?

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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     # This auto-corrects unused arguments.
     class UnusedArgCorrector
-      extend Util
+      extend RangeHelp
 
       class << self
         attr_reader :processed_source

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

@@ -35,6 +35,8 @@ module RuboCop
       #     spec.add_runtime_dependency('parser', '>= 2.3.3.1', '< 3.0')
       #   end
       class DuplicatedAssignment < Cop
+        include RangeHelp
+
         MSG = '`%<assignment>s` method calls already given on line '\
               '%<line_of_first_occurrence>d of the gemspec.'.freeze
 
@@ -53,7 +55,7 @@ module RuboCop
         PATTERN
 
         def investigate(processed_source)
-          return unless processed_source.ast
+          return if processed_source.blank?
 
           duplicated_assignment_method_nodes.each do |nodes|
             nodes[1..-1].each do |node|

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

@@ -60,7 +60,7 @@ module RuboCop
               .freeze
 
         def investigate(processed_source)
-          return if processed_source.ast.nil?
+          return if processed_source.blank?
           dependency_declarations(processed_source.ast)
             .each_cons(2) do |previous, current|
             next unless consecutive_lines(previous, current)

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

@@ -38,8 +38,8 @@ module RuboCop
       class RequiredRubyVersion < Cop
         MSG = '`required_ruby_version` (%<required_ruby_version>s, ' \
               'declared in %<gemspec_filename>s) and `TargetRubyVersion` ' \
-              '(%<target_ruby_version>s, declared in .rubocop.yml) ' \
-              'should be equal.'.freeze
+              '(%<target_ruby_version>s, which may be specified in ' \
+              '.rubocop.yml) should be equal.'.freeze
 
         def_node_search :required_ruby_version, <<-PATTERN
           (send _ :required_ruby_version= ${(str _) (array (str _))})
@@ -72,12 +72,10 @@ module RuboCop
         end
 
         def message(required_ruby_version, target_ruby_version)
-          file_path = processed_source.buffer.name
-
           format(
             MSG,
             required_ruby_version: required_ruby_version,
-            gemspec_filename: File.basename(file_path),
+            gemspec_filename: File.basename(processed_source.file_path),
             target_ruby_version: target_ruby_version
           )
         end

data/lib/rubocop/cop/generator.rb

@@ -14,25 +14,45 @@ module RuboCop
         module RuboCop
           module Cop
             module %<department>s
-              # TODO: Write cop description and example of bad / good code.
+              # TODO: Write cop description and example of bad / good code. For every
+              # `SupportedStyle` and unique configuration, there needs to be examples.
+              # Examples must have valid Ruby syntax. Do not use upticks.
+              #
+              # @example EnforcedStyle: bar (default)
+              #   # Description of the `bar` style.
+              #
+              #   # bad
+              #   bad_bar_method
+              #
+              #   # bad
+              #   bad_bar_method(args)
+              #
+              #   # good
+              #   good_bar_method
+              #
+              #   # good
+              #   good_bar_method(args)
+              #
+              # @example EnforcedStyle: foo
+              #   # Description of the `foo` style.
               #
-              # @example
               #   # bad
-              #   bad_method()
+              #   bad_foo_method
               #
               #   # bad
-              #   bad_method(args)
+              #   bad_foo_method(args)
               #
               #   # good
-              #   good_method()
+              #   good_foo_method
               #
               #   # good
-              #   good_method(args)
+              #   good_foo_method(args)
+              #
               class %<cop_name>s < Cop
-                # TODO: Implement the cop into here.
+                # TODO: Implement the cop in here.
                 #
                 # In many cases, you can use a node matcher for matching node pattern.
-                # See. https://github.com/bbatsov/rubocop/blob/master/lib/rubocop/node_pattern.rb
+                # See https://github.com/bbatsov/rubocop/blob/master/lib/rubocop/node_pattern.rb
                 #
                 # For example
                 MSG = 'Use `#good_method` instead of `#bad_method`.'.freeze
@@ -43,6 +63,7 @@ module RuboCop
 
                 def on_send(node)
                   return unless bad_method?(node)
+
                   add_offense(node)
                 end
               end

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

@@ -17,6 +17,8 @@ module RuboCop
       #   add_offense(node, location: :selector)
       #
       class RedundantLocationArgument < Cop
+        include RangeHelp
+
         MSG = 'Redundant location argument to `#add_offense`.'.freeze
 
         def_node_matcher :add_offense_kwargs, <<-PATTERN

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

@@ -20,6 +20,8 @@ module RuboCop
       #   add_offense(node, message: message(other_node))
       #
       class RedundantMessageArgument < Cop
+        include RangeHelp
+
         MSG = 'Redundant message argument to `#add_offense`.'.freeze
 
         def_node_matcher :node_type_check, <<-PATTERN

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

@@ -19,86 +19,155 @@ module RuboCop
       #   - ignore_implicit (without curly braces)
       #   - ignore_explicit (with curly braces)
       #
-      # @example
-      #
-      #   # EnforcedHashRocketStyle: key (default)
-      #   # EnforcedColonStyle: key (default)
-      #
-      #   # good
+      # @example EnforcedHashRocketStyle: key (default)
+      #   # bad
       #   {
-      #     foo: bar,
-      #     ba: baz
+      #     :foo => bar,
+      #      :ba => baz
       #   }
+      #
+      #   # good
       #   {
       #     :foo => bar,
       #     :ba => baz
       #   }
       #
+      # @example EnforcedHashRocketStyle: separator
       #   # bad
       #   {
-      #     foo: bar,
-      #      ba: baz
+      #     :foo => bar,
+      #     :ba => baz
       #   }
       #   {
       #     :foo => bar,
-      #      :ba => baz
+      #     :ba  => baz
       #   }
       #
-      # @example
-      #
-      #   # EnforcedHashRocketStyle: separator
-      #   # EnforcedColonStyle: separator
-      #
-      #   #good
-      #   {
-      #     foo: bar,
-      #      ba: baz
-      #   }
+      #   # good
       #   {
       #     :foo => bar,
       #      :ba => baz
       #   }
       #
-      #   #bad
-      #   {
-      #     foo: bar,
-      #     ba: baz
-      #   }
+      # @example EnforcedHashRocketStyle: table
+      #   # bad
       #   {
       #     :foo => bar,
-      #     :ba => baz
+      #      :ba => baz
       #   }
+      #
+      #   # good
       #   {
       #     :foo => bar,
       #     :ba  => baz
       #   }
       #
-      # @example
+      # @example EnforcedColonStyle: key (default)
+      #   # bad
+      #   {
+      #     foo: bar,
+      #      ba: baz
+      #   }
       #
-      #   # EnforcedHashRocketStyle: table
-      #   # EnforcedColonStyle: table
+      #   # good
+      #   {
+      #     foo: bar,
+      #     ba: baz
+      #   }
       #
-      #   #good
+      # @example EnforcedColonStyle: separator
+      #   # bad
       #   {
       #     foo: bar,
-      #     ba:  baz
+      #     ba: baz
       #   }
+      #
+      #   # good
       #   {
-      #     :foo => bar,
-      #     :ba  => baz
+      #     foo: bar,
+      #      ba: baz
       #   }
       #
-      #   #bad
+      # @example EnforcedColonStyle: table
+      #   # bad
       #   {
       #     foo: bar,
       #     ba: baz
       #   }
+      #
+      #   # good
       #   {
-      #     :foo => bar,
-      #      :ba => baz
+      #     foo: bar,
+      #     ba:  baz
       #   }
+      #
+      # @example EnforcedLastArgumentHashStyle: always_inspect (default)
+      #   # Inspect both implicit and explicit hashes.
+      #
+      #   # bad
+      #   do_something(foo: 1,
+      #     bar: 2)
+      #
+      #   # bad
+      #   do_something({foo: 1,
+      #     bar: 2})
+      #
+      #   # good
+      #   do_something(foo: 1,
+      #                bar: 2)
+      #
+      #   # good
+      #   do_something(
+      #     foo: 1,
+      #     bar: 2
+      #   )
+      #
+      #   # good
+      #   do_something({foo: 1,
+      #                 bar: 2})
+      #
+      #   # good
+      #   do_something({
+      #     foo: 1,
+      #     bar: 2
+      #   })
+      #
+      # @example EnforcedLastArgumentHashStyle: always_ignore
+      #   # Ignore both implicit and explicit hashes.
+      #
+      #   # good
+      #   do_something(foo: 1,
+      #     bar: 2)
+      #
+      #   # good
+      #   do_something({foo: 1,
+      #     bar: 2})
+      #
+      # @example EnforcedLastArgumentHashStyle: ignore_implicit
+      #   # Ignore only implicit hashes.
+      #
+      #   # bad
+      #   do_something({foo: 1,
+      #     bar: 2})
+      #
+      #   # good
+      #   do_something(foo: 1,
+      #     bar: 2)
+      #
+      # @example EnforcedLastArgumentHashStyle: ignore_explicit
+      #   # Ignore only explicit hashes.
+      #
+      #   # bad
+      #   do_something(foo: 1,
+      #     bar: 2)
+      #
+      #   # good
+      #   do_something({foo: 1,
+      #     bar: 2})
+      #
       class AlignHash < Cop
         include HashAlignment
+        include RangeHelp
 
         MSG = 'Align the elements of a hash literal if they span more than ' \
               'one line.'.freeze