rubocop 0.83.0 → 0.87.0

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

@@ -26,6 +26,33 @@ module RuboCop
             add_offense(nested_ternary)
           end
         end
+
+        def autocorrect(node)
+          if_node = if_node(node)
+
+          lambda do |corrector|
+            corrector.replace(if_node, <<~RUBY.chop)
+              if #{if_node.condition.source}
+                #{remove_parentheses(if_node.if_branch.source)}
+              else
+                #{if_node.else_branch.source}
+              end
+            RUBY
+          end
+        end
+
+        private
+
+        def if_node(node)
+          node = node.parent
+          return node if node.if_type?
+
+          if_node(node)
+        end
+
+        def remove_parentheses(source)
+          source.gsub(/\A\(/, '').gsub(/\)\z/, '')
+        end
       end
     end
   end

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

@@ -191,7 +191,7 @@ module RuboCop
         end
 
         def end_followed_by_whitespace_only?(source_buffer, end_pos)
-          source_buffer.source[end_pos..-1] =~ /\A\s*$/
+          /\A\s*$/.match?(source_buffer.source[end_pos..-1])
         end
 
         def reindentable_lines(node)
@@ -201,7 +201,7 @@ module RuboCop
           lines = (node.source_range.line + 1)...node.loc.end.line
           lines = lines.to_a - heredoc_lines(node)
           # Skip blank lines
-          lines.reject { |lineno| buffer.source_line(lineno) =~ /\A\s*\z/ }
+          lines.reject { |lineno| /\A\s*\z/.match?(buffer.source_line(lineno)) }
         end
 
         # Adjust indentation of `lines` to match `node`

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

@@ -11,7 +11,7 @@ module RuboCop
       #
       # With `IncludeSemanticChanges` set to `true`, this cop reports offenses
       # for `!x.nil?` and autocorrects that and `x != nil` to solely `x`, which
-      # is **usually** OK, but might change behavior.
+      # is *usually* OK, but might change behavior.
       #
       # @example
       #   # bad

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

@@ -77,9 +77,9 @@ module RuboCop
         end
 
         def octal_literal_type(literal)
-          if literal =~ OCTAL_ZERO_ONLY_REGEX && octal_zero_only?
+          if OCTAL_ZERO_ONLY_REGEX.match?(literal) && octal_zero_only?
             :octal_zero_only
-          elsif literal =~ OCTAL_REGEX && !octal_zero_only?
+          elsif OCTAL_REGEX.match?(literal) && !octal_zero_only?
             :octal
           end
         end

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

@@ -49,13 +49,9 @@ module RuboCop
         def replacement(node)
           return to_ternary(node) unless node.parent
 
-          if %i[and or].include?(node.parent.type)
-            return "(#{to_ternary(node)})"
-          end
+          return "(#{to_ternary(node)})" if %i[and or].include?(node.parent.type)
 
-          if node.parent.send_type? && node.parent.operator_method?
-            return "(#{to_ternary(node)})"
-          end
+          return "(#{to_ternary(node)})" if node.parent.send_type? && node.parent.operator_method?
 
           to_ternary(node)
         end

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

@@ -102,7 +102,7 @@ module RuboCop
           delimiters_regexp = Regexp.union(delimiters)
           node
             .children.map { |n| string_source(n) }.compact
-            .any? { |s| delimiters_regexp =~ s }
+            .any? { |s| delimiters_regexp.match?(s) }
         end
 
         def string_source(node)

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

@@ -17,7 +17,7 @@ module RuboCop
         MSG = 'Use `proc` instead of `Proc.new`.'
 
         def_node_matcher :proc_new?,
-                         '(block $(send (const nil? :Proc) :new) ...)'
+                         '(block $(send (const {nil? cbase} :Proc) :new) ...)'
 
         def on_block(node)
           proc_new?(node) do |block_method|

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

@@ -31,7 +31,7 @@ module RuboCop
           (send
             int {:+ :-}
             (send
-              {nil? (const nil? :Random) (const nil? :Kernel)}
+              {nil? (const {nil? cbase} :Random) (const {nil? cbase} :Kernel)}
               :rand
               {int irange erange}))
         PATTERN
