rubocop 0.52.0 → 0.52.1

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This class does condition auto-correction
+    class ConditionCorrector
+      class << self
+        def correct_negative_condition(node)
+          condition = negated_condition(node)
+
+          lambda do |corrector|
+            corrector.replace(node.loc.keyword, node.inverse_keyword)
+            corrector.replace(condition.source_range,
+                              condition.children.first.source)
+          end
+        end
+
+        private
+
+        def negated_condition(node)
+          condition = node.condition
+          condition = condition.children.first while condition.begin_type?
+          condition
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This class does empty line auto-correction
+    class EmptyLineCorrector
+      class << self
+        def correct(node)
+          offense_style, range = node
+          lambda do |corrector|
+            case offense_style
+            when :no_empty_lines then
+              corrector.remove(range)
+            when :empty_lines then
+              corrector.insert_before(range, "\n")
+            end
+          end
+        end
+
+        def insert_before(node)
+          ->(corrector) { corrector.insert_before(node.source_range, "\n") }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Autocorrection logic for the closing brace of a literal either
+    # on the same line as the last contained elements, or a new line.
+    class MultilineLiteralBraceCorrector
+      extend MultilineLiteralBraceLayout
+      extend Util
+
+      class << self
+        attr_reader :processed_source
+
+        # rubocop:disable Metrics/MethodLength
+        def correct(processed_source, node)
+          @processed_source = processed_source
+          if closing_brace_on_same_line?(node)
+            lambda do |corrector|
+              corrector.insert_before(node.loc.end, "\n".freeze)
+            end
+          else
+            # When a comment immediately before the closing brace gets in the
+            # way of an easy correction, the offense is reported but not auto-
+            # corrected. The user must handle the delicate decision of where to
+            # put the comment.
+            return if new_line_needed_before_closing_brace?(node)
+
+            lambda do |corrector|
+              corrector.remove(range_with_surrounding_space(range: node.loc.end,
+                                                            side: :left))
+
+              corrector.insert_after(
+                last_element_range_with_trailing_comma(node),
+                node.loc.end.source
+              )
+            end
+          end
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        private
+
+        def last_element_range_with_trailing_comma(node)
+          trailing_comma_range = last_element_trailing_comma_range(node)
+          if trailing_comma_range
+            children(node).last.source_range.join(trailing_comma_range)
+          else
+            children(node).last.source_range
+          end
+        end
+
+        def last_element_trailing_comma_range(node)
+          range = range_with_surrounding_space(
+            range: children(node).last.source_range,
+            side: :right
+          ).end.resize(1)
+          range.source == ',' ? range : nil
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This auto-corrects gem dependency order
+    class OrderedGemCorrector
+      extend OrderedGemNode
+
+      class << self
+        attr_reader :processed_source, :comments_as_separators
+
+        def correct(processed_source, node,
+                    previous_declaration, comments_as_separators)
+          @processed_source = processed_source
+          @comments_as_separators = comments_as_separators
+
+          current_range = declaration_with_comment(node)
+          previous_range = declaration_with_comment(previous_declaration)
+
+          lambda do |corrector|
+            swap_range(corrector, current_range, previous_range)
+          end
+        end
+
+        private
+
+        def declaration_with_comment(node)
+          buffer = processed_source.buffer
+          begin_pos = get_source_range(node, comments_as_separators).begin_pos
+          end_line = buffer.line_for_position(node.loc.expression.end_pos)
+          end_pos = buffer.line_range(end_line).end_pos
+          Parser::Source::Range.new(buffer, begin_pos, end_pos)
+        end
+
+        def swap_range(corrector, range1, range2)
+          src1 = range1.source
+          src2 = range2.source
+          corrector.replace(range1, src2)
+          corrector.replace(range2, src1)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This auto-corrects parentheses
+    class ParenthesesCorrector
+      class << self
+        def correct(node)
+          lambda do |corrector|
+            corrector.remove(node.loc.begin)
+            corrector.remove(node.loc.end)
+
+            if ternary_condition?(node) && next_char_is_question_mark?(node)
+              corrector.insert_after(node.loc.end, ' ')
+            end
+          end
+        end
+
+        private
+
+        def ternary_condition?(node)
+          node.parent && node.parent.if_type? && node.parent.ternary?
+        end
+
+        def next_char_is_question_mark?(node)
+          node.loc.last_column == node.parent.loc.question.column
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This auto-corrects punctuation
+    class PunctuationCorrector
+      class << self
+        def remove_space(space_before)
+          ->(corrector) { corrector.remove(space_before) }
+        end
+
+        def add_space(token)
+          ->(corrector) { corrector.replace(token.pos, token.pos.source + ' ') }
+        end
+
+        def swap_comma(range)
+          return unless range
+
+          lambda do |corrector|
+            case range.source
+            when ',' then corrector.remove(range)
+            else          corrector.insert_after(range, ',')
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This auto-corrects whitespace
+    class SpaceCorrector
+      extend SurroundingSpace
+
+      class << self
+        attr_reader :processed_source
+
+        def remove_space(processed_source, corrector, left_token, right_token)
+          @processed_source = processed_source
+          if left_token.space_after?
+            range = side_space_range(range: left_token.pos, side: :right)
+            corrector.remove(range)
+          end
+          return unless right_token.space_before?
+          range = side_space_range(range: right_token.pos, side: :left)
+          corrector.remove(range)
+        end
+
+        def add_space(processed_source, corrector, left_token, right_token)
+          @processed_source = processed_source
+          unless left_token.space_after?
+            corrector.insert_after(left_token.pos, ' ')
+          end
+          return if right_token.space_before?
+          corrector.insert_before(right_token.pos, ' ')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This auto-corrects string literals
+    class StringLiteralCorrector
+      extend Util
+
+      class << self
+        def correct(node, style)
+          return if node.dstr_type?
+
+          lambda do |corrector|
+            str = node.str_content
+            if style == :single_quotes
+              corrector.replace(node.source_range, to_string_literal(str))
+            else
+              corrector.replace(node.source_range, str.inspect)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # This auto-corrects unused arguments.
+    class UnusedArgCorrector
+      extend Util
+
+      class << self
+        attr_reader :processed_source
+
+        def correct(processed_source, node)
+          return if %i[kwarg kwoptarg].include?(node.type)
+
+          @processed_source = processed_source
+
+          if node.blockarg_type?
+            lambda do |corrector|
+              range = range_with_surrounding_space(range: node.source_range,
+                                                   side: :left)
+              range = range_with_surrounding_comma(range, :left)
+              corrector.remove(range)
+            end
+          else
+            ->(corrector) { corrector.insert_before(node.loc.name, '_') }
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -60,7 +60,7 @@ module RuboCop
               register_offense(
                 node,
                 node.method_name,
-                nodes.first.loc.line
+                nodes.first.first_line
               )
             end
           end
