rubocop 0.93.1 → 1.79.2

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

@@ -15,6 +15,11 @@ module RuboCop
       #     end
       #   end
       #
+      #   # bad
+      #   if condition_b
+      #     do_something
+      #   end if condition_a
+      #
       #   # good
       #   if condition_a && condition_b
       #     do_something
@@ -26,35 +31,201 @@ module RuboCop
       #     do_something if condition_b
       #   end
       #
+      #   # bad
+      #   if condition_b
+      #     do_something
+      #   end if condition_a
+      #
       # @example AllowModifier: true
       #   # good
       #   if condition_a
       #     do_something if condition_b
       #   end
       #
+      #   # good
+      #   if condition_b
+      #     do_something
+      #   end if condition_a
       class SoleNestedConditional < Base
-        MSG = 'Consider merging nested conditions into '\
-              'outer `%<conditional_type>s` conditions.'
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Consider merging nested conditions into outer `%<conditional_type>s` conditions.'
+
+        def self.autocorrect_incompatible_with
+          [Style::NegatedIf, Style::NegatedUnless]
+        end
 
         def on_if(node)
           return if node.ternary? || node.else? || node.elsif?
 
-          branch = node.if_branch
-          return unless offending_branch?(branch)
+          if_branch = node.if_branch
+          return if use_variable_assignment_in_condition?(node.condition, if_branch)
+          return unless offending_branch?(node, if_branch)
 
           message = format(MSG, conditional_type: node.keyword)
-          add_offense(branch.loc.keyword, message: message)
+          add_offense(if_branch.loc.keyword, message: message) do |corrector|
+            autocorrect(corrector, node, if_branch)
+          end
         end
 
         private
 
-        def offending_branch?(branch)
+        def use_variable_assignment_in_condition?(condition, if_branch)
+          assigned_variables = assigned_variables(condition)
+
+          assigned_variables && if_branch&.if_type? &&
+            assigned_variables.include?(if_branch.condition.source)
+        end
+
+        def assigned_variables(condition)
+          assigned_variables = condition.assignment? ? [condition.children.first.to_s] : []
+
+          assigned_variables + condition.descendants.select(&:assignment?).map do |node|
+            node.children.first.to_s
+          end
+        end
+
+        def offending_branch?(node, branch)
           return false unless branch
 
           branch.if_type? &&
             !branch.else? &&
             !branch.ternary? &&
-            !(branch.modifier_form? && allow_modifier?)
+            !((node.modifier_form? || branch.modifier_form?) && allow_modifier?)
+        end
+
+        def autocorrect(corrector, node, if_branch)
+          if node.modifier_form?
+            autocorrect_outer_condition_modify_form(corrector, node, if_branch)
+          else
+            autocorrect_outer_condition_basic(corrector, node, if_branch)
+          end
+        end
+
+        def autocorrect_outer_condition_basic(corrector, node, if_branch)
+          correct_node(corrector, node)
+
+          if if_branch.modifier_form?
+            correct_for_guard_condition_style(corrector, node, if_branch)
+          else
+            correct_for_basic_condition_style(corrector, node, if_branch)
+            correct_for_comment(corrector, node, if_branch)
+          end
+        end
+
+        def correct_node(corrector, node)
+          corrector.replace(node.loc.keyword, 'if') if node.unless? && !part_of_ignored_node?(node)
+          corrector.replace(node.condition, chainable_condition(node))
+          ignore_node(node)
+        end
+
+        def correct_for_guard_condition_style(corrector, node, if_branch)
+          corrector.insert_after(node.condition, " && #{chainable_condition(if_branch)}")
+
+          range = range_between(
+            if_branch.loc.keyword.begin_pos, if_branch.condition.source_range.end_pos
+          )
+          corrector.remove(range_with_surrounding_space(range, newlines: false))
+        end
+
+        def correct_for_basic_condition_style(corrector, node, if_branch)
+          range = range_between(
+            node.condition.source_range.end_pos, if_branch.condition.source_range.begin_pos
+          )
+          corrector.replace(range, ' && ')
+
+          corrector.replace(if_branch.condition, chainable_condition(if_branch))
+
+          corrector.remove(range_by_whole_lines(node.loc.end, include_final_newline: true))
+        end
+
+        def autocorrect_outer_condition_modify_form(corrector, node, if_branch)
+          correct_node(corrector, if_branch)
+
+          corrector.insert_before(if_branch.condition, "#{chainable_condition(node)} && ")
+
+          range = range_between(node.loc.keyword.begin_pos, node.condition.source_range.end_pos)
+          corrector.remove(range_with_surrounding_space(range, newlines: false))
+        end
+
+        def correct_for_comment(corrector, node, if_branch)
+          comments = processed_source.ast_with_comments[if_branch].select do |comment|
+            comment.loc.line < if_branch.condition.first_line
+          end
+          comment_text = comments.map(&:text).join("\n") << "\n"
+
+          corrector.insert_before(node.loc.keyword, comment_text) unless comments.empty?
+        end
+
+        def chainable_condition(node)
+          wrapped_condition = add_parentheses_if_needed(node.condition)
+
+          return wrapped_condition if node.if?
+
+          node.condition.and_type? ? "!(#{wrapped_condition})" : "!#{wrapped_condition}"
+        end
+
+        def add_parentheses_if_needed(condition)
+          # Handle `send` and `block` nodes that need to be wrapped in parens
+          # FIXME: autocorrection prevents syntax errors by wrapping the entire node in parens,
+          #        but wrapping the argument list would be a more ergonomic correction.
+          node_to_check = condition&.any_block_type? ? condition.send_node : condition
+          return condition.source unless add_parentheses?(node_to_check)
+
+          if parenthesize_method?(condition)
+            parenthesized_method_arguments(condition)
+          elsif condition.and_type?
+            parenthesized_and(condition)
+          else
+            "(#{condition.source})"
+          end
+        end
+
+        def parenthesize_method?(node)
+          node.call_type? && node.arguments.any? && !node.parenthesized? &&
+            !node.comparison_method? && !node.operator_method?
+        end
+
+        def add_parentheses?(node)
+          return true if node.assignment? || node.or_type?
+          return true if assignment_in_and?(node)
+          return false unless node.call_type?
+
+          (node.arguments.any? && !node.parenthesized?) || node.prefix_not?
+        end
+
+        def assignment_in_and?(node)
+          return false unless node.and_type?
+
+          node.each_descendant.any?(&:assignment?)
+        end
+
+        def parenthesized_method_arguments(node)
+          method_call = node.source_range.begin.join(node.loc.selector.end).source
+          arguments = node.first_argument.source_range.begin.join(node.source_range.end).source
+
+          "#{method_call}(#{arguments})"
+        end
+
+        def parenthesized_and(node)
+          # We only need to add parentheses around the last clause if it's an assignment,
+          # because other clauses will be unchanged by merging conditionals.
+          lhs = node.lhs.source
+          rhs = parenthesized_and_clause(node.rhs)
+          operator = range_with_surrounding_space(node.loc.operator, whitespace: true).source
+
+          "#{lhs}#{operator}#{rhs}"
+        end
+
+        def parenthesized_and_clause(node)
+          if node.and_type?
+            parenthesized_and(node)
+          elsif node.assignment?
+            "(#{node.source})"
+          else
+            node.source
+          end
         end
 
         def allow_modifier?

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

