rubocop 0.51.0 → 0.87.0

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

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop identifies places where `fetch(key) { value }`
+      # can be replaced by `fetch(key, value)`.
+      #
+      # In such cases `fetch(key, value)` method is faster
+      # than `fetch(key) { value }`.
+      #
+      # @example SafeForConstants: false (default)
+      #   # bad
+      #   hash.fetch(:key) { 5 }
+      #   hash.fetch(:key) { true }
+      #   hash.fetch(:key) { nil }
+      #   array.fetch(5) { :value }
+      #   ENV.fetch(:key) { 'value' }
+      #
+      #   # good
+      #   hash.fetch(:key, 5)
+      #   hash.fetch(:key, true)
+      #   hash.fetch(:key, nil)
+      #   array.fetch(5, :value)
+      #   ENV.fetch(:key, 'value')
+      #
+      # @example SafeForConstants: true
+      #   # bad
+      #   ENV.fetch(:key) { VALUE }
+      #
+      #   # good
+      #   ENV.fetch(:key, VALUE)
+      #
+      class RedundantFetchBlock < Cop
+        include FrozenStringLiteral
+        include RangeHelp
+
+        MSG = 'Use `%<good>s` instead of `%<bad>s`.'
+
+        def_node_matcher :redundant_fetch_block_candidate?, <<~PATTERN
+          (block
+            $(send _ :fetch _)
+            (args)
+            ${nil? #basic_literal? #const_type?})
+        PATTERN
+
+        def on_block(node)
+          redundant_fetch_block_candidate?(node) do |send, body|
+            return if should_not_check?(send, body)
+
+            range = fetch_range(send, node)
+            good = build_good_method(send, body)
+            bad = build_bad_method(send, body)
+
+            add_offense(
+              node,
+              location: range,
+              message: format(MSG, good: good, bad: bad)
+            )
+          end
+        end
+
+        def autocorrect(node)
+          redundant_fetch_block_candidate?(node) do |send, body|
+            lambda do |corrector|
+              receiver, _, key = send.children
+              default_value = body ? body.source : 'nil'
+
+              corrector.replace(node, "#{receiver.source}.fetch(#{key.source}, #{default_value})")
+            end
+          end
+        end
+
+        private
+
+        def basic_literal?(node)
+          node&.basic_literal?
+        end
+
+        def const_type?(node)
+          node&.const_type?
+        end
+
+        def should_not_check?(send, body)
+          (body&.const_type? && !check_for_constant?) ||
+            (body&.str_type? && !check_for_string?) ||
+            rails_cache?(send.receiver)
+        end
+
+        def_node_matcher :rails_cache?, <<~PATTERN
+          (send (const _ :Rails) :cache)
+        PATTERN
+
+        def fetch_range(send, node)
+          range_between(send.loc.selector.begin_pos, node.loc.end.end_pos)
+        end
+
+        def build_good_method(send, body)
+          key = send.children[2].source
+          default_value = body ? body.source : 'nil'
+
+          "fetch(#{key}, #{default_value})"
+        end
+
+        def build_bad_method(send, body)
+          key = send.children[2].source
+          block = body ? "{ #{body.source} }" : '{}'
+
+          "fetch(#{key}) #{block}"
+        end
+
+        def check_for_constant?
+          cop_config['SafeForConstants']
+        end
+
+        def check_for_string?
+          frozen_string_literals_enabled?
+        end
+      end
+    end
+  end
+end

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

@@ -15,11 +15,12 @@ module RuboCop
         include FrozenStringLiteral
 
         MSG = 'Do not freeze immutable objects, as freezing them has no ' \
-              'effect.'.freeze
+              'effect.'
 
         def on_send(node)
           return unless node.receiver && node.method?(:freeze) &&
-                        immutable_literal?(node.receiver)
+                        (immutable_literal?(node.receiver) ||
+                         operation_produces_immutable_object?(node.receiver))
 
           add_offense(node)
         end
@@ -34,11 +35,32 @@ module RuboCop
         private
 
         def immutable_literal?(node)
+          node = strip_parenthesis(node)
+
           return true if node.immutable_literal?
 
           FROZEN_STRING_LITERAL_TYPES.include?(node.type) &&
             frozen_string_literals_enabled?
         end
+
+        def strip_parenthesis(node)
+          if node.begin_type? && node.children.first
+            node.children.first
+          else
+            node
+          end
+        end
+
+        def_node_matcher :operation_produces_immutable_object?, <<~PATTERN
+          {
+            (begin (send {float int} {:+ :- :* :** :/ :% :<<} _))
+            (begin (send !(str _) {:+ :- :* :** :/ :%} {float int}))
+            (begin (send _ {:== :=== :!= :<= :>= :< :>} _))
+            (send (const {nil? cbase} :ENV) :[] _)
+            (send _ {:count :length :size} ...)
+            (block (send _ {:count :length :size} ...) ...)
+          }
+        PATTERN
       end
     end
   end

data/lib/rubocop/cop/style/{unneeded_interpolation.rb → redundant_interpolation.rb}

@@ -15,10 +15,10 @@ module RuboCop
       #
       #   # good if @var is already a String
       #   @var
-      class UnneededInterpolation < Cop
+      class RedundantInterpolation < Cop
         include PercentLiteral
 
-        MSG = 'Prefer `to_s` over string interpolation.'.freeze
+        MSG = 'Prefer `to_s` over string interpolation.'
 
         def self.autocorrect_incompatible_with
           [Style::LineEndConcatenation]
@@ -28,21 +28,29 @@ module RuboCop
           add_offense(node) if single_interpolation?(node)
         end
 
+        def autocorrect(node)
+          embedded_node = node.children.first
+
+          if variable_interpolation?(embedded_node)
+            autocorrect_variable_interpolation(embedded_node, node)
+          elsif single_variable_interpolation?(embedded_node)
+            autocorrect_single_variable_interpolation(embedded_node, node)
+          else
+            autocorrect_other(embedded_node, node)
+          end
+        end
+
         private
 
         def single_interpolation?(node)
-          single_child?(node) &&
+          node.children.one? &&
             interpolation?(node.children.first) &&
             !implicit_concatenation?(node) &&
             !embedded_in_percent_array?(node)
         end
 
         def single_variable_interpolation?(node)
-          single_child?(node) && variable_interpolation?(node.children.first)
-        end
-
-        def single_child?(node)
-          node.children.one?
+          node.children.one? && variable_interpolation?(node.children.first)
         end
 
         def interpolation?(node)
@@ -54,35 +62,23 @@ module RuboCop
         end
 
         def implicit_concatenation?(node)
-          node.parent && node.parent.dstr_type?
+          node.parent&.dstr_type?
         end
 
         def embedded_in_percent_array?(node)
-          node.parent && node.parent.array_type? &&
+          node.parent&.array_type? &&
             percent_literal?(node.parent)
         end
 
-        def autocorrect(node)
-          embedded_node = node.children.first
-
-          if variable_interpolation?(embedded_node)
-            autocorrect_variable_interpolation(embedded_node, node)
-          elsif single_variable_interpolation?(embedded_node)
-            autocorrect_single_variable_interpolation(embedded_node, node)
-          else
-            autocorrect_other(embedded_node, node)
-          end
-        end
-
         def autocorrect_variable_interpolation(embedded_node, node)
           replacement = "#{embedded_node.loc.expression.source}.to_s"
-          ->(corrector) { corrector.replace(node.loc.expression, replacement) }
+          ->(corrector) { corrector.replace(node, replacement) }
         end
 
         def autocorrect_single_variable_interpolation(embedded_node, node)
           variable_loc = embedded_node.children.first.loc
           replacement = "#{variable_loc.expression.source}.to_s"
-          ->(corrector) { corrector.replace(node.loc.expression, replacement) }
+          ->(corrector) { corrector.replace(node, replacement) }
         end
 
         def autocorrect_other(embedded_node, node)

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

@@ -16,26 +16,31 @@ module RuboCop
       class RedundantParentheses < Cop
         include Parentheses
 
-        ALLOWED_LITERALS = %i[irange erange].freeze
-
         def_node_matcher :square_brackets?,
                          '(send {(send _recv _msg) str array hash} :[] ...)'
         def_node_matcher :range_end?, '^^{irange erange}'
-        def_node_matcher :method_node_and_args, '$(send _recv _msg $...)'
+        def_node_matcher :method_node_and_args, '$(call _recv _msg $...)'
         def_node_matcher :rescue?, '{^resbody ^^resbody}'
         def_node_matcher :arg_in_call_with_block?,
                          '^^(block (send _ _ equal?(%0) ...) ...)'
 
         def on_begin(node)
           return if !parentheses?(node) || parens_allowed?(node)
+          return if node.parent && (node.parent.while_post_type? ||
+                                    node.parent.until_post_type?)
+
           check(node)
         end
 
+        def autocorrect(node)
+          ParenthesesCorrector.correct(node)
+        end
+
         private
 
         def parens_allowed?(node)
           empty_parentheses?(node) ||
-            hash_literal_as_first_arg?(node) ||
+            first_arg_begins_with_hash_literal?(node) ||
             rescue?(node) ||
             allowed_expression?(node)
         end
@@ -59,8 +64,10 @@ module RuboCop
 
         def allowed_multiple_expression?(node)
           return false if node.children.one?
+
           ancestor = node.ancestors.first
           return false unless ancestor
+
           !ancestor.begin_type? && !ancestor.def_type? && !ancestor.block_type?
         end
 
@@ -69,23 +76,29 @@ module RuboCop
           node.children.empty?
         end
 
-        def hash_literal_as_first_arg?(node)
-          # Don't flag `method ({key: value})`
-          node.children.first.hash_type? && first_argument?(node) &&
+        def first_arg_begins_with_hash_literal?(node)
+          # Don't flag `method ({key: value})` or `method ({key: value}.method)`
+          method_chain_begins_with_hash_literal?(node.children.first) &&
+            first_argument?(node) &&
             !parentheses?(node.parent)
         end
 
+        def method_chain_begins_with_hash_literal?(node)
+          return false if node.nil?
+          return true if node.hash_type?
+          return false unless node.send_type?
+
+          method_chain_begins_with_hash_literal?(node.children.first)
+        end
+
         def check(begin_node)
           node = begin_node.children.first
-          if keyword_with_redundant_parentheses?(node)
-            return offense(begin_node, 'a keyword')
-          end
-          if disallowed_literal?(begin_node, node)
-            return offense(begin_node, 'a literal')
-          end
+          return offense(begin_node, 'a keyword') if keyword_with_redundant_parentheses?(node)
+          return offense(begin_node, 'a literal') if disallowed_literal?(begin_node, node)
           return offense(begin_node, 'a variable') if node.variable?
           return offense(begin_node, 'a constant') if node.const_type?
-          check_send(begin_node, node) if node.send_type?
+
+          check_send(begin_node, node) if node.call_type?
         end
 
         def check_send(begin_node, node)
@@ -100,8 +113,8 @@ module RuboCop
         def check_unary(begin_node, node)
           return if begin_node.chained?
 
-          # parens are not redundant in `(!recv.method arg)`
-          node = node.children.first while node.unary_operation?
+          node = node.children.first while suspect_unary?(node)
+
           if node.send_type?
             return unless method_call_with_redundant_parentheses?(node)
           end
@@ -113,8 +126,12 @@ module RuboCop
           add_offense(node, message: "Don't use parentheses around #{msg}.")
         end
 
+        def suspect_unary?(node)
+          node.send_type? && node.unary_operation? && !node.prefix_not?
+        end
+
         def keyword_ancestor?(node)
-          node.parent && node.parent.keyword?
+          node.parent&.keyword?
         end
 
         def allowed_array_or_hash_element?(node)
@@ -128,35 +145,36 @@ module RuboCop
         end
 
         def hash_element?(node)
-          node.parent && node.parent.pair_type?
+          node.parent&.pair_type?
         end
 
         def array_element?(node)
-          node.parent && node.parent.array_type?
+          node.parent&.array_type?
         end
 
         def only_closing_paren_before_comma?(node)
           source_buffer = node.source_range.source_buffer
           line_range = source_buffer.line_range(node.loc.end.line)
 
-          line_range.source =~ /^\s*\)\s*,/
+          /^\s*\)\s*,/.match?(line_range.source)
         end
 
         def disallowed_literal?(begin_node, node)
           node.literal? &&
