rubocop 0.78.0 → 1.13.0

data/lib/rubocop/cop/style/special_global_vars.rb

@@ -26,10 +26,6 @@ module RuboCop
       #   puts $LAST_MATCH_INFO
       #   puts $IGNORECASE
       #   puts $ARGV # or ARGV
-      #   puts $MATCH
-      #   puts $PREMATCH
-      #   puts $POSTMATCH
-      #   puts $LAST_PAREN_MATCH
       #
       # @example EnforcedStyle: use_perl_names
       #   # good
@@ -51,13 +47,10 @@ module RuboCop
       #   puts $~
       #   puts $=
       #   puts $*
-      #   puts $&
-      #   puts $`
-      #   puts $'
-      #   puts $+
       #
-      class SpecialGlobalVars < Cop
+      class SpecialGlobalVars < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG_BOTH = 'Prefer `%<prefer>s` from the stdlib \'English\' ' \
         'module (don\'t forget to require it) or `%<regular>s` over ' \
@@ -84,32 +77,18 @@ module RuboCop
           :$? => [:$CHILD_STATUS],
           :$~ => [:$LAST_MATCH_INFO],
           :$= => [:$IGNORECASE],
-          :$* => %i[$ARGV ARGV],
-          :$& => [:$MATCH],
-          :$` => [:$PREMATCH],
-          :$' => [:$POSTMATCH],
-          :$+ => [:$LAST_PAREN_MATCH]
+          :$* => %i[$ARGV ARGV]
         }
 
-        PERL_VARS =
-          Hash[ENGLISH_VARS.flat_map { |k, vs| vs.map { |v| [v, [k]] } }]
+        PERL_VARS = ENGLISH_VARS.flat_map { |k, vs| vs.map { |v| [v, [k]] } }.to_h
 
-        ENGLISH_VARS.merge!(
-          Hash[ENGLISH_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }]
-        )
-        PERL_VARS.merge!(
-          Hash[PERL_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }]
-        )
+        ENGLISH_VARS.merge!(ENGLISH_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }.to_h)
+        PERL_VARS.merge!(PERL_VARS.flat_map { |_, vs| vs.map { |v| [v, [v]] } }.to_h)
         ENGLISH_VARS.each_value(&:freeze).freeze
         PERL_VARS.each_value(&:freeze).freeze
 
         # Anything *not* in this set is provided by the English library.
-        NON_ENGLISH_VARS = Set.new(%i[
-                                     $LOAD_PATH
-                                     $LOADED_FEATURES
-                                     $PROGRAM_NAME
-                                     ARGV
-                                   ]).freeze
+        NON_ENGLISH_VARS = Set.new(%i[$LOAD_PATH $LOADED_FEATURES $PROGRAM_NAME ARGV]).freeze
 
         def on_gvar(node)
           global_var, = *node
@@ -120,33 +99,25 @@ module RuboCop
             correct_style_detected
           else
             opposite_style_detected
-            add_offense(node)
+
+            add_offense(node, message: message(global_var)) do |corrector|
+              autocorrect(corrector, node, global_var)
+            end
           end
         end
 
-        def message(node)
-          global_var, = *node
-
+        def message(global_var)
           if style == :use_english_names
             format_english_message(global_var)
           else
-            format(MSG_REGULAR,
-                   prefer: preferred_names(global_var).first,
-                   global: global_var)
+            format(MSG_REGULAR, prefer: preferred_names(global_var).first, global: global_var)
           end
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            global_var, = *node
-
-            while node.parent&.begin_type? &&
-                  node.parent.children.one?
-              node = node.parent
-            end
+        def autocorrect(corrector, node, global_var)
+          node = node.parent while node.parent&.begin_type? && node.parent.children.one?
 
-            corrector.replace(node.source_range, replacement(node, global_var))
-          end
+          corrector.replace(node, replacement(node, global_var))
         end
 
         private
@@ -181,13 +152,9 @@ module RuboCop
           parent_type = node.parent&.type
           preferred_name = preferred_names(global_var).first
 
-          unless %i[dstr xstr regexp].include?(parent_type)
-            return preferred_name.to_s
-          end
+          return preferred_name.to_s unless %i[dstr xstr regexp].include?(parent_type)
 
-          if style == :use_english_names
-            return english_name_replacement(preferred_name, node)
-          end
+          return english_name_replacement(preferred_name, node) if style == :use_english_names
 
           "##{preferred_name}"
         end

data/lib/rubocop/cop/style/stabby_lambda_parentheses.rb

@@ -19,25 +19,25 @@ module RuboCop
       #
       #   # good
       #   ->a,b,c { a + b + c}
-      class StabbyLambdaParentheses < Cop
+      class StabbyLambdaParentheses < Base
         include ConfigurableEnforcedStyle
+        extend AutoCorrector
 
         MSG_REQUIRE = 'Wrap stabby lambda arguments with parentheses.'
-        MSG_NO_REQUIRE = 'Do not wrap stabby lambda arguments ' \
-                         'with parentheses.'
+        MSG_NO_REQUIRE = 'Do not wrap stabby lambda arguments with parentheses.'
         def on_send(node)
           return unless stabby_lambda_with_args?(node)
-          return unless redundant_parentheses?(node) ||
-                        missing_parentheses?(node)
+          return unless redundant_parentheses?(node) || missing_parentheses?(node)
 
-          add_offense(node.block_node.arguments)
-        end
+          arguments = node.block_node.arguments
 
-        def autocorrect(node)
-          if style == :require_parentheses
-            missing_parentheses_corrector(node)
-          elsif style == :require_no_parentheses
-            unwanted_parentheses_corrector(node)
+          add_offense(arguments) do |corrector|
+            case style
+            when :require_parentheses
+              missing_parentheses_corrector(corrector, arguments)
+            when :require_no_parentheses
+              unwanted_parentheses_corrector(corrector, arguments)
+            end
           end
         end
 
@@ -55,22 +55,15 @@ module RuboCop
           style == :require_parentheses ? MSG_REQUIRE : MSG_NO_REQUIRE
         end
 
-        def missing_parentheses_corrector(node)
-          lambda do |corrector|
-            args_loc = node.loc.expression
-
-            corrector.insert_before(args_loc, '(')
-            corrector.insert_after(args_loc, ')')
-          end
+        def missing_parentheses_corrector(corrector, node)
+          corrector.wrap(node, '(', ')')
         end
 
-        def unwanted_parentheses_corrector(node)
-          lambda do |corrector|
-            args_loc = node.loc
+        def unwanted_parentheses_corrector(corrector, node)
+          args_loc = node.loc
 
-            corrector.replace(args_loc.begin, '')
-            corrector.remove(args_loc.end)
-          end
+          corrector.replace(args_loc.begin, '')
+          corrector.remove(args_loc.end)
         end
 
         def stabby_lambda_with_args?(node)

data/lib/rubocop/cop/style/static_class.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for places where classes with only class methods can be
+      # replaced with a module. Classes should be used only when it makes sense to create
+      # instances out of them.
+      #
+      # This cop is marked as unsafe, because it is possible that this class is a parent
+      # for some other subclass, monkey-patched with instance methods or
+      # a dummy instance is instantiated from it somewhere.
+      #
+      # @example
+      #   # bad
+      #   class SomeClass
+      #     def self.some_method
+      #       # body omitted
+      #     end
+      #
+      #     def self.some_other_method
+      #       # body omitted
+      #     end
+      #   end
+      #
+      #   # good
+      #   module SomeModule
+      #     module_function
+      #
+      #     def some_method
+      #       # body omitted
+      #     end
+      #
+      #     def some_other_method
+      #       # body omitted
+      #     end
+      #   end
+      #
+      #   # good - has instance method
+      #   class SomeClass
+      #     def instance_method; end
+      #     def self.class_method; end
+      #   end
+      #
+      class StaticClass < Base
+        include VisibilityHelp
+
+        MSG = 'Prefer modules to classes with only class methods.'
+
+        def on_class(class_node)
+          return if class_node.parent_class
+
+          add_offense(class_node) if class_convertible_to_module?(class_node)
+        end
+
+        private
+
+        def class_convertible_to_module?(class_node)
+          nodes = class_elements(class_node)
+          return false if nodes.empty?
+
+          nodes.all? do |node|
+            node_visibility(node) == :public &&
+              node.defs_type? ||
+              sclass_convertible_to_module?(node) ||
+              node.equals_asgn? ||
+              extend_call?(node)
+          end
+        end
+
+        def extend_call?(node)
+          node.send_type? && node.method?(:extend)
+        end
+
+        def sclass_convertible_to_module?(node)
+          return false unless node.sclass_type?
+
+          class_elements(node).all? do |child|
+            node_visibility(child) == :public && (child.def_type? || child.equals_asgn?)
+          end
+        end
+
+        def class_elements(class_node)
+          class_def = class_node.body
+
+          if !class_def
+            []
+          elsif class_def.begin_type?
+            class_def.children
+          else
+            [class_def]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/stderr_puts.rb

@@ -14,15 +14,17 @@ module RuboCop
       #   # good
       #   warn('hello')
       #
-      class StderrPuts < Cop
+      class StderrPuts < Base
         include RangeHelp
+        extend AutoCorrector
 
-        MSG =
-          'Use `warn` instead of `%<bad>s` to allow such output to be disabled.'
+        MSG = 'Use `warn` instead of `%<bad>s` to allow such output to be disabled.'
+        RESTRICT_ON_SEND = %i[puts].freeze
 
+        # @!method stderr_puts?(node)
         def_node_matcher :stderr_puts?, <<~PATTERN
           (send
-            {(gvar #stderr_gvar?) (const nil? :STDERR)}
+            {(gvar #stderr_gvar?) (const {nil? cbase} :STDERR)}
             :puts $_
             ...)
         PATTERN
@@ -30,11 +32,8 @@ module RuboCop
         def on_send(node)
           return unless stderr_puts?(node)
 
-          add_offense(node, location: stderr_puts_range(node))
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
+          message = message(node)
+          add_offense(stderr_puts_range(node), message: message) do |corrector|
             corrector.replace(stderr_puts_range(node), 'warn')
           end
         end
@@ -50,10 +49,7 @@ module RuboCop
         end
 
         def stderr_puts_range(send)
-          range_between(
-            send.loc.expression.begin_pos,
-            send.loc.selector.end_pos
-          )
+          range_between(send.loc.expression.begin_pos, send.loc.selector.end_pos)
         end
       end
     end

data/lib/rubocop/cop/style/string_chars.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of `String#split` with empty string or regexp literal argument.
+      #
+      # This cop is marked as unsafe. But probably it's quite unlikely that some other class would
+      # define a `split` method that takes exactly the same arguments.
+      #
+      # @example
+      #   # bad
+      #   string.split(//)
+      #   string.split('')
+      #
+      #   # good
+      #   string.chars
+      #
+      class StringChars < Base
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `chars` instead of `%<current>s`.'
+        RESTRICT_ON_SEND = %i[split].freeze
+        BAD_ARGUMENTS = %w[// '' ""].freeze
+
+        def on_send(node)
+          return unless node.arguments.one? && BAD_ARGUMENTS.include?(node.first_argument.source)
+
+          range = range_between(node.loc.selector.begin_pos, node.source_range.end_pos)
+
+          add_offense(range, message: format(MSG, current: range.source)) do |corrector|
+            corrector.replace(range, 'chars')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/style/string_concatenation.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for places where string concatenation
+      # can be replaced with string interpolation.
+      #
+      # The cop can autocorrect simple cases but will skip autocorrecting
+      # more complex cases where the resulting code would be harder to read.
+      # In those cases, it might be useful to extract statements to local
+      # variables or methods which you can then interpolate in a string.
+      #
+      # NOTE: When concatenation between two strings is broken over multiple
+      # lines, this cop does not register an offense; instead,
+      # `Style/LineEndConcatenation` will pick up the offense if enabled.
+      #
+      # @example
+      #   # bad
+      #   email_with_name = user.name + ' <' + user.email + '>'
+      #
+      #   # good
+      #   email_with_name = "#{user.name} <#{user.email}>"
+      #   email_with_name = format('%s <%s>', user.name, user.email)
+      #
+      #   # accepted, line-end concatenation
+      #   name = 'First' +
+      #     'Last'
+      #
+      class StringConcatenation < Base
+        include Util
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Prefer string interpolation to string concatenation.'
+        RESTRICT_ON_SEND = %i[+].freeze
+
+        # @!method string_concatenation?(node)
+        def_node_matcher :string_concatenation?, <<~PATTERN
+          {
+            (send str_type? :+ _)
+            (send _ :+ str_type?)
+          }
+        PATTERN
+
+        def on_new_investigation
+          @corrected_nodes = nil
+        end
+
+        def on_send(node)
+          return unless string_concatenation?(node)
+          return if line_end_concatenation?(node)
+
+          topmost_plus_node = find_topmost_plus_node(node)
+
+          parts = []
+          collect_parts(topmost_plus_node, parts)
+
+          add_offense(topmost_plus_node) do |corrector|
+            correctable_parts = parts.none? { |part| uncorrectable?(part) }
+            if correctable_parts && !corrected_ancestor?(topmost_plus_node)
+              corrector.replace(topmost_plus_node, replacement(parts))
+
+              @corrected_nodes ||= Set.new.compare_by_identity
+              @corrected_nodes.add(topmost_plus_node)
+            end
+          end
+        end
+
+        private
+
+        def line_end_concatenation?(node)
+          # If the concatenation happens at the end of the line,
+          # and both the receiver and argument are strings, allow
+          # `Style/LineEndConcatenation` to handle it instead.
+          node.receiver.str_type? &&
+            node.first_argument.str_type? &&
+            node.multiline? &&
+            node.source =~ /\+\s*\n/
+        end
+
+        def find_topmost_plus_node(node)
+          current = node
+          while (parent = current.parent) && plus_node?(parent)
+            current = parent
+          end
+          current
+        end
+
+        def collect_parts(node, parts)
+          return unless node
+
+          if plus_node?(node)
+            collect_parts(node.receiver, parts)
+            collect_parts(node.first_argument, parts)
+          else
+            parts << node
+          end
+        end
+
+        def plus_node?(node)
+          node.send_type? && node.method?(:+)
+        end
+
+        def uncorrectable?(part)
+          part.multiline? || (part.str_type? && part.heredoc?) || part.each_descendant(:block).any?
+        end
+
+        def corrected_ancestor?(node)
+          node.each_ancestor(:send).any? { |ancestor| @corrected_nodes&.include?(ancestor) }
+        end
+
+        def replacement(parts)
+          interpolated_parts =
+            parts.map do |part|
+              case part.type
+              when :str
+                value = part.value
+                single_quoted?(part) ? value.gsub(/(\\|")/, '\\\\\&') : value.inspect[1..-2]
+              when :dstr
+                contents_range(part).source
+              else
+                "\#{#{part.source}}"
+              end
+            end
+
+          "\"#{handle_quotes(interpolated_parts).join}\""
+        end
+
+        def handle_quotes(parts)
+          parts.map do |part|
+            part == '"' ? '\"' : part
+          end
+        end
+
+        def single_quoted?(str_node)
+          str_node.source.start_with?("'")
+        end
+      end
+    end
+  end
+end