@@ -88,7 +88,7 @@ module RuboCop
         def register_offense(node, assignment, line_of_first_occurrence)
           line_range = node.loc.column...node.loc.last_column
           offense_location =
-            source_range(processed_source.buffer, node.loc.line, line_range)
+            source_range(processed_source.buffer, node.first_line, line_range)
           message = format(
             MSG,
             assignment: assignment,

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

@@ -76,6 +76,15 @@ module RuboCop
           end
         end
 
+        def autocorrect(node)
+          OrderedGemCorrector.correct(
+            processed_source,
+            node,
+            previous_declaration(node),
+            treat_comments_as_separators
+          )
+        end
+
         private
 
         def previous_declaration(node)

data/lib/rubocop/cop/generator.rb

@@ -54,7 +54,7 @@ module RuboCop
       SPEC_TEMPLATE = <<-SPEC.strip_indent
         # frozen_string_literal: true
 
-        describe RuboCop::Cop::%<department>s::%<cop_name>s do
+        RSpec.describe RuboCop::Cop::%<department>s::%<cop_name>s do
           subject(:cop) { described_class.new(config) }
 
           let(:config) { RuboCop::Config.new }
@@ -77,9 +77,9 @@ module RuboCop
         end
       SPEC
 
-      def initialize(name)
+      def initialize(name, output: $stdout)
         @badge = Badge.parse(name)
-
+        @output = output
         return if badge.qualified?
 
         raise ArgumentError, 'Specify a cop name with Department/Name style'
@@ -93,12 +93,15 @@ module RuboCop
         write_unless_file_exists(spec_path, generated_spec)
       end
 
-      def inject_require
-        RequireFileInjector.new(require_path).inject
+      def inject_require(root_file_path: 'lib/rubocop.rb')
+        RequireFileInjector.new(
+          source_path: source_path,
+          root_file_path: root_file_path
+        ).inject
       end
 
-      def inject_config(path = 'config/enabled.yml')
-        config = File.readlines(path)
+      def inject_config(config_file_path: 'config/enabled.yml')
+        config = File.readlines(config_file_path)
         content = <<-YAML.strip_indent
           #{badge}:
             Description: 'TODO: Write a description of the cop.'
@@ -110,19 +113,15 @@ module RuboCop
           break index - 1 if badge.to_s < line
         end
         config.insert(target_line, content)
-        File.write(path, config.join)
+        File.write(config_file_path, config.join)
+        output.puts <<-MESSAGE.strip_indent
+          [modify] A configuration for the cop is added into #{config_file_path}.
+                   If you want to disable the cop by default, move the added config to config/disabled.yml
+        MESSAGE
       end
 
       def todo
         <<-TODO.strip_indent
-          Files created:
-            - #{source_path}
-            - #{spec_path}
-          File modified:
-            - `require_relative '#{require_path}'` added into lib/rubocop.rb
-            - A configuration for the cop is added into config/enabled.yml
-              - If you want to disable the cop by default, move the added config to config/disabled.yml
-
           Do 3 steps:
             1. Add an entry to the "New features" section in CHANGELOG.md,
                e.g. "Add new `#{badge}` cop. ([@your_id][])"
@@ -133,7 +132,7 @@ module RuboCop
 
       private
 
-      attr_reader :badge
+      attr_reader :badge, :output
 
       def write_unless_file_exists(path, contents)
         if File.exist?(path)
@@ -145,6 +144,7 @@ module RuboCop
         FileUtils.mkdir_p(dir) unless File.exist?(dir)
 
         File.write(path, contents)
+        output.puts "[create] #{path}"
       end
 
       def generated_source
@@ -159,10 +159,6 @@ module RuboCop
         format(template, department: badge.department, cop_name: badge.cop_name)
       end
 
-      def require_path
-        source_path.sub('lib/', '').sub('.rb', '')
-      end
-
       def spec_path
         File.join(
           'spec',
@@ -184,77 +180,12 @@ module RuboCop
       end
 
       def snake_case(camel_case_string)
+        return 'rspec' if camel_case_string == 'RSpec'
         camel_case_string
           .gsub(/([^A-Z])([A-Z]+)/, '\1_\2')
           .gsub(/([A-Z])([A-Z][^A-Z\d]+)/, '\1_\2')
           .downcase
       end
-
-      # A class that injects a require directive into the root RuboCop file.
-      # It looks for other directives that require files in the same (cop)
-      # namespace and injects the provided one in alpha
-      class RequireFileInjector
-        REQUIRE_PATH = /require_relative ['"](.+)['"]/
-
-        def initialize(require_path)
-          @require_path    = require_path
-          @require_entries = File.readlines(rubocop_root_file_path)
-        end
-
-        def inject
-          return if require_exists? || !target_line
-
-          File.write(rubocop_root_file_path, updated_directives)
-        end
-
-        private
-
-        attr_reader :require_path, :require_entries
-
-        def rubocop_root_file_path
-          File.join('lib', 'rubocop.rb')
-        end
-
-        def require_exists?
-          require_entries.any? do |entry|
-            entry == injectable_require_directive
-          end
-        end
-
-        def updated_directives
-          require_entries.insert(target_line,
-                                 injectable_require_directive).join
-        end
-
-        def target_line
-          @target_line ||= begin
-            in_the_same_department = false
-            inject_parts = require_path_fragments(injectable_require_directive)
-
-            require_entries.find.with_index do |entry, index|
-              current_entry_parts = require_path_fragments(entry)
-
-              if inject_parts[0..-2] == current_entry_parts[0..-2]
-                in_the_same_department = true
-
-                break index if inject_parts.last < current_entry_parts.last
-              elsif in_the_same_department
-                break index
-              end
-            end
-          end
-        end
-
-        def require_path_fragments(require_directove)
-          path = require_directove.match(REQUIRE_PATH)
-
-          path ? path.captures.first.split('/') : []
-        end
-
-        def injectable_require_directive
-          "require_relative '#{require_path}'\n"
-        end
-      end
     end
   end
 end