-            !ALLOWED_LITERALS.include?(node.type) &&
+            !node.range_type? &&
             !raised_to_power_negative_numeric?(begin_node, node)
         end
 
         def raised_to_power_negative_numeric?(begin_node, node)
           return false unless node.numeric_type?
 
-          siblings = begin_node.parent && begin_node.parent.children
+          siblings = begin_node.parent&.children
           return false if siblings.nil?
+
           next_sibling = siblings[begin_node.sibling_index + 1]
           base_value = node.children.first
 
-          base_value < 0 && next_sibling == :**
+          base_value.negative? && next_sibling == :**
         end
 
         def keyword_with_redundant_parentheses?(node)
@@ -173,8 +191,8 @@ module RuboCop
         end
 
         def method_call_with_redundant_parentheses?(node)
-          return false unless node.send_type?
-          return false if node.keyword_not?
+          return false unless node.call_type?
+          return false if node.prefix_not?
           return false if range_end?(node)
 
           send_node, args = method_node_and_args(node)
@@ -186,13 +204,27 @@ module RuboCop
           args.one? && args.first.begin_type?
         end
 
-        def_node_matcher :first_argument?, <<-PATTERN
+        def first_argument?(node)
+          first_send_argument?(node) ||
+            first_super_argument?(node) ||
+            first_yield_argument?(node)
+        end
+
+        def_node_matcher :first_send_argument?, <<~PATTERN
           ^(send _ _ equal?(%0) ...)
         PATTERN
 
