rubocop 0.82.0 → 0.86.0

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

@@ -5,7 +5,7 @@ module RuboCop
     module Style
       # This cop checks for uses of `each_key` and `each_value` Hash methods.
       #
-      # Note: If you have an array of two-element arrays, you can put
+      # NOTE: If you have an array of two-element arrays, you can put
       #   parentheses around the block arguments to indicate that you're not
       #   working with a hash, and suppress RuboCop offenses.
       #

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

@@ -13,11 +13,11 @@ module RuboCop
       # The supported styles are:
       #
       # * ruby19 - forces use of the 1.9 syntax (e.g. `{a: 1}`) when hashes have
-      #   all symbols for keys
+      # all symbols for keys
       # * hash_rockets - forces use of hash rockets for all hashes
       # * no_mixed_keys - simply checks for hashes with mixed syntaxes
       # * ruby19_no_mixed_keys - forces use of ruby 1.9 syntax and forbids mixed
-      #   syntax hashes
+      # syntax hashes
       #
       # @example EnforcedStyle: ruby19 (default)
       #   # bad
@@ -168,11 +168,7 @@ module RuboCop
         end
 
         def autocorrect_ruby19(corrector, pair_node)
-          key = pair_node.key.source_range
-          op = pair_node.loc.operator
-
-          range = key.join(op)
-          range = range_with_surrounding_space(range: range, side: :right)
+          range = range_for_autocorrect_ruby19(pair_node)
 
           space = argument_without_space?(pair_node.parent) ? ' ' : ''
 
@@ -180,6 +176,19 @@ module RuboCop
             range,
             range.source.sub(/^:(.*\S)\s*=>\s*$/, space.to_s + '\1: ')
           )
+
+          hash_node = pair_node.parent
+          return unless hash_node.parent&.return_type? && !hash_node.braces?
+
+          corrector.wrap(hash_node, '{', '}')
+        end
+
+        def range_for_autocorrect_ruby19(pair_node)
+          key = pair_node.key.source_range
+          operator = pair_node.loc.operator
+
+          range = key.join(operator)
+          range_with_surrounding_space(range: range, side: :right)
         end
 
         def argument_without_space?(node)

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

@@ -81,7 +81,7 @@ module RuboCop
 
         private
 
-        def check_branches(branches)
+        def check_branches(branches) # rubocop:todo Metrics/CyclomaticComplexity
           # return if any branch is empty. An empty branch can be an `if`
           # without an `else` or a branch that contains only comments.
           return if branches.any?(&:nil?)

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

@@ -61,7 +61,7 @@ module RuboCop
       class IfInsideElse < Cop
         MSG = 'Convert `if` nested inside `else` to `elsif`.'
 
-        def on_if(node)
+        def on_if(node) # rubocop:todo Metrics/CyclomaticComplexity
           return if node.ternary? || node.unless?
 
           else_branch = node.else_branch

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

@@ -19,11 +19,27 @@ module RuboCop
         MSG = 'Do not use if x; Use the ternary operator instead.'
 
         def on_normal_if_unless(node)
+          return unless node.else_branch
+
           beginning = node.loc.begin
           return unless beginning&.is?(';')
 
           add_offense(node)
         end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node, correct_to_ternary(node))
+          end
+        end
+
+        private
+
+        def correct_to_ternary(node)
+          else_code = node.else_branch ? node.else_branch.source : 'nil'
+
+          "#{node.condition.source} ? #{node.if_branch.source} : #{else_code}"
+        end
       end
     end
   end

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

@@ -23,7 +23,7 @@ module RuboCop
         def investigate(processed_source)
           processed_source.each_comment do |comment|
             next if comment_line?(processed_source[comment.loc.line - 1]) ||
-                    comment.text.match(/\A# rubocop:(enable|disable)/)
+                    comment.text.match?(/\A# rubocop:(enable|disable)/)
 
             add_offense(comment)
           end

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

@@ -178,7 +178,7 @@ module RuboCop
         end
 
         def camel_case_constant?(node)
-          node.const_type? && node.source =~ CAMEL_CASE
+          node.const_type? && CAMEL_CASE.match?(node.source)
         end
 
         def dot_range(loc)

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

@@ -34,7 +34,7 @@ module RuboCop
           # shortcut out if the string does not look like an IP address
           return false unless could_be_ip?(contents)
 
-          contents =~ ::Resolv::IPv4::Regex || contents =~ ::Resolv::IPv6::Regex
+          ::Resolv::IPv4::Regex.match?(contents) || ::Resolv::IPv6::Regex.match?(contents)
         end
 
         # Dummy implementation of method in ConfigurableEnforcedStyle that is

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

@@ -52,26 +52,6 @@ module RuboCop
             implicit_style? && !node.implicit_call?
         end
 
-        def add_parentheses(node, corrector)
-          if node.arguments.empty?
-            corrector.insert_after(node, '()')
-          else
-            corrector.replace(args_begin(node), '(')
-            corrector.insert_after(args_end(node), ')')
-          end
-        end
-
-        def args_begin(node)
-          loc = node.loc
-          selector =
-            node.super_type? || node.yield_type? ? loc.keyword : loc.selector
-          selector.end.resize(1)
-        end
-
-        def args_end(node)
-          node.loc.expression.end
-        end
-
         def message(_node)
           if explicit_style?
             'Prefer the use of `lambda.call(...)` over `lambda.(...)`.'

data/lib/rubocop/cop/style/method_call_with_args_parentheses/require_parentheses.rb

@@ -22,9 +22,7 @@ module RuboCop
             lambda do |corrector|
               corrector.replace(args_begin(node), '(')
 
-              unless args_parenthesized?(node)
-                corrector.insert_after(args_end(node), ')')
-              end
+              corrector.insert_after(args_end(node), ')') unless args_parenthesized?(node)
             end
           end
 

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

@@ -41,9 +41,7 @@ module RuboCop
 
         def same_name_assignment?(node)
           any_assignment?(node) do |asgn_node|
-            if asgn_node.masgn_type?
-              next variable_in_mass_assignment?(node.method_name, asgn_node)
-            end
+            next variable_in_mass_assignment?(node.method_name, asgn_node) if asgn_node.masgn_type?
 
             asgn_node.loc.name.source == node.method_name.to_s
           end

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

@@ -42,7 +42,7 @@ module RuboCop
         private
 
         def non_modifier_then?(node)
-          node.loc.begin && node.loc.begin.source_line =~ NON_MODIFIER_THEN
+          NON_MODIFIER_THEN.match?(node.loc.begin&.source_line)
         end
       end
     end

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

@@ -82,7 +82,7 @@ module RuboCop
         end
 
         def keyword_end_str(node, node_buf)
-          if /[^\s\)]/.match?(node_buf.source_line(node.loc.end.line))
+          if /[^\s)]/.match?(node_buf.source_line(node.loc.end.line))
             "\n" + (' ' * node.loc.column) + 'end'
           else
             'end'

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

