rubocop 1.15.0 → 1.18.1

data/lib/rubocop/cop/naming/memoized_instance_variable_name.rb

@@ -147,9 +147,9 @@ module RuboCop
         include ConfigurableEnforcedStyle
 
         MSG = 'Memoized variable `%<var>s` does not match ' \
-          'method name `%<method>s`. Use `@%<suggested_var>s` instead.'
+              'method name `%<method>s`. Use `@%<suggested_var>s` instead.'
         UNDERSCORE_REQUIRED = 'Memoized variable `%<var>s` does not start ' \
-          'with `_`. Use `@%<suggested_var>s` instead.'
+                              'with `_`. Use `@%<suggested_var>s` instead.'
         DYNAMIC_DEFINE_METHODS = %i[define_method define_singleton_method].to_set.freeze
 
         # @!method method_definition?(node)

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

@@ -84,6 +84,7 @@ module RuboCop
         def compact_definition(corrector, node)
           compact_node(corrector, node)
           remove_end(corrector, node.body)
+          unindent(corrector, node)
         end
 
         def compact_node(corrector, node)
@@ -114,6 +115,19 @@ module RuboCop
           corrector.remove(range)
         end
 
+        def configured_indentation_width
+          config.for_badge(Layout::IndentationWidth.badge).fetch('Width', 2)
+        end
+
+        def unindent(corrector, node)
+          return if node.body.children.last.nil?
+
+          column_delta = configured_indentation_width - leading_spaces(node.body.children.last).size
+          return if column_delta.zero?
+
+          AlignmentCorrector.correct(corrector, processed_source, node, column_delta)
+        end
+
         def leading_spaces(node)
           node.source_range.source_line[/\A\s*/]
         end

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

@@ -17,6 +17,11 @@ module RuboCop
       #   # good
       #   hash.each_key { |k| p k }
       #   hash.each_value { |v| p v }
+      #
+      # @example AllowedReceivers: ['execute']
+      #   # good
+      #   execute(sql).keys.each { |v| p v }
+      #   execute(sql).values.each { |v| p v }
       class HashEachMethods < Base
         include Lint::UnusedArgument
         extend AutoCorrector
@@ -36,7 +41,9 @@ module RuboCop
 
         def register_kv_offense(node)
           kv_each(node) do |target, method|
-            return unless target.receiver.receiver
+            parent_receiver = target.receiver.receiver
+            return unless parent_receiver
+            return if allowed_receiver?(parent_receiver)
 
             msg = format(message, prefer: "each_#{method[0..-2]}", current: "#{method}.each")
 
@@ -80,6 +87,16 @@ module RuboCop
         def kv_range(outer_node)
           outer_node.receiver.loc.selector.join(outer_node.loc.selector)
         end
+
+        def allowed_receiver?(receiver)
+          receiver_name = receiver.send_type? ? receiver.method_name.to_s : receiver.source
+
+          allowed_receivers.include?(receiver_name)
+        end
+
+        def allowed_receivers
+          cop_config.fetch('AllowedReceivers', [])
+        end
       end
     end
   end

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

@@ -67,40 +67,90 @@ module RuboCop
       #     do_x
       #     do_z
       #   end
+      #
+      #   # bad
+      #   case foo
+      #   in 1
+      #     do_x
+      #   in 2
+      #     do_x
+      #   else
+      #     do_x
+      #   end
+      #
+      #   # good
+      #   case foo
+      #   in 1
+      #     do_x
+      #     do_y
+      #   in 2
+      #     # nothing
+      #   else
+      #     do_x
+      #     do_z
+      #   end
       class IdenticalConditionalBranches < Base
+        include RangeHelp
+        extend AutoCorrector
+
         MSG = 'Move `%<source>s` out of the conditional.'
 
         def on_if(node)
           return if node.elsif?
 
           branches = expand_elses(node.else_branch).unshift(node.if_branch)
-          check_branches(branches)
+          check_branches(node, branches)
         end
 
         def on_case(node)
           return unless node.else? && node.else_branch
 
           branches = node.when_branches.map(&:body).push(node.else_branch)
-          check_branches(branches)
+          check_branches(node, branches)
+        end
+
+        def on_case_match(node)
+          return unless node.else? && node.else_branch
+
+          branches = node.in_pattern_branches.map(&:body).push(node.else_branch)
+          check_branches(node, branches)
         end
 
         private
 