+        def_node_matcher :first_super_argument?, <<~PATTERN
+          ^(super equal?(%0) ...)
+        PATTERN
+
+        def_node_matcher :first_yield_argument?, <<~PATTERN
+          ^(yield equal?(%0) ...)
+        PATTERN
+
         def call_chain_starts_with_int?(begin_node, send_node)
           recv = first_part_of_call_chain(send_node)
-          recv && recv.int_type? && (parent = begin_node.parent) &&
+          recv&.int_type? && (parent = begin_node.parent) &&
             parent.send_type? && (parent.method?(:-@) || parent.method?(:+@))
         end
       end

data/lib/rubocop/cop/style/{unneeded_percent_q.rb → redundant_percent_q.rb}

@@ -4,20 +4,35 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for usage of the %q/%Q syntax when '' or "" would do.
-      class UnneededPercentQ < Cop
-        MSG = 'Use `%s` only for strings that contain both single quotes and ' \
-              'double quotes%s.'.freeze
+      #
+      # @example
+      #
+      #   # bad
+      #   name = %q(Bruce Wayne)
+      #   time = %q(8 o'clock)
+      #   question = %q("What did you say?")
+      #
+      #   # good
+      #   name = 'Bruce Wayne'
+      #   time = "8 o'clock"
+      #   question = '"What did you say?"'
+      #
+      class RedundantPercentQ < Cop
+        MSG = 'Use `%<q_type>s` only for strings that contain both ' \
+              'single quotes and double quotes%<extra>s.'
         DYNAMIC_MSG = ', or for dynamic strings that contain ' \