@@ -17,12 +17,11 @@ module RuboCop
       #
       #   # good
       #   a = cond ? b : c
-      #   a =
-      #     if cond
-      #       b
-      #     else
-      #       c
-      #     end
+      #   a = if cond
+      #     b
+      #   else
+      #     c
+      #   end
       class MultilineTernaryOperator < Cop
         MSG = 'Avoid multi-line ternary operators, ' \
               'use `if` or `unless` instead.'
@@ -32,6 +31,18 @@ module RuboCop
 
           add_offense(node)
         end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            corrector.replace(node, <<~RUBY.chop)
+              if #{node.condition.source}
+                #{node.if_branch.source}
+              else
+                #{node.else_branch.source}
+              end
+            RUBY
+          end
+        end
       end
     end
   end

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

@@ -22,6 +22,12 @@ module RuboCop
       #   when bar then do_something
       #   end
       #
+      #   # good
+      #   case foo
+      #   when bar then do_something(arg1,
+      #                              arg2)
+      #   end
+      #
       class MultilineWhenThen < Cop
         include RangeHelp
 
@@ -32,7 +38,10 @@ module RuboCop
           return unless node.then?
 
           # Single line usage of `then` is not an offense
-          return if !node.children.last.nil? && !node.multiline? && node.then?
+          return if !node.children.last.nil? && !node.multiline?
+
+          # Requires `then` for write `when` and its body on the same line.
+          return if require_then?(node)
 
           # With more than one statements after then, there's not offense
           return if accept_node_type?(node.body)
@@ -50,6 +59,12 @@ module RuboCop
           end
         end
 
+        def require_then?(when_node)
+          return false unless when_node.body
+
+          when_node.loc.line == when_node.body.loc.line
+        end
+
         def accept_node_type?(node)
           node&.begin_type? || node&.array_type? || node&.hash_type?
         end

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

@@ -6,9 +6,9 @@ module RuboCop
       # Checks for uses of if with a negated condition. Only ifs
       # without else are considered. There are three different styles:
       #
-      #   - both
-      #   - prefix
-      #   - postfix
+      # * both
+      # * prefix
+      # * postfix
       #
       # @example EnforcedStyle: both (default)
       #   # enforces `unless` for `prefix` and `postfix` conditionals

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

@@ -6,9 +6,9 @@ module RuboCop
       # Checks for uses of unless with a negated condition. Only unless
       # without else are considered. There are three different styles:
       #
-      #   - both
-      #   - prefix
-      #   - postfix
+      # * both
+      # * prefix
+      # * postfix
       #
       # @example EnforcedStyle: both (default)
       #   # enforces `if` for `prefix` and `postfix` conditionals

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/optional_arguments.rb

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Style
       # This cop checks for optional arguments to methods
-      # that do not come at the end of the argument list
+      # that do not come at the end of the argument list.
       #
       # @example
       #   # bad

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/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_fetch_block.rb

@@ -0,0 +1,103 @@
+# 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)
+            ${#basic_literal? const_type?})
+        PATTERN
+
+        def on_block(node)
+          redundant_fetch_block_candidate?(node) do |send, body|
+            return if body.const_type? && !check_for_constant?
+            return if body.str_type? && !check_for_string?
+
+            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
+              corrector.replace(node, "#{receiver.source}.fetch(#{key.source}, #{body.source})")
+            end
+          end
+        end
+
+        private
+
+        def basic_literal?(node)
+          node.basic_literal?
+        end
+
+        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
+          "fetch(#{key}, #{body.source})"
+        end
+
+        def build_bad_method(send, body)
+          key = send.children[2].source
+          "fetch(#{key}) { #{body.source} }"
+        end
+
+        def check_for_constant?
+          cop_config['SafeForConstants']
+        end
+
+        def check_for_string?
+          frozen_string_literals_enabled?
+        end
+      end
+    end
+  end
+end