-        def check_branches(branches) # rubocop:todo Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def check_branches(node, branches)
           # 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?)
 
           tails = branches.map { |branch| tail(branch) }
-          check_expressions(tails) if tails.none?(&:nil?)
+          check_expressions(node, tails, :after_condition) if duplicated_expressions?(tails)
+
           heads = branches.map { |branch| head(branch) }
-          check_expressions(heads) if tails.none?(&:nil?)
+          check_expressions(node, heads, :before_condition) if duplicated_expressions?(heads)
         end
 
-        def check_expressions(expressions)
-          return unless expressions.size > 1 && expressions.uniq.one?
+        def duplicated_expressions?(expressions)
+          expressions.size > 1 && expressions.uniq.one?
+        end
 
-          expressions.each { |expression| add_offense(expression) }
+        def check_expressions(node, expressions, insert_position)
+          inserted_expression = false
+
+          expressions.each do |expression|
+            add_offense(expression) do |corrector|
+              range = range_by_whole_lines(expression.source_range, include_final_newline: true)
+              corrector.remove(range)
+              next if inserted_expression
+
+              if insert_position == :after_condition
+                corrector.insert_after(node, "\n#{expression.source}")
+              else
+                corrector.insert_before(node, "#{expression.source}\n")
+              end
+              inserted_expression = true
+            end
+          end
         end
 
         def message(node)

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks for `in;` uses in `case` expressions.
+      #
+      # @example
+      #   # bad
+      #   case expression
+      #   in pattern_a; foo
+      #   in pattern_b; bar
+      #   end
+      #
+      #   # good
+      #   case expression
+      #   in pattern_a then foo
+      #   in pattern_b then bar
+      #   end
+      #
+      class InPatternThen < Base
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.7
+
+        MSG = 'Do not use `in %<pattern>s;`. Use `in %<pattern>s then` instead.'
+
+        def on_in_pattern(node)
+          return if node.multiline? || node.then? || !node.body
+
+          pattern = node.pattern
+          pattern_source = if pattern.match_alt_type?
+                             alternative_pattern_source(pattern)
+                           else
+                             pattern.source
+                           end
+
+          add_offense(node.loc.begin, message: format(MSG, pattern: pattern_source)) do |corrector|
+            corrector.replace(node.loc.begin, ' then')
+          end
+        end
+
+        private
+
+        def alternative_pattern_source(pattern)
+          return pattern.children.map(&:source) unless pattern.children.first.match_alt_type?
+
+          pattern_sources = alternative_pattern_source(pattern.children.first)
+
+          (pattern_sources << pattern.children[1].source).join(' | ')
+        end
+      end
+    end
+  end
+end

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

@@ -116,7 +116,8 @@ module RuboCop
           end
 
           def call_with_braced_block?(node)
-            (node.send_type? || node.super_type?) && node.block_node && node.block_node.braces?
+            (node.send_type? || node.super_type?) &&
+              ((node.parent&.block_type? || node.parent&.numblock_type?) && node.parent&.braces?)
           end
 
           def call_as_argument_or_chain?(node)

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # This cop checks uses of the `then` keyword in multi-line `in` statement.
+      #
+      # @example
+      #   # bad
+      #   case expression
+      #   in pattern then
+      #   end
+      #
+      #   # good
+      #   case expression
+      #   in pattern
+      #   end
+      #
+      #   # good
+      #   case expression
+      #   in pattern then do_something
+      #   end
+      #
+      #   # good
+      #   case expression
+      #   in pattern then do_something(arg1,
+      #                                arg2)
+      #   end
+      #
+      class MultilineInPatternThen < Base
+        include RangeHelp
+        extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.7
+
+        MSG = 'Do not use `then` for multiline `in` statement.'
+
+        def on_in_pattern(node)
+          return if !node.then? || require_then?(node)
+
+          range = node.loc.begin
+          add_offense(range) do |corrector|
+            corrector.remove(
+              range_with_surrounding_space(range: range, side: :left, newlines: false)
+            )
+          end
+        end
+
+        private
+
+        # Requires `then` for write `in` and its body on the same line.
+        def require_then?(in_pattern_node)
+          return true if in_pattern_node.pattern.first_line != in_pattern_node.pattern.last_line
+          return false unless in_pattern_node.body
+
+          in_pattern_node.loc.line == in_pattern_node.body.loc.line
+        end
+      end
+    end
+  end
+end

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

