rubocop 0.78.0 → 1.13.0

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

@@ -28,7 +28,14 @@ module RuboCop
       #   end
       #
       #   # bad
-      #   # When using Ruby 2.5 or later.
+      #   begin
+      #     do_something
+      #   end
+      #
+      #   # good
+      #   do_something
+      #
+      #   # bad
       #   do_something do
       #     begin
       #       something
@@ -54,36 +61,95 @@ module RuboCop
       #       baz
       #     end
       #   end
-      class RedundantBegin < Cop
+      class RedundantBegin < Base
+        include RangeHelp
+        extend AutoCorrector
+
         MSG = 'Redundant `begin` block detected.'
 
         def on_def(node)
-          check(node)
+          return unless node.body&.kwbegin_type?
+
+          register_offense(node.body)
         end
         alias on_defs on_def
 
         def on_block(node)
-          return if target_ruby_version < 2.5
-
           return if node.send_node.lambda_literal?
           return if node.braces?
+          return unless node.body&.kwbegin_type?
 
-          check(node)
+          register_offense(node.body)
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.remove(node.loc.begin)
+        def on_kwbegin(node)
+          return if empty_begin?(node) ||
+                    contain_rescue_or_ensure?(node) ||
+                    valid_context_using_only_begin?(node)
+
+          register_offense(node)
+        end
+
+        private
+
+        def register_offense(node)
+          offense_range = node.loc.begin
+
+          add_offense(offense_range) do |corrector|
+            if any_ancestor_assignment_node?(node)
+              replace_begin_with_statement(corrector, offense_range, node)
+            else
+              corrector.remove(offense_range)
+            end
+
             corrector.remove(node.loc.end)
           end
         end
 
-        private
+        def replace_begin_with_statement(corrector, offense_range, node)
+          first_child = node.children.first
 
-        def check(node)
-          return unless node.body&.kwbegin_type?
+          source = first_child.source
+          source = "(#{source})" if first_child.if_type?
+
+          corrector.replace(offense_range, source)
+          corrector.remove(range_between(offense_range.end_pos, first_child.source_range.end_pos))
+
+          restore_removed_comments(corrector, offense_range, node, first_child)
+        end
+
+        # Restore comments that occur between "begin" and "first_child".
+        # These comments will be moved to above the assignment line.
+        def restore_removed_comments(corrector, offense_range, node, first_child)
+          comments_range = range_between(offense_range.end_pos, first_child.source_range.begin_pos)
+          comments = comments_range.source
+
+          corrector.insert_before(node.parent, comments) unless comments.blank?
+        end
+
+        def empty_begin?(node)
+          node.children.empty?
+        end
+
+        def contain_rescue_or_ensure?(node)
+          first_child = node.children.first
+
+          first_child.rescue_type? || first_child.ensure_type?
+        end
+
+        def valid_context_using_only_begin?(node)
+          parent = node.parent
+
+          valid_begin_assignment?(node) || parent&.post_condition_loop? ||
+            parent&.send_type? || parent&.operator_keyword?
+        end
+
+        def valid_begin_assignment?(node)
+          any_ancestor_assignment_node?(node) && !node.children.one?
+        end
 
-          add_offense(node.body, location: :begin)
+        def any_ancestor_assignment_node?(node)
+          node.each_ancestor.any?(&:assignment?)
         end
       end
     end

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

@@ -14,29 +14,25 @@ module RuboCop
       #   %w/swim run bike/
       #   %w[shirt pants shoes]
       #   %W(apple #{fruit} grape)
-      class RedundantCapitalW < Cop
+      class RedundantCapitalW < Base
         include PercentLiteral
+        extend AutoCorrector
 
-        MSG = 'Do not use `%W` unless interpolation is needed. ' \
-              'If not, use `%w`.'
+        MSG = 'Do not use `%W` unless interpolation is needed. If not, use `%w`.'
 
         def on_array(node)
           process(node, '%W')
         end
 