@@ -3,11 +3,19 @@
 module RuboCop
   module Cop
     module Style
+      # Looks for uses of Perl-style global variables.
+      # Correcting to global variables in the 'English' library
+      # will add a require statement to the top of the file if
+      # enabled by RequireEnglish config.
       #
-      # This cop looks for uses of Perl-style global variables.
+      # @safety
+      #   Autocorrection is marked as unsafe because if `RequireEnglish` is not
+      #   true, replacing perl-style variables with english variables will break.
       #
       # @example EnforcedStyle: use_english_names (default)
       #   # good
+      #   require 'English' # or this could be in another file.
+      #
       #   puts $LOAD_PATH
       #   puts $LOADED_FEATURES
       #   puts $PROGRAM_NAME
@@ -26,10 +34,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,20 +55,45 @@ module RuboCop
       #   puts $~
       #   puts $=
       #   puts $*
-      #   puts $&
-      #   puts $`
-      #   puts $'
-      #   puts $+
+      #
+      # @example EnforcedStyle: use_builtin_english_names
+      #
+      #   # good
+      #   # Like `use_perl_names` but allows builtin global vars.
+      #   puts $LOAD_PATH
+      #   puts $LOADED_FEATURES
+      #   puts $PROGRAM_NAME
+      #   puts ARGV
+      #   puts $:
+      #   puts $"
+      #   puts $0
+      #   puts $!
+      #   puts $@
+      #   puts $;
+      #   puts $,
+      #   puts $/
+      #   puts $\
+      #   puts $.
+      #   puts $_
+      #   puts $>
+      #   puts $<
+      #   puts $$
+      #   puts $?
+      #   puts $~
+      #   puts $=
+      #   puts $*
       #
       class SpecialGlobalVars < Base
         include ConfigurableEnforcedStyle
+        include RangeHelp
+        include RequireLibrary
         extend AutoCorrector
 
         MSG_BOTH = 'Prefer `%<prefer>s` from the stdlib \'English\' ' \
-        'module (don\'t forget to require it) or `%<regular>s` over ' \
-        '`%<global>s`.'
+                   'module (don\'t forget to require it) or `%<regular>s` over ' \
+                   '`%<global>s`.'
         MSG_ENGLISH = 'Prefer `%<prefer>s` from the stdlib \'English\' ' \
