rubocop 1.26.0 → 1.36.0

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,12 +31,21 @@ 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
         include RangeHelp
         extend AutoCorrector
@@ -47,7 +61,7 @@ module RuboCop
 
           if_branch = node.if_branch
           return if use_variable_assignment_in_condition?(node.condition, if_branch)
-          return unless offending_branch?(if_branch)
+          return unless offending_branch?(node, if_branch)
 
           message = format(MSG, conditional_type: node.keyword)
           add_offense(if_branch.loc.keyword, message: message) do |corrector|
@@ -72,13 +86,13 @@ module RuboCop
           end
         end
 
-        def offending_branch?(branch)
+        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)
@@ -86,37 +100,45 @@ module RuboCop
             corrector.wrap(node.condition, '(', ')')
           end
 
+          if outer_condition_modify_form?(node, if_branch)
+            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_from_unless_to_if(corrector, node) if node.unless?
 
+          outer_condition = node.condition
+          correct_outer_condition(corrector, outer_condition)
+
           and_operator = if_branch.unless? ? ' && !' : ' && '
           if if_branch.modifier_form?
-            correct_for_guard_condition_style(corrector, node, if_branch, and_operator)
+            correct_for_guard_condition_style(corrector, outer_condition, if_branch, and_operator)
           else
             correct_for_basic_condition_style(corrector, node, if_branch, and_operator)
             correct_for_comment(corrector, node, if_branch)
           end
         end
 
-        def correct_from_unless_to_if(corrector, node)
+        def autocorrect_outer_condition_modify_form(corrector, node, if_branch)
+          correct_from_unless_to_if(corrector, if_branch, is_modify_form: true) if if_branch.unless?
+          correct_for_outer_condition_modify_form_style(corrector, node, if_branch)
+        end
+
+        def correct_from_unless_to_if(corrector, node, is_modify_form: false)
           corrector.replace(node.loc.keyword, 'if')
 
-          condition = node.condition
-          if condition.send_type? && condition.comparison_method? && !condition.parenthesized?
-            corrector.wrap(node.condition, '!(', ')')
-          else
-            corrector.insert_before(node.condition, '!')
-          end
+          insert_bang(corrector, node, is_modify_form)
         end
 
-        def correct_for_guard_condition_style(corrector, node, if_branch, and_operator)
-          outer_condition = node.condition
-          correct_outer_condition(corrector, outer_condition)
-
+        def correct_for_guard_condition_style(corrector, outer_condition, if_branch, and_operator)
           condition = if_branch.condition
-          corrector.insert_after(outer_condition, replacement_condition(and_operator, condition))
+          corrector.insert_after(outer_condition, "#{and_operator}#{replace_condition(condition)}")
 
           range = range_between(if_branch.loc.keyword.begin_pos, condition.source_range.end_pos)
-          corrector.remove(range_with_surrounding_space(range: range, newlines: false))
+          corrector.remove(range_with_surrounding_space(range, newlines: false))
           corrector.remove(if_branch.loc.keyword)
         end
 
@@ -126,12 +148,31 @@ module RuboCop
           )
           corrector.replace(range, and_operator)
           corrector.remove(range_by_whole_lines(node.loc.end, include_final_newline: true))
-          corrector.wrap(if_branch.condition, '(', ')') if wrap_condition?(if_branch.condition)
+
+          wrap_condition(corrector, if_branch.condition)
         end
 