@@ -39,7 +39,7 @@ module RuboCop
         def_node_matcher :rand_op_integer?, <<~PATTERN
           (send
             (send
-              {nil? (const nil? :Random) (const nil? :Kernel)}
+              {nil? (const {nil? cbase} :Random) (const {nil? cbase} :Kernel)}
               :rand
               {int irange erange})
             {:+ :-}
@@ -49,7 +49,7 @@ module RuboCop
         def_node_matcher :rand_modified?, <<~PATTERN
           (send
             (send
-              {nil? (const nil? :Random) (const nil? :Kernel)}
+              {nil? (const {nil? cbase} :Random) (const {nil? cbase} :Kernel)}
               :rand
               {int irange erange})
             {:succ :pred :next})
@@ -128,14 +128,8 @@ module RuboCop
           end
         end
 
-        def_node_matcher :namespace, <<~PATTERN
-          {$nil? (const nil? $_)}
-        PATTERN
-
         def prefix_from_prefix_node(node)
-          namespace(node) do |namespace|
-            [namespace, 'rand'].compact.join('.')
-          end
+          [node&.source, 'rand'].compact.join('.')
         end
 
         def boundaries_from_random_node(random_node)

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for redundant assignment before returning.
+      #
+      # @example
+      #   # bad
+      #   def test
+      #     x = foo
+      #     x
+      #   end
+      #
+      #   # bad
+      #   def test
+      #     if x
+      #       z = foo
+      #       z
+      #     elsif y
+      #       z = bar
+      #       z
+      #     end
+      #   end
+      #
+      #   # good
+      #   def test
+      #     foo
+      #   end
+      #
+      #   # good
+      #   def test
+      #     if x
+      #       foo
+      #     elsif y
+      #       bar
+      #     end
+      #   end
+      #
+      class RedundantAssignment < Cop
+        MSG = 'Redundant assignment before returning detected.'
+
+        def_node_matcher :redundant_assignment?, <<~PATTERN
+          (... $(lvasgn _name _expression) (lvar _name))
+        PATTERN
+
+        def on_def(node)
+          check_branch(node.body)
+        end
+        alias on_defs on_def
+
+        def autocorrect(node)
+          lambda do |corrector|
+            expression = node.children[1]
+            corrector.replace(node, expression.source)
+            corrector.remove(right_sibling_of(node))
+          end
+        end
+
+        private
+
+        def check_branch(node)
+          return unless node
+
+          case node.type
+          when :case   then check_case_node(node)
+          when :if     then check_if_node(node)
+          when :rescue, :resbody
+            check_rescue_node(node)
+          when :ensure then check_ensure_node(node)
+          when :begin, :kwbegin
+            check_begin_node(node)
+          end
+        end
+
+        def check_case_node(node)
+          node.when_branches.each { |when_node| check_branch(when_node.body) }
+          check_branch(node.else_branch)
+        end
+
+        def check_if_node(node)
+          return if node.modifier_form? || node.ternary?
+
+          check_branch(node.if_branch)
+          check_branch(node.else_branch)
+        end
+
+        def check_rescue_node(node)
+          node.child_nodes.each do |child_node|
+            check_branch(child_node)
+          end
+        end
+
+        def check_ensure_node(node)
+          check_branch(node.body)
+        end
+
+        def check_begin_node(node)
+          if (assignment = redundant_assignment?(node))
+            add_offense(assignment)
+          else
+            last_expr = node.children.last
+            check_branch(last_expr)
+          end
+        end
+
+        def right_sibling_of(node)
+          siblings_of(node)[node.sibling_index + 1]
+        end
+
+        def siblings_of(node)
+          node.parent.children
+        end
+      end
+    end
+  end
+end

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

@@ -27,7 +27,8 @@ module RuboCop
       class RedundantConditional < Cop
         include Alignment
 
-        COMPARISON_OPERATORS = RuboCop::AST::Node::COMPARISON_OPERATORS
+        operators = RuboCop::AST::Node::COMPARISON_OPERATORS.to_a
+        COMPARISON_OPERATOR_MATCHER = "{:#{operators.join(' :')}}"
 
         MSG = 'This conditional expression can just be replaced ' \
               'by `%<msg>s`.'
@@ -54,11 +55,11 @@ module RuboCop
         end
 
         def_node_matcher :redundant_condition?, <<~RUBY
-          (if (send _ {:#{COMPARISON_OPERATORS.join(' :')}} _) true false)
+          (if (send _ #{COMPARISON_OPERATOR_MATCHER} _) true false)
         RUBY
 
         def_node_matcher :redundant_condition_inverted?, <<~RUBY
-          (if (send _ {:#{COMPARISON_OPERATORS.join(' :')}} _) false true)
+          (if (send _ #{COMPARISON_OPERATOR_MATCHER} _) false true)
         RUBY
 
         def offense?(node)

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

@@ -16,21 +16,22 @@ module RuboCop
       #
       #   # Good
       #   raise 'message'
-      class RedundantException < Cop
+      class RedundantException < Base
+        extend AutoCorrector
+
         MSG_1 = 'Redundant `RuntimeError` argument can be removed.'
         MSG_2 = 'Redundant `RuntimeError.new` call can be replaced with ' \
                 'just the message.'
 
+        # Switch `raise RuntimeError, 'message'` to `raise 'message'`, and
+        # `raise RuntimeError.new('message')` to `raise 'message'`.
         def on_send(node)
-          exploded?(node) { return add_offense(node, message: MSG_1) }
-          compact?(node) { add_offense(node, message: MSG_2) }
+          fix_exploded(node) || fix_compact(node)
         end
 
-        # Switch `raise RuntimeError, 'message'` to `raise 'message'`, and
-        # `raise RuntimeError.new('message')` to `raise 'message'`.
-        def autocorrect(node) # rubocop:disable Metrics/MethodLength
+        def fix_exploded(node)
           exploded?(node) do |command, message|
-            return lambda do |corrector|
+            add_offense(node, message: MSG_1) do |corrector|
               if node.parenthesized?
                 corrector.replace(node,
                                   "#{command}(#{message.source})")
@@ -40,19 +41,22 @@ module RuboCop
               end
             end
           end
+        end
+
+        def fix_compact(node)
           compact?(node) do |new_call, message|
-            lambda do |corrector|
+            add_offense(node, message: MSG_2) do |corrector|
               corrector.replace(new_call, message.source)
             end
           end
         end
 
         def_node_matcher :exploded?, <<~PATTERN
-          (send nil? ${:raise :fail} (const nil? :RuntimeError) $_)
+          (send nil? ${:raise :fail} (const {nil? cbase} :RuntimeError) $_)
         PATTERN
 
         def_node_matcher :compact?, <<~PATTERN
-          (send nil? {:raise :fail} $(send (const nil? :RuntimeError) :new $_))
+          (send nil? {:raise :fail} $(send (const {nil? cbase} :RuntimeError) :new $_))
         PATTERN
       end
     end

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