-        def autocorrect(node)
-          lambda do |corrector|
-            src = node.loc.begin.source
-            corrector.replace(node.loc.begin, src.tr('W', 'w'))
-          end
-        end
-
         private
 
         def on_percent_literal(node)
           return if requires_interpolation?(node)
 
-          add_offense(node)
+          add_offense(node) do |corrector|
+            src = node.loc.begin.source
+            corrector.replace(node.loc.begin, src.tr('W', 'w'))
+          end
         end
 
         def requires_interpolation?(node)

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

@@ -30,8 +30,9 @@ module RuboCop
       #     c
       #   end
       #
-      class RedundantCondition < Cop
+      class RedundantCondition < Base
         include RangeHelp
+        extend AutoCorrector
 
         MSG = 'Use double pipes `||` instead.'
         REDUNDANT_CONDITION = 'This condition is not needed.'
@@ -40,19 +41,17 @@ module RuboCop
           return if node.elsif_conditional?
           return unless offense?(node)
 
-          add_offense(node, location: range_of_offense(node))
-        end
+          message = message(node)
 
-        def autocorrect(node)
-          lambda do |corrector|
+          add_offense(range_of_offense(node), message: message) do |corrector|
             if node.ternary?
-              corrector.replace(range_of_offense(node), '||')
+              correct_ternary(corrector, node)
             elsif node.modifier_form? || !node.else_branch
-              corrector.replace(node.source_range, node.if_branch.source)
+              corrector.replace(node, node.if_branch.source)
             else
               corrected = make_ternary_form(node)
 
-              corrector.replace(node.source_range, corrected)
+              corrector.replace(node, corrected)
             end
           end
         end
@@ -68,7 +67,7 @@ module RuboCop
         end
 
         def range_of_offense(node)
-          return :expression unless node.ternary?
+          return node.loc.expression unless node.ternary?
 
           range_between(node.loc.question.begin_pos, node.loc.colon.end_pos)
         end
@@ -76,12 +75,10 @@ module RuboCop
         def offense?(node)
           condition, if_branch, else_branch = *node
 
-          return false if use_if_branch?(else_branch)
+          return false if use_if_branch?(else_branch) || use_hash_key_assignment?(else_branch)
 
           condition == if_branch && !node.elsif? && (
-            node.ternary? ||
-            !else_branch.instance_of?(AST::Node) ||
-            else_branch.single_line?
+            node.ternary? || !else_branch.instance_of?(AST::Node) || else_branch.single_line?
           )
         end
 
@@ -89,16 +86,23 @@ module RuboCop
           else_branch&.if_type?
         end
 
+        def use_hash_key_assignment?(else_branch)
+          else_branch&.send_type? && else_branch&.method?(:[]=)
+        end
+
         def else_source(else_branch)
-          wrap_else =
-            else_branch.basic_conditional? && else_branch.modifier_form?
-          wrap_else ? "(#{else_branch.source})" : else_branch.source
+          if require_parentheses?(else_branch)
+            "(#{else_branch.source})"
+          elsif without_argument_parentheses_method?(else_branch)
+            "#{else_branch.method_name}(#{else_branch.arguments.map(&:source).join(', ')})"
+          else
+            else_branch.source
+          end
         end
 
         def make_ternary_form(node)
           _condition, if_branch, else_branch = *node
-          ternary_form = [if_branch.source,
-                          else_source(else_branch)].join(' || ')
+          ternary_form = [if_branch.source, else_source(else_branch)].join(' || ')
 
           if node.parent&.send_type?
             "(#{ternary_form})"
@@ -106,6 +110,27 @@ module RuboCop
             ternary_form
           end
         end