-                      'double quotes'.freeze
-        SINGLE_QUOTE = "'".freeze
-        QUOTE = '"'.freeze
-        EMPTY = ''.freeze
-        PERCENT_Q = '%q'.freeze
-        PERCENT_CAPITAL_Q = '%Q'.freeze
-        STRING_INTERPOLATION_REGEXP = /#\{.+}/
-        ESCAPED_NON_BACKSLASH = /\\[^\\]/
+                      'double quotes'
+        SINGLE_QUOTE = "'"
+        QUOTE = '"'
+        EMPTY = ''
+        PERCENT_Q = '%q'
+        PERCENT_CAPITAL_Q = '%Q'
+        STRING_INTERPOLATION_REGEXP = /#\{.+\}/.freeze
+        ESCAPED_NON_BACKSLASH = /\\[^\\]/.freeze
 
         def on_dstr(node)
+          return unless string_literal?(node)
+
           check(node)
         end
 
@@ -26,9 +41,19 @@ module RuboCop
           # will call `on_dstr` for the entire string and `on_str` for the
           # non interpolated portion of the string
           return unless string_literal?(node)
+
           check(node)
         end
 
+        def autocorrect(node)
+          delimiter =
+            /^%Q[^"]+$|'/.match?(node.source) ? QUOTE : SINGLE_QUOTE
+          lambda do |corrector|
+            corrector.replace(node.loc.begin, delimiter)
+            corrector.replace(node.loc.end, delimiter)
+          end
+        end
+
         private
 
         def check(node)
@@ -55,16 +80,7 @@ module RuboCop
                   else
                     EMPTY
                   end
-          format(MSG, src[0, 2], extra)
-        end
-
-        def autocorrect(node)
-          delimiter =
-            node.source =~ /^%Q[^"]+$|'/ ? QUOTE : SINGLE_QUOTE
-          lambda do |corrector|
-            corrector.replace(node.loc.begin, delimiter)
-            corrector.replace(node.loc.end, delimiter)
-          end
+          format(MSG, q_type: src[0, 2], extra: extra)
         end
 
         def string_literal?(node)
@@ -79,15 +95,15 @@ module RuboCop
         def acceptable_q?(node)
           src = node.source
 
-          return true if src =~ STRING_INTERPOLATION_REGEXP
+          return true if STRING_INTERPOLATION_REGEXP.match?(src)
 
-          src.scan(/\\./).any? { |s| s =~ ESCAPED_NON_BACKSLASH }
+          src.scan(/\\./).any? { |s| ESCAPED_NON_BACKSLASH.match?(s) }
         end
 
         def acceptable_capital_q?(node)
           src = node.source
           src.include?(QUOTE) &&
-            (src =~ STRING_INTERPOLATION_REGEXP ||
+            (STRING_INTERPOLATION_REGEXP.match?(src) ||
             (node.str_type? && double_quotes_required?(src)))
         end
       end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for unnecessary single-element Regexp character classes.
+      #
+      # @example
+      #
+      #   # bad
+      #   r = /[x]/
+      #
+      #   # good
+      #   r = /x/
+      #
+      #   # bad
+      #   r = /[\s]/
+      #
+      #   # good
+      #   r = /\s/
+      #
+      #   # good
+      #   r = /[ab]/
+      class RedundantRegexpCharacterClass < Cop
+        include MatchRange
+        include RegexpLiteralHelp
+
+        MSG_REDUNDANT_CHARACTER_CLASS = 'Redundant single-element character class, ' \
+        '`%<char_class>s` can be replaced with `%<element>s`.'
+
+        PATTERN = /
+          (
+            (?<!\\)           # No \-prefix (i.e. not escaped)
+            \[                # Literal [
+            (?!\#\{)          # Not (the start of) an interpolation
+            (?:               # Either...
+             \\[^b] |         # Any escaped character except b (which would change behaviour)
+             [^.*+?{}()|$] |  # or one that doesn't require escaping outside the character class
+             \\[upP]\{[^}]+\} # or a unicode code-point or property
+            )
+            (?<!\\)           # No \-prefix (i.e. not escaped)
+            \]                # Literal ]
+          )
+        /x.freeze
+
+        def on_regexp(node)
+          each_redundant_character_class(node) do |loc|
+            next if whitespace_in_free_space_mode?(node, loc)
+
+            add_offense(
+              node,
+              location: loc,
+              message: format(
+                MSG_REDUNDANT_CHARACTER_CLASS,
+                char_class: loc.source,
+                element: without_character_class(loc)
+              )
+            )
+          end
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            each_redundant_character_class(node) do |loc|
+              corrector.replace(loc, without_character_class(loc))
+            end
+          end
+        end
+
+        def each_redundant_character_class(node)
+          pattern_source(node).scan(PATTERN) do
+            yield match_range(node.loc.begin.end, Regexp.last_match)
+          end
+        end
+
+        private
+
+        def without_character_class(loc)
+          loc.source[1..-2]
+        end
+
+        def whitespace_in_free_space_mode?(node, loc)
+          return false unless freespace_mode_regexp?(node)
+
+          /\[\s\]/.match?(loc.source)
+        end
+      end
+    end
+  end
+end