rubocop 1.14.0 → 1.18.0

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

@@ -3,8 +3,8 @@
 module RuboCop
   module Cop
     module Style
-      # This cop checks for lambdas that always return nil, which can be replaced
-      # with an empty lambda instead.
+      # This cop checks for lambdas and procs that always return nil,
+      # which can be replaced with an empty lambda or proc instead.
       #
       # @example
       #   # bad
@@ -14,6 +14,12 @@ module RuboCop
       #     next nil
       #   end
       #
+      #   proc { nil }
+      #
+      #   Proc.new do
+      #     break nil
+      #   end
+      #
       #   # good
       #   -> {}
       #
@@ -22,11 +28,15 @@ module RuboCop
       #
       #   -> (x) { nil if x }
       #
+      #   proc {}
+      #
+      #   Proc.new { nil if x }
+      #
       class NilLambda < Base
         extend AutoCorrector
         include RangeHelp
 
-        MSG = 'Use an empty lambda instead of always returning nil.'
+        MSG = 'Use an empty %<type>s instead of always returning nil.'
 
         # @!method nil_return?(node)
         def_node_matcher :nil_return?, <<~PATTERN
@@ -34,19 +44,26 @@ module RuboCop
         PATTERN
 
         def on_block(node)
-          return unless node.lambda?
+          return unless node.lambda? || node.proc?
           return unless nil_return?(node.body)
 
-          add_offense(node) do |corrector|
-            range = if node.single_line?
-                      range_with_surrounding_space(range: node.body.loc.expression)
-                    else
-                      range_by_whole_lines(node.body.loc.expression, include_final_newline: true)
-                    end
-
-            corrector.remove(range)
+          message = format(MSG, type: node.lambda? ? 'lambda' : 'proc')
+          add_offense(node, message: message) do |corrector|
+            autocorrect(corrector, node)
           end
         end
+
+        private
+
+        def autocorrect(corrector, node)
+          range = if node.single_line?
+                    range_with_surrounding_space(range: node.body.loc.expression)
+                  else
+                    range_by_whole_lines(node.body.loc.expression, include_final_newline: true)
+                  end
+
+          corrector.remove(range)
+        end
       end
     end
   end

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