+
+        def correct_ternary(corrector, node)
+          corrector.replace(range_of_offense(node), '||')
+
+          return unless node.else_branch.range_type?
+
+          corrector.wrap(node.else_branch, '(', ')')
+        end
+
+        def require_parentheses?(node)
+          node.basic_conditional? &&
+            node.modifier_form? ||
+            node.range_type? ||
+            node.rescue_type? ||
+            node.respond_to?(:semantic_operator?) && node.semantic_operator?
+        end
+
+        def without_argument_parentheses_method?(node)
+          node.send_type? &&
+            !node.arguments.empty? && !node.parenthesized? && !node.operator_method?
+        end
       end
     end
   end

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

@@ -24,23 +24,22 @@ module RuboCop
       #
       #   # good
       #   x != y
-      class RedundantConditional < Cop
+      class RedundantConditional < Base
         include Alignment
+        extend AutoCorrector
 
-        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`.'
+        MSG = 'This conditional expression can just be replaced by `%<msg>s`.'
 
         def on_if(node)
           return unless offense?(node)
 
-          add_offense(node)
-        end
+          message = message(node)
 
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node.loc.expression, replacement_condition(node))
+          add_offense(node, message: message) do |corrector|
+            corrector.replace(node, replacement_condition(node))
           end
         end
 
@@ -53,12 +52,14 @@ module RuboCop
           format(MSG, msg: msg)
         end
 
+        # @!method redundant_condition?(node)
         def_node_matcher :redundant_condition?, <<~RUBY
-          (if (send _ {:#{COMPARISON_OPERATORS.join(' :')}} _) true false)
+          (if (send _ #{COMPARISON_OPERATOR_MATCHER} _) true false)
         RUBY
 
+        # @!method redundant_condition_inverted?(node)
         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)
@@ -76,11 +77,9 @@ module RuboCop
 
         def invert_expression?(node)
           (
-            (node.if? || node.elsif? || node.ternary?) &&
-            redundant_condition_inverted?(node)
+            (node.if? || node.elsif? || node.ternary?) && redundant_condition_inverted?(node)
           ) || (
-            node.unless? &&
-            redundant_condition?(node)
+            node.unless? && redundant_condition?(node)
           )
         end
 

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

@@ -16,43 +16,48 @@ 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.'
+        MSG_2 = 'Redundant `RuntimeError.new` call can be replaced with just the message.'
 
-        def on_send(node)
-          exploded?(node) { return add_offense(node, message: MSG_1) }
-          compact?(node) { add_offense(node, message: MSG_2) }
-        end
+        RESTRICT_ON_SEND = %i[raise fail].freeze
 
         # Switch `raise RuntimeError, 'message'` to `raise 'message'`, and
         # `raise RuntimeError.new('message')` to `raise 'message'`.
-        def autocorrect(node) # rubocop:disable Metrics/MethodLength
+        def on_send(node)
+          fix_exploded(node) || fix_compact(node)
+        end
+
+        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.source_range,
-                                  "#{command}(#{message.source})")
+                corrector.replace(node, "#{command}(#{message.source})")
               else
-                corrector.replace(node.source_range,
-                                  "#{command} #{message.source}")
+                corrector.replace(node, "#{command} #{message.source}")
               end
             end
           end
+        end
+
+        def fix_compact(node)
           compact?(node) do |new_call, message|
-            lambda do |corrector|
-              corrector.replace(new_call.source_range, message.source)
+            add_offense(node, message: MSG_2) do |corrector|
+              corrector.replace(new_call, message.source)
             end
           end
         end
 
+        # @!method exploded?(node)
         def_node_matcher :exploded?, <<~PATTERN
-          (send nil? ${:raise :fail} (const nil? :RuntimeError) $_)
+          (send nil? ${:raise :fail} (const {nil? cbase} :RuntimeError) $_)
         PATTERN
 
+        # @!method compact?(node)
         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,115 @@
+# 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 < Base
+        include FrozenStringLiteral
+        include RangeHelp
+        extend AutoCorrector
+
+        MSG = 'Use `%<good>s` instead of `%<bad>s`.'
+
+        # @!method redundant_fetch_block_candidate?(node)
+        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(range, message: format(MSG, good: good, bad: bad)) 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
+
+        # @!method rails_cache?(node)
+        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