-        'module (don\'t forget to require it) over `%<global>s`.'
+                      'module (don\'t forget to require it) over `%<global>s`.'
         MSG_REGULAR = 'Prefer `%<prefer>s` over `%<global>s`.'
 
         ENGLISH_VARS = { # rubocop:disable Style/MutableConstant
@@ -85,42 +114,49 @@ 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]] } }]
+        # 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
+
+        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)
+        BUILTIN_VARS = PERL_VARS.merge(
+          NON_ENGLISH_VARS
+            .select { |v| v.to_s.start_with?('$') }
+            .flat_map { |v| [[v, [v]], PERL_VARS[v].flat_map { |a| [a, [v]] }] }
+            .to_h
         )
+
         ENGLISH_VARS.each_value(&:freeze).freeze
         PERL_VARS.each_value(&:freeze).freeze
+        BUILTIN_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
+        STYLE_VARS_MAP = {
+          use_english_names: ENGLISH_VARS,
+          use_perl_names: PERL_VARS,
+          use_builtin_english_names: BUILTIN_VARS
+        }.freeze
+
+        LIBRARY_NAME = 'English'
+
+        def on_new_investigation
+          super
+          @required_english = false
+        end
 
         def on_gvar(node)
-          global_var, = *node
+          global_var = node.name
 
           return unless (preferred = preferred_names(global_var))
 
           if preferred.include?(global_var)
             correct_style_detected
           else
-            opposite_style_detected
+            style_detected(matching_styles(global_var))
 
             add_offense(node, message: message(global_var)) do |corrector|
               autocorrect(corrector, node, global_var)
@@ -132,15 +168,19 @@ module RuboCop
           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(corrector, node, global_var)
           node = node.parent while node.parent&.begin_type? && node.parent.children.one?
 
+          if should_require_english?(global_var)
+            ensure_required(corrector, node, LIBRARY_NAME)
+
+            @required_english = true
+          end
+
           corrector.replace(node, replacement(node, global_var))
         end
 
@@ -184,10 +224,16 @@ module RuboCop
         end
 
         def preferred_names(global)
-          if style == :use_english_names
-            ENGLISH_VARS[global]
-          else
-            PERL_VARS[global]
+          vars = STYLE_VARS_MAP.fetch(style) do
+            raise ArgumentError, "Invalid style: #{style.inspect}"
+          end
+
+          vars[global]
+        end
+
+        def matching_styles(global)
+          STYLE_VARS_MAP.filter_map do |style, vars|
+            style if vars.values.flatten(1).include? global
           end
         end
 
@@ -196,6 +242,17 @@ module RuboCop
 
           "{#{preferred_name}}"
         end
+
+        def add_require_english?
+          cop_config['RequireEnglish']
+        end
+
+        def should_require_english?(global_var)
+          style == :use_english_names &&
+            add_require_english? &&
+            !@required_english &&
+            !NON_ENGLISH_VARS.include?(preferred_names(global_var).first)
+        end
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Check for parentheses around stabby lambda arguments.
+      # Checks for parentheses around stabby lambda arguments.
       # There are two different styles. Defaults to `require_parentheses`.
       #
       # @example EnforcedStyle: require_parentheses (default)
@@ -24,8 +24,7 @@ module RuboCop
         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)

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

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # 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.
+      #
+      # @safety
+      #   This cop is 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 RangeHelp
+        include VisibilityHelp
+        extend AutoCorrector
+
+        MSG = 'Prefer modules to classes with only class methods.'
+
+        def on_class(class_node)
+          return if class_node.parent_class
+          return unless class_convertible_to_module?(class_node)
+
+          add_offense(class_node) do |corrector|
+            autocorrect(corrector, class_node)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, class_node)
+          corrector.replace(class_node.loc.keyword, 'module')
+          corrector.insert_after(class_node.loc.name, "\nmodule_function\n")
+
+          class_elements(class_node).each do |node|
+            if node.defs_type?
+              autocorrect_def(corrector, node)
+            elsif node.sclass_type?
+              autocorrect_sclass(corrector, node)
+            end
+          end
+        end
+
+        def autocorrect_def(corrector, node)
+          corrector.remove(
+            range_between(node.receiver.source_range.begin_pos, node.loc.name.begin_pos)
+          )
+        end
+
+        def autocorrect_sclass(corrector, node)
+          corrector.remove(
+            range_between(node.loc.keyword.begin_pos, node.identifier.source_range.end_pos)
+          )
+          corrector.remove(node.loc.end)
+        end
+
+        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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop identifies places where `$stderr.puts` can be replaced by
+      # Identifies places where `$stderr.puts` can be replaced by
       # `warn`. The latter has the advantage of easily being disabled by,
       # the `-W0` interpreter flag or setting `$VERBOSE` to `nil`.
       #
@@ -18,10 +18,10 @@ module RuboCop
         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? cbase} :STDERR)}
@@ -49,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.source_range.begin_pos, send.loc.selector.end_pos)
         end
       end
     end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for uses of `String#split` with empty string or regexp literal argument.
+      #
+      # @safety
+      #   This cop is unsafe because it cannot be guaranteed that the receiver
+      #   is actually a string. If another class has a `split` method with
+      #   different behavior, it would be registered as a false positive.
+      #
+      # @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
+        alias on_csend on_send
+      end
+    end
+  end
+end