rubocop 0.89.1 → 0.90.0

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

@@ -16,9 +16,10 @@ module RuboCop
       #
       #   # bad
       #   %x(  ls -l )
-      class SpaceInsidePercentLiteralDelimiters < Cop
+      class SpaceInsidePercentLiteralDelimiters < Base
         include MatchRange
         include PercentLiteral
+        extend AutoCorrector
 
         MSG = 'Do not use spaces inside percent literal delimiters.'
         BEGIN_REGEX = /\A( +)/.freeze
@@ -36,21 +37,15 @@ module RuboCop
           add_offenses_for_unnecessary_spaces(node)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            regex_matches(node) do |match_range|
-              corrector.remove(match_range)
-            end
-          end
-        end
-
         private
 
         def add_offenses_for_unnecessary_spaces(node)
           return unless node.single_line?
 
           regex_matches(node) do |match_range|
-            add_offense(node, location: match_range)
+            add_offense(match_range) do |corrector|
+              corrector.remove(match_range)
+            end
           end
         end
 

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

@@ -17,7 +17,9 @@ module RuboCop
       #
       #   # good
       #   'a'..'z'
-      class SpaceInsideRangeLiteral < Cop
+      class SpaceInsideRangeLiteral < Base
+        extend AutoCorrector
+
         MSG = 'Space inside range literal.'
 
         def on_irange(node)
@@ -28,21 +30,6 @@ module RuboCop
           check(node)
         end
 