-        def correct_for_comment(corrector, node, if_branch)
-          return if config.for_cop('Style/IfUnlessModifier')['Enabled']
+        def wrap_condition(corrector, 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&.block_type? ? condition.send_node : condition
+          return unless wrap_condition?(node_to_check)
+
+          corrector.wrap(condition, '(', ')')
+        end
+
+        def correct_for_outer_condition_modify_form_style(corrector, node, if_branch)
+          condition = if_branch.condition
+          corrector.insert_before(condition,
+                                  "#{'!' if node.unless?}#{replace_condition(node.condition)} && ")
+
+          corrector.remove(node.condition.loc.expression)
+          corrector.remove(range_with_surrounding_space(node.loc.keyword, newlines: false))
+          corrector.replace(if_branch.loc.keyword, 'if')
+        end
 
+        def correct_for_comment(corrector, node, if_branch)
           comments = processed_source.ast_with_comments[if_branch]
           comment_text = comments.map(&:text).join("\n") << "\n"
 
@@ -139,7 +180,7 @@ module RuboCop
         end
 
         def correct_outer_condition(corrector, condition)
-          return unless requrie_parentheses?(condition)
+          return unless require_parentheses?(condition)
 
           end_pos = condition.loc.selector.end_pos
           begin_pos = condition.first_argument.source_range.begin_pos
@@ -149,8 +190,33 @@ module RuboCop
           corrector.insert_after(condition.last_argument.source_range, ')')
         end
 
-        def requrie_parentheses?(condition)
-          condition.send_type? && !condition.arguments.empty? && !condition.parenthesized? &&
+        def insert_bang(corrector, node, is_modify_form)
+          condition = node.condition
+
+          if (condition.send_type? && condition.comparison_method? && !condition.parenthesized?) ||
+             (is_modify_form && wrap_condition?(condition))
+            corrector.wrap(node.condition, '!(', ')')
+          elsif condition.and_type?
+            insert_bang_for_and(corrector, node)
+          else
+            corrector.insert_before(condition, '!')
+          end
+        end
+
+        def insert_bang_for_and(corrector, node)
+          lhs, rhs = *node
+
+          if lhs.and_type?
+            insert_bang_for_and(corrector, lhs)
+            corrector.insert_before(rhs, '!') if rhs
+          else
+            corrector.insert_before(lhs, '!')
+            corrector.insert_before(rhs, '!')
+          end
+        end
+
+        def require_parentheses?(condition)
+          condition.call_type? && !condition.arguments.empty? && !condition.parenthesized? &&
             !condition.comparison_method?
         end
 
@@ -162,20 +228,20 @@ module RuboCop
 
         def wrap_condition?(node)
           node.and_type? || node.or_type? ||
-            (node.send_type? && node.arguments.any? && !node.parenthesized?)
+            (node.call_type? && node.arguments.any? && !node.parenthesized?)
         end
 
-        def replacement_condition(and_operator, condition)
-          if wrap_condition?(condition)
-            "#{and_operator}(#{condition.source})"
-          else
-            "#{and_operator}#{condition.source}"
-          end
+        def replace_condition(condition)
+          wrap_condition?(condition) ? "(#{condition.source})" : condition.source
         end
 
         def allow_modifier?
           cop_config['AllowModifier']
         end
+
+        def outer_condition_modify_form?(node, if_branch)
+          node.condition.loc.expression.begin_pos > if_branch.condition.loc.expression.begin_pos
+        end
       end
     end
   end

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

@@ -57,6 +57,34 @@ module RuboCop
       #   puts $=
       #   puts $*
       #
+      # @example EnforcedStyle: use_builtin_english_names
+      #
+      # Like `use_perl_names` but allows builtin global vars.
+      #
+      #   # good
+      #   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
@@ -91,18 +119,37 @@ module RuboCop
           :$* => %i[$ARGV ARGV]
         }
 
+        # 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!(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
 
@@ -111,7 +158,7 @@ module RuboCop
           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)
@@ -130,7 +177,11 @@ module RuboCop
         def autocorrect(corrector, node, global_var)
           node = node.parent while node.parent&.begin_type? && node.parent.children.one?
 
-          ensure_required(corrector, node, LIBRARY_NAME) if should_require_english?(global_var)
+          if should_require_english?(global_var)
+            ensure_required(corrector, node, LIBRARY_NAME)
+
+            @required_english = true
+          end
 
           corrector.replace(node, replacement(node, global_var))
         end
@@ -175,11 +226,17 @@ 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.map do |style, vars|
+            style if vars.values.flatten(1).include? global
+          end.compact
         end
 
         def english_name_replacement(preferred_name, node)