@@ -35,17 +35,7 @@ module RuboCop
         MSG = 'Do not use `then` for multiline `when` statement.'
 
         def on_when(node)
-          # Without `then`, there's no offense
-          return unless node.then?
-
-          # Single line usage of `then` is not an offense
-          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)
-
-          # For arrays and hashes there's no offense
-          return if accept_node_type?(node.body)
+          return if !node.then? || require_then?(node)
 
           range = node.loc.begin
           add_offense(range) do |corrector|
@@ -57,6 +47,7 @@ module RuboCop
 
         private
 
+        # Requires `then` for write `when` and its body on the same line.
         def require_then?(when_node)
           unless when_node.conditions.first.first_line == when_node.conditions.last.last_line
             return true

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

@@ -44,7 +44,7 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Avoid comparing a variable with multiple items ' \
-          'in a conditional, use `Array#include?` instead.'
+              'in a conditional, use `Array#include?` instead.'
 
         def on_new_investigation
           @last_comparison = nil

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

@@ -68,7 +68,7 @@ module RuboCop
           delimiters = preferred_delimiters_for(type)
 
           "`#{type}`-literals should be delimited by " \
-          "`#{delimiters[0]}` and `#{delimiters[1]}`."
+            "`#{delimiters[0]}` and `#{delimiters[1]}`."
         end
 
         def preferred_delimiters_for(type)

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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks if the quotes used for quoted symbols match the configured defaults.
+      # By default uses the same configuration as `Style/StringLiterals`.
+      #
+      # String interpolation is always kept in double quotes.
+      #
+      # Note: `Lint/SymbolConversion` can be used in parallel to ensure that symbols
+      # are not quoted that don't need to be. This cop is for configuring the quoting
+      # style to use for symbols that require quotes.
+      #
+      # @example EnforcedStyle: same_as_string_literals (default) / single_quotes
+      #   # bad
+      #   :"abc-def"
+      #
+      #   # good
+      #   :'abc-def'
+      #   :"#{str}"
+      #   :"a\'b"
+      #
+      # @example EnforcedStyle: double_quotes
+      #   # bad
+      #   :'abc-def'
+      #
+      #   # good
+      #   :"abc-def"
+      #   :"#{str}"
+      #   :"a\'b"
+      class QuotedSymbols < Base
+        include ConfigurableEnforcedStyle
+        include SymbolHelp
+        include StringLiteralsHelp
+        extend AutoCorrector
+
+        MSG_SINGLE = "Prefer single-quoted symbols when you don't need string interpolation " \
+                     'or special symbols.'
+        MSG_DOUBLE = 'Prefer double-quoted symbols unless you need single quotes to ' \
+                     'avoid extra backslashes for escaping.'
+
+        def on_sym(node)
+          return unless quoted?(node)
+
+          message = style == :single_quotes ? MSG_SINGLE : MSG_DOUBLE
+
+          if wrong_quotes?(node)
+            add_offense(node, message: message) do |corrector|
+              opposite_style_detected
+              autocorrect(corrector, node)
+            end
+          else
+            correct_style_detected
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, node)
+          str = if hash_colon_key?(node)
+                  # strip quotes
+                  correct_quotes(node.source[1..-2])
+                else
+                  # strip leading `:` and quotes
+                  ":#{correct_quotes(node.source[2..-2])}"
+                end
+
+          corrector.replace(node, str)
+        end
+
+        def hash_colon_key?(node)
+          # Is the node a hash key with the colon style?
+          hash_key?(node) && node.parent.colon?
+        end
+
+        def correct_quotes(str)
+          if style == :single_quotes
+            to_string_literal(str)
+          else
+            str.inspect
+          end
+        end
+
+        def style
+          return super unless super == :same_as_string_literals
+
+          string_literals_config = config.for_cop('Style/StringLiterals')
+          return :single_quotes unless string_literals_config['Enabled']
+
+          string_literals_config['EnforcedStyle'].to_sym
+        end
+
+        def alternative_style
+          (supported_styles - [style, :same_as_string_literals]).first
+        end
+
+        def quoted?(sym_node)
+          sym_node.source.match?(/\A:?(['"]).*?\1\z/m)
+        end
+
+        def wrong_quotes?(node)
+          return super if hash_key?(node)
+
+          super(node.source[1..-1])
+        end
+      end
+    end
+  end
+end