-        def autocorrect(node)
-          expression = node.source
-          operator = node.loc.operator.source
-          operator_escaped = operator.gsub(/\./, '\.')
-
-          lambda do |corrector|
-            corrector.replace(
-              node,
-              expression
-                .sub(/\s+#{operator_escaped}/, operator)
-                .sub(/#{operator_escaped}\s+/, operator)
-            )
-          end
-        end
-
         private
 
         def check(node)
@@ -55,7 +42,11 @@ module RuboCop
 
           return unless /(\s#{escaped_op})|(#{escaped_op}\s)/.match?(expression)
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            corrector.replace(
+              node, expression.sub(/\s+#{escaped_op}/, op).sub(/#{escaped_op}\s+/, op)
+            )
+          end
         end
       end
     end

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

@@ -53,9 +53,10 @@ module RuboCop
       #   # good
       #   foo[ ]
       #
-      class SpaceInsideReferenceBrackets < Cop
+      class SpaceInsideReferenceBrackets < Base
         include SurroundingSpace
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG = '%<command>s space inside reference brackets.'
         EMPTY_MSG = '%<command>s space inside empty reference brackets.'
@@ -83,24 +84,20 @@ module RuboCop
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            left, right = reference_brackets(node)
-
-            if empty_brackets?(left, right)
-              SpaceCorrector.empty_corrections(processed_source, corrector,
-                                               empty_config, left, right)
-            elsif style == :no_space
-              SpaceCorrector.remove_space(processed_source, corrector,
-                                          left, right)
-            else
-              SpaceCorrector.add_space(processed_source, corrector, left, right)
-            end
+        private
+
+        def autocorrect(corrector, node)
+          left, right = reference_brackets(node)
+
+          if empty_brackets?(left, right)
+            SpaceCorrector.empty_corrections(processed_source, corrector, empty_config, left, right)
+          elsif style == :no_space
+            SpaceCorrector.remove_space(processed_source, corrector, left, right)
+          else
+            SpaceCorrector.add_space(processed_source, corrector, left, right)
           end
         end
 
-        private
-
         def reference_brackets(node)
           tokens = tokens(node)
           left = left_ref_bracket(node, tokens)

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

@@ -18,11 +18,12 @@ module RuboCop
       #
       #   # good
       #      var = "This is the #{ space } example"
-      class SpaceInsideStringInterpolation < Cop
+      class SpaceInsideStringInterpolation < Base
         include Interpolation
         include SurroundingSpace
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
         NO_SPACE_MSG = 'Space inside string interpolation detected.'
         SPACE_MSG = 'Missing space inside string interpolation detected.'
@@ -40,20 +41,18 @@ module RuboCop
           end
         end
 
-        def autocorrect(begin_node)
-          lambda do |corrector|
-            delims = delimiters(begin_node)
+        private
+
+        def autocorrect(corrector, begin_node)
+          delims = delimiters(begin_node)
 
-            if style == :no_space
-              SpaceCorrector.remove_space(processed_source, corrector, *delims)
-            else
-              SpaceCorrector.add_space(processed_source, corrector, *delims)
-            end
+          if style == :no_space
+            SpaceCorrector.remove_space(processed_source, corrector, *delims)
+          else
+            SpaceCorrector.add_space(processed_source, corrector, *delims)
           end
         end
 
-        private
-
         def delimiters(begin_node)
           left = processed_source.tokens[index_of_first_token(begin_node)]
           right = processed_source.tokens[index_of_last_token(begin_node)]

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

@@ -37,11 +37,12 @@ module RuboCop
       #   class Foo; end
       #   # EOF
       #
-      class TrailingEmptyLines < Cop
+      class TrailingEmptyLines < Base
         include ConfigurableEnforcedStyle
         include RangeHelp
+        extend AutoCorrector
 
-        def investigate(processed_source)
+        def on_new_investigation
           buffer = processed_source.buffer
           return if buffer.source.empty?
 
@@ -57,28 +58,22 @@ module RuboCop
 
           return unless blank_lines != wanted_blank_lines
 
-          offense_detected(buffer, wanted_blank_lines, blank_lines,
-                           whitespace_at_end)
-        end
-
-        def autocorrect(range)
-          lambda do |corrector|
-            corrector.replace(range, style == :final_newline ? "\n" : "\n\n")
-          end
+          offense_detected(buffer, wanted_blank_lines, blank_lines, whitespace_at_end)
         end
 
         private
 
-        def offense_detected(buffer, wanted_blank_lines, blank_lines,
-                             whitespace_at_end)
+        def offense_detected(buffer, wanted_blank_lines, blank_lines, whitespace_at_end)
           begin_pos = buffer.source.length - whitespace_at_end.length
           autocorrect_range = range_between(begin_pos, buffer.source.length)
           begin_pos += 1 unless whitespace_at_end.empty?
           report_range = range_between(begin_pos, buffer.source.length)
 
-          add_offense(autocorrect_range,
-                      location: report_range,
-                      message: message(wanted_blank_lines, blank_lines))
+          add_offense(
+            report_range, message: message(wanted_blank_lines, blank_lines)
+          ) do |corrector|
+            corrector.replace(autocorrect_range, style == :final_newline ? "\n" : "\n\n")
+          end
         end
 
         def ends_in_end?(processed_source)

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

@@ -28,12 +28,13 @@ module RuboCop
       #     x = 0
       #   RUBY
       #
-      class TrailingWhitespace < Cop
+      class TrailingWhitespace < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Trailing whitespace detected.'
 
-        def investigate(processed_source)
+        def on_new_investigation
           heredoc_ranges = extract_heredoc_ranges(processed_source.ast)
           processed_source.lines.each_with_index do |line, index|
             lineno = index + 1
@@ -41,18 +42,13 @@ module RuboCop
             next unless line.end_with?(' ', "\t")
             next if skip_heredoc? && inside_heredoc?(heredoc_ranges, lineno)
 
-            range = source_range(processed_source.buffer,
-                                 lineno,
-                                 (line.rstrip.length)...(line.length))
-
-            add_offense(range, location: range)
+            range = offense_range(lineno, line)
+            add_offense(range) do |corrector|
+              corrector.remove(range)
+            end
           end
         end
 
-        def autocorrect(range)
-          ->(corrector) { corrector.remove(range) }
-        end
-
         private
 
         def skip_heredoc?
@@ -71,6 +67,10 @@ module RuboCop
             (body.first_line...body.last_line)
           end
         end
+
+        def offense_range(lineno, line)
+          source_range(processed_source.buffer, lineno, (line.rstrip.length)...(line.length))
+        end
       end
     end
   end

data/lib/rubocop/cop/lint/binary_operator_with_identical_operands.rb

@@ -35,7 +35,7 @@ module RuboCop
           return unless node.binary_operation?
 
           lhs, operation, rhs = *node
-          return if MATH_OPERATORS.include?(node.method_name) && rhs.basic_literal?
+          return if MATH_OPERATORS.include?(node.method_name) && lhs.basic_literal?
 
           add_offense(node, message: format(MSG, op: operation)) if lhs == rhs
         end

data/lib/rubocop/cop/lint/constant_resolution.rb

@@ -63,7 +63,7 @@ module RuboCop
         PATTERN
 
         def on_const(node)
-          return unless unqualified_const?(node)
+          return if !unqualified_const?(node) || node.parent&.defined_module
 
           add_offense(node)
         end

data/lib/rubocop/cop/lint/duplicate_require.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop checks for duplicate `require`s and `require_relative`s.
+      #
+      # @example
+      #   # bad
+      #   require 'foo'
+      #   require 'bar'
+      #   require 'foo'
+      #
+      #   # good
+      #   require 'foo'
+      #   require 'bar'
+      #
+      class DuplicateRequire < Base
+        MSG = 'Duplicate `%<method>s` detected.'
+        REQUIRE_METHODS = %i[require require_relative].freeze
+
+        def_node_matcher :require_call?, <<~PATTERN
+          (send {nil? (const _ :Kernel)} {:#{REQUIRE_METHODS.join(' :')}} _)
+        PATTERN
+
+        def on_new_investigation
+          # Holds the known required files for a given parent node (used as key)
+          @required = Hash.new { |h, k| h[k] = Set.new }.compare_by_identity
+          super
+        end
+
+        def on_send(node)
+          return unless REQUIRE_METHODS.include?(node.method_name) && require_call?(node)
+          return if @required[node.parent].add?(node.first_argument)
+
+          add_offense(node, message: format(MSG, method: node.method_name))
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/duplicate_rescue_exception.rb

@@ -43,17 +43,6 @@ module RuboCop
             end
           end
         end
-
-        private
-
-        def rescued_exceptions(resbody)
-          rescue_group, = *resbody
-          if rescue_group
-            rescue_group.values
-          else
-            []
-          end
-        end
       end
     end
   end

data/lib/rubocop/cop/lint/empty_file.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # This cop enforces that Ruby source files are not empty.
+      #
+      # @example
+      #   # bad
+      #   # Empty file
+      #
+      #   # good
+      #   # File containing non commented source lines
+      #
+      # @example AllowComments: true (default)
+      #   # good
+      #   # File consisting only of comments
+      #
+      # @example AllowComments: false
+      #   # bad
+      #   # File consisting only of comments
+      #
+      class EmptyFile < Base
+        include RangeHelp
+
+        MSG = 'Empty file detected.'
+
+        def on_new_investigation
+          return unless offending?
+
+          range = source_range(processed_source.buffer, 1, 0)
+          add_offense(range)
+        end
+
+        private
+
+        def offending?
+          empty_file? || (!cop_config['AllowComments'] && contains_only_comments?)
+        end
+
+        def empty_file?
+          processed_source.buffer.source.empty?
+        end
+
+        def contains_only_comments?
+          processed_source.lines.all? do |line|
+            line.blank? || comment_line?(line)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/missing_super.rb

@@ -56,8 +56,8 @@ module RuboCop
         def on_def(node)
           return unless offender?(node)
 
-          if node.method?(:initialize)
-            add_offense(node, message: CONSTRUCTOR_MSG) if inside_class_with_stateful_parent?(node)
+          if node.method?(:initialize) && inside_class_with_stateful_parent?(node)
+            add_offense(node, message: CONSTRUCTOR_MSG)
           elsif callback_method_def?(node)
             add_offense(node, message: CALLBACK_MSG)
           end

data/lib/rubocop/cop/lint/mixed_regexp_capture_types.rb

@@ -25,44 +25,11 @@ module RuboCop
               'in a Regexp literal.'
 
         def on_regexp(node)
-          return if contain_non_literal?(node)
-
-          begin
-            tree = Regexp::Parser.parse(node.content)
-          # Returns if a regular expression that cannot be processed by regexp_parser gem.
-          # https://github.com/rubocop-hq/rubocop/issues/8083
-          rescue Regexp::Scanner::ScannerError
-            return
-          end
-
-          return unless named_capture?(tree)
-          return unless numbered_capture?(tree)
+          return if node.each_capture(named: false).none?
+          return if node.each_capture(named: true).none?
 
           add_offense(node)
         end
-
-        private
-
-        def contain_non_literal?(node)
-          if node.respond_to?(:type) && (node.variable? || node.send_type? || node.const_type?)
-            return true
-          end
-          return false unless node.respond_to?(:children)
-
-          node.children.any? { |child| contain_non_literal?(child) }
-        end
-
-        def named_capture?(tree)
-          tree.each_expression.any? do |e|
-            e.instance_of?(Regexp::Expression::Group::Capture)
-          end
-        end
-
-        def numbered_capture?(tree)
-          tree.each_expression.any? do |e|
-            e.instance_of?(Regexp::Expression::Group::Named)
-          end
-        end
       end
     end
   end