@@ -195,6 +252,7 @@ module RuboCop
         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

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for places where classes with only class methods can be
+      # 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.
       #

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`.
       #

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

@@ -8,7 +8,7 @@ module RuboCop
       # @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 behaviour, it would be registered as a false positive.
+      #   different behavior, it would be registered as a false positive.
       #
       # @example
       #   # bad

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for places where string concatenation
+      # Checks for places where string concatenation
       # can be replaced with string interpolation.
       #
       # The cop can autocorrect simple cases but will skip autocorrecting
@@ -76,7 +76,7 @@ module RuboCop
 
           topmost_plus_node = find_topmost_plus_node(node)
           parts = collect_parts(topmost_plus_node)
-          return unless parts[0..-2].any? { |receiver_node| offensive_for_mode?(receiver_node) }
+          return if mode == :conservative && !parts.first.str_type?
 
           register_offense(topmost_plus_node, parts)
         end
@@ -95,11 +95,6 @@ module RuboCop
           end
         end
 
-        def offensive_for_mode?(receiver_node)
-          mode = cop_config['Mode'].to_sym
-          mode == :aggressive || (mode == :conservative && receiver_node.str_type?)
-        end
-
         def line_end_concatenation?(node)
           # If the concatenation happens at the end of the line,
           # and both the receiver and argument are strings, allow
@@ -173,6 +168,10 @@ module RuboCop
         def single_quoted?(str_node)
           str_node.source.start_with?("'")
         end
+
+        def mode
+          cop_config['Mode'].to_sym
+        end
       end
     end
   end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for the use of strings as keys in hashes. The use of
+      # Checks for the use of strings as keys in hashes. The use of
       # symbols is preferred instead.
       #
       # @safety

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks that quotes inside the string interpolation
+      # Checks that quotes inside the string interpolation
       # match the configured preference.
       #
       # @example EnforcedStyle: single_quotes (default)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces the use of consistent method names
+      # Enforces the use of consistent method names
       # from the String class.
       #
       # @example

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop identifies places where `lstrip.rstrip` can be replaced by
+      # Identifies places where `lstrip.rstrip` can be replaced by
       # `strip`.
       #
       # @example

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

@@ -3,10 +3,10 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for inheritance from Struct.new.
+      # Checks for inheritance from Struct.new.
       #
       # @safety
-      #   Auto-correction is unsafe because it will change the inheritance
+      #   Autocorrection is unsafe because it will change the inheritance
       #   tree (e.g. return value of `Module#ancestors`) of the constant.
       #
       # @example
@@ -34,7 +34,7 @@ module RuboCop
           return unless struct_constructor?(node.parent_class)
 
           add_offense(node.parent_class.source_range) do |corrector|
-            corrector.remove(range_with_surrounding_space(range: node.loc.keyword, newlines: false))
+            corrector.remove(range_with_surrounding_space(node.loc.keyword, newlines: false))
             corrector.replace(node.loc.operator, '=')
 
             correct_parent(node.parent_class, corrector)
@@ -51,7 +51,7 @@ module RuboCop
 
         def correct_parent(parent, corrector)
           if parent.block_type?
-            corrector.remove(range_with_surrounding_space(range: parent.loc.end, newlines: false))
+            corrector.remove(range_with_surrounding_space(parent.loc.end, newlines: false))
           elsif (class_node = parent.parent).body.nil?
             corrector.remove(range_for_empty_class_body(class_node, parent))
           else

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop enforces the use of shorthand-style swapping of 2 variables.
+      # Enforces the use of shorthand-style swapping of 2 variables.
       #
       # @safety
       #   Autocorrection is unsafe, because the temporary variable used to
@@ -22,7 +22,7 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Replace this and assignments at lines %<x_line>d '\
+        MSG = 'Replace this and assignments at lines %<x_line>d ' \
               'and %<y_line>d with `%<replacement>s`.'
 
         SIMPLE_ASSIGNMENT_TYPES = %i[lvasgn ivasgn cvasgn gvasgn casgn].to_set.freeze

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

@@ -3,11 +3,12 @@
 module RuboCop
   module Cop
     module Style
-      # This cop can check for array literals made up of symbols that are not
+      # Checks for array literals made up of symbols that are not
       # using the %i() syntax.
       #
       # Alternatively, it checks for symbol arrays using the %i() syntax on
-      # projects which do not want to use that syntax.
+      # projects which do not want to use that syntax, perhaps because they
+      # support a version of Ruby lower than 2.0.
       #
       # Configuration option: MinSize
       # If set, arrays with fewer elements than this value will not trigger the
@@ -33,9 +34,12 @@ module RuboCop
         include ConfigurableEnforcedStyle
         include PercentArray
         extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.0
 
         PERCENT_MSG = 'Use `%i` or `%I` for an array of symbols.'
-        ARRAY_MSG = 'Use `%<prefer>s` for an array of symbols.'
+        ARRAY_MSG = 'Use %<prefer>s for an array of symbols.'
 
         class << self
           attr_accessor :largest_brackets
@@ -65,13 +69,12 @@ module RuboCop
             if c.dsym_type?
               string_literal = to_string_literal(c.source)
 
-              ":#{trim_string_interporation_escape_character(string_literal)}"
+              ":#{trim_string_interpolation_escape_character(string_literal)}"
             else
               to_symbol_literal(c.value.to_s)
             end
           end
-
-          "[#{syms.join(', ')}]"
+          build_bracketed_array_with_appropriate_whitespace(elements: syms, node: node)
         end
 
         def to_symbol_literal(string)

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks symbol literal syntax.
+      # Checks symbol literal syntax.
       #
       # @example
       #