rubocop 1.32.0 → 1.35.1

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

@@ -27,7 +27,7 @@ module RuboCop
 
         MSG = 'Use `Integer#times` for a simple loop which iterates a fixed number of times.'
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return unless offending_each_range(node)
 
           send_node = node.send_node

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

@@ -23,13 +23,8 @@ module RuboCop
         MSG = 'Use `each_with_object` instead of `%<method>s`.'
         METHODS = %i[inject reduce].freeze
 
-        # @!method each_with_object_candidate?(node)
-        def_node_matcher :each_with_object_candidate?, <<~PATTERN
-          (block $(send _ {:inject :reduce} _) $_ $_)
-        PATTERN
-
         def on_block(node)
-          each_with_object_candidate?(node) do |method, args, body|
+          each_with_object_block_candidate?(node) do |method, args, body|
             _, method_name, method_arg = *method
             return if simple_method_arg?(method_arg)
 
@@ -40,14 +35,38 @@ module RuboCop
 
             message = format(MSG, method: method_name)
             add_offense(method.loc.selector, message: message) do |corrector|
-              autocorrect(corrector, node, return_value)
+              autocorrect_block(corrector, node, return_value)
+            end
+          end
+        end
+
+        def on_numblock(node)
+          each_with_object_numblock_candidate?(node) do |method, body|
+            _, method_name, method_arg = *method
+            return if simple_method_arg?(method_arg)
+
+            return unless return_value(body)&.source == '_1'
+
+            message = format(MSG, method: method_name)
+            add_offense(method.loc.selector, message: message) do |corrector|
+              autocorrect_numblock(corrector, node)
             end
           end
         end
 
         private
 
-        def autocorrect(corrector, node, return_value)
+        # @!method each_with_object_block_candidate?(node)
+        def_node_matcher :each_with_object_block_candidate?, <<~PATTERN
+          (block $(send _ {:inject :reduce} _) $_ $_)
+        PATTERN
+
+        # @!method each_with_object_numblock_candidate?(node)
+        def_node_matcher :each_with_object_numblock_candidate?, <<~PATTERN
+          (numblock $(send _ {:inject :reduce} _) 2 $_)
+        PATTERN
+
+        def autocorrect_block(corrector, node, return_value)
           corrector.replace(node.send_node.loc.selector, 'each_with_object')
 
           first_arg, second_arg = *node.arguments
@@ -62,6 +81,18 @@ module RuboCop
           end
         end
 
+        def autocorrect_numblock(corrector, node)
+          corrector.replace(node.send_node.loc.selector, 'each_with_object')
+
+          # We don't remove the return value to avoid a clobbering error.
+          node.body.each_descendant do |var|
+            next unless var.lvar_type?
+
+            corrector.replace(var, '_2') if var.source == '_1'
+            corrector.replace(var, '_1') if var.source == '_2'
+          end
+        end
+
         def simple_method_arg?(method_arg)
           method_arg&.basic_literal?
         end

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

@@ -28,7 +28,7 @@ module RuboCop
 
         MSG = 'Omit pipes for the empty block parameters.'
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           send_node = node.send_node
           check(node) unless send_node.send_type? && send_node.lambda_literal?
         end

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

@@ -48,11 +48,25 @@ module RuboCop
           add_offense(node) do |corrector|
             heredoc_end = node.loc.heredoc_end
 
-            corrector.replace(node, "''")
+            corrector.replace(node, preferred_string_literal)
             corrector.remove(range_by_whole_lines(heredoc_body, include_final_newline: true))
             corrector.remove(range_by_whole_lines(heredoc_end, include_final_newline: true))
           end
         end
+
+        private
+
+        def preferred_string_literal
+          enforce_double_quotes? ? '""' : "''"
+        end
+
+        def enforce_double_quotes?
+          string_literals_config['EnforcedStyle'] == 'double_quotes'
+        end
+
+        def string_literals_config
+          config.for_cop('Style/StringLiterals')
+        end
       end
     end
   end

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

@@ -23,7 +23,7 @@ module RuboCop
 
         MSG = 'Omit parentheses for the empty lambda parameters.'
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           send_node = node.send_node
           return unless send_node.send_type?
 

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

@@ -75,6 +75,8 @@ module RuboCop
           end
         end
 
+        alias on_numblock on_block
+
         private
 
         def suspect_enumerable?(node)

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

@@ -11,8 +11,8 @@ module RuboCop
       # The reason is that _unannotated_ format is very similar
       # to encoded URLs or Date/Time formatting strings.
       #
-      # This cop can be customized ignored methods with `IgnoredMethods`.
-      # By default, there are no methods to ignored.
+      # This cop can be customized allowed methods with `AllowedMethods`.
+      # By default, there are no methods to allowed.
       #
       # @example EnforcedStyle: annotated (default)
       #
@@ -62,23 +62,34 @@ module RuboCop
       #   # good
       #   format('%06d', 10)
       #
-      # @example IgnoredMethods: [] (default)
+      # @example AllowedMethods: [] (default)
       #
       #   # bad
       #   redirect('foo/%{bar_id}')
       #
-      # @example IgnoredMethods: [redirect]
+      # @example AllowedMethods: [redirect]
+      #
+      #   # good
+      #   redirect('foo/%{bar_id}')
+      #
+      # @example AllowedPatterns: [] (default)
+      #
+      #   # bad
+      #   redirect('foo/%{bar_id}')
+      #
+      # @example AllowedPatterns: [/redirect/]
       #
       #   # good
       #   redirect('foo/%{bar_id}')
       #
       class FormatStringToken < Base
         include ConfigurableEnforcedStyle
-        include IgnoredMethods
+        include AllowedMethods
+        include AllowedPattern
         extend AutoCorrector
 
         def on_str(node)
-          return if format_string_token?(node) || use_ignored_method?(node)
+          return if format_string_token?(node) || use_allowed_method?(node)
 
           detections = collect_detections(node)
           return if detections.empty?
@@ -103,9 +114,11 @@ module RuboCop
           !node.value.include?('%') || node.each_ancestor(:xstr, :regexp).any?
         end
 
-        def use_ignored_method?(node)
+        def use_allowed_method?(node)
           send_parent = node.each_ancestor(:send).first
-          send_parent && ignored_method?(send_parent.method_name)
+          send_parent &&
+            (allowed_method?(send_parent.method_name) ||
+            matches_allowed_pattern?(send_parent.method_name))
         end
 
         def check_sequence(detected_sequence, token_range)

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

@@ -6,6 +6,10 @@ module RuboCop
       # Use a guard clause instead of wrapping the code inside a conditional
       # expression
       #
+      # A condition with an `elsif` or `else` branch is allowed unless
+      # one of `return`, `break`, `next`, `raise`, or `fail` is used
+      # in the body of the conditional expression.
+      #
       # @example
       #   # bad
       #   def test
@@ -50,34 +54,41 @@ module RuboCop
       #
       # @example AllowConsecutiveConditionals: false (default)
       #   # bad
-      #   if foo?
-      #     work
-      #   end
+      #   def test
+      #     if foo?
+      #       work
+      #     end
       #
-      #   if bar?  # <- reports an offense
-      #     work
+      #     if bar?  # <- reports an offense
+      #       work
+      #     end
       #   end
       #
       # @example AllowConsecutiveConditionals: true
       #   # good
-      #   if foo?
-      #     work
-      #   end
+      #   def test
+      #     if foo?
+      #       work
+      #     end
       #
-      #   if bar?
-      #     work
+      #     if bar?
+      #       work
+      #     end
       #   end
       #
       #   # bad
-      #   if foo?
-      #     work
-      #   end
+      #   def test
+      #     if foo?
+      #       work
+      #     end
       #
-      #   do_something
+      #     do_something
       #
-      #   if bar?  # <- reports an offense
-      #     work
+      #     if bar?  # <- reports an offense
+      #       work
+      #     end
       #   end
+      #
       class GuardClause < Base
         include MinBodyLength
         include StatementModifier

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

@@ -35,13 +35,15 @@ module RuboCop
 
         # @!method kv_each(node)
         def_node_matcher :kv_each, <<~PATTERN
-          (block $(send (send _ ${:keys :values}) :each) ...)
+          ({block numblock} $(send (send _ ${:keys :values}) :each) ...)
         PATTERN
 
         def on_block(node)
           register_kv_offense(node)
         end
 
+        alias on_numblock on_block
+
         private
 
         def register_kv_offense(node)

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

@@ -159,10 +159,6 @@ module RuboCop
           key_argument = node.argument_list.first.source
           body = extract_body_if_nagated(node.body)
           lhs, _method_name, rhs = *body
-
-          return lhs if body.method?('include?')
-          return lhs if body.method?('exclude?')
-          return rhs if body.method?('in?')
           return if [lhs, rhs].map(&:source).none?(key_argument)
 
           [lhs, rhs].find { |operand| operand.source != key_argument }

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

@@ -28,6 +28,7 @@ module RuboCop
       # * always - forces use of the 3.1 syntax (e.g. {foo:})
       # * never - forces use of explicit hash literal value
       # * either - accepts both shorthand and explicit use of hash literal value
+      # * consistent - like "always", but will avoid mixing styles in a single hash
       #
       # @example EnforcedStyle: ruby19 (default)
       #   # bad
@@ -89,6 +90,20 @@ module RuboCop
       #   # good
       #   {foo:, bar:}
       #
+      # @example EnforcedShorthandSyntax: consistent
+      #
+      #   # bad
+      #   {foo: , bar: bar}
+      #
+      #   # good
+      #   {foo:, bar:}
+      #
+      #   # bad
+      #   {foo: , bar: baz}
+      #
+      #   # good
+      #   {foo: foo, bar: baz}
+      #
       class HashSyntax < Base
         include ConfigurableEnforcedStyle
         include HashShorthandSyntax
@@ -104,6 +119,8 @@ module RuboCop
 
           return if pairs.empty?
 
+          on_hash_for_mixed_shorthand(node)
+
           if style == :hash_rockets || force_hash_rockets?(pairs)
             hash_rockets_check(pairs)
           elsif style == :ruby19_no_mixed_keys

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

@@ -96,7 +96,7 @@ module RuboCop
           return false unless max_line_length
 
           range = node.source_range
-          return false unless range.first_line == range.last_line
+          return false unless range.single_line?
           return false unless line_length_enabled_at_line?(range.first_line)
 
           line = range.source_line

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

@@ -59,18 +59,18 @@ module RuboCop
         def_node_matcher :inverse_candidate?, <<~PATTERN
           {
             (send $(send $(...) $_ $...) :!)
-            (send (block $(send $(...) $_) $...) :!)
+            (send ({block numblock} $(send $(...) $_) $...) :!)
             (send (begin $(send $(...) $_ $...)) :!)
           }
         PATTERN
 
         # @!method inverse_block?(node)
         def_node_matcher :inverse_block?, <<~PATTERN
-          (block $(send (...) $_) ... { $(send ... :!)
-                                        $(send (...) {:!= :!~} ...)
-                                        (begin ... $(send ... :!))
-                                        (begin ... $(send (...) {:!= :!~} ...))
-                                      })
+          ({block numblock} $(send (...) $_) ... { $(send ... :!)
+                                                   $(send (...) {:!= :!~} ...)
+                                                   (begin ... $(send ... :!))
+                                                   (begin ... $(send (...) {:!= :!~} ...))
+                                                 })
         PATTERN
 
         def on_send(node)
@@ -102,6 +102,8 @@ module RuboCop
           end
         end
 
+        alias on_numblock on_block
+
         private
 
         def correct_inverse_method(corrector, node)

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

@@ -0,0 +1,307 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Ensures magic comments are written consistently throughout your code base.
+      # Looks for discrepancies in separators (`-` vs `_`) and capitalization for
+      # both magic comment directives and values.
+      #
+      # Required capitalization can be set with the `DirectiveCapitalization` and
+      # `ValueCapitalization` configuration keys.
+      #
+      # NOTE: If one of these configuration is set to nil, any capitalization is allowed.
+      #
+      # @example EnforcedStyle: snake_case (default)
+      #   # The `snake_case` style will enforce that the frozen string literal
+      #   # comment is written in snake case. (Words separated by underscores)
+      #   # bad
+      #   # frozen-string-literal: true
+      #
+      #   module Bar
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   # frozen_string_literal: false
+      #
+      #   module Bar
+      #     # ...
+      #   end
+      #
+      # @example EnforcedStyle: kebab_case
+      #   # The `kebab_case` style will enforce that the frozen string literal
+      #   # comment is written in kebab case. (Words separated by hyphens)
+      #   # bad
+      #   # frozen_string_literal: true
+      #
+      #   module Baz
+      #     # ...
+      #   end
+      #
+      #   # good
+      #   # frozen-string-literal: true
+      #
+      #   module Baz
+      #     # ...
+      #   end
+      #
+      # @example DirectiveCapitalization: lowercase (default)
+      #   # bad
+      #   # FROZEN-STRING-LITERAL: true
+      #
+      #   # good
+      #   # frozen-string-literal: true
+      #
+      # @example DirectiveCapitalization: uppercase
+      #   # bad
+      #   # frozen-string-literal: true
+      #
+      #   # good
+      #   # FROZEN-STRING-LITERAL: true
+      #
+      # @example DirectiveCapitalization: nil
+      #   # any capitalization is accepted
+      #
+      #   # good
+      #   # frozen-string-literal: true
+      #
+      #   # good
+      #   # FROZEN-STRING-LITERAL: true
+      #
+      # @example ValueCapitalization: nil (default)
+      #   # any capitalization is accepted
+      #
+      #   # good
+      #   # frozen-string-literal: true
+      #
+      #   # good
+      #   # frozen-string-literal: TRUE
+      #
+      # @example ValueCapitalization: lowercase
+      #   # when a value is not given, any capitalization is accepted
+      #
+      #   # bad
+      #   # frozen-string-literal: TRUE
+      #
+      #   # good
+      #   # frozen-string-literal: TRUE
+      #
+      # @example ValueCapitalization: uppercase
+      #   # bad
+      #   # frozen-string-literal: true
+      #
+      #   # good
+      #   # frozen-string-literal: TRUE
+      #
+      class MagicCommentFormat < Base
+        include ConfigurableEnforcedStyle
+        extend AutoCorrector
+
+        SNAKE_SEPARATOR = '_'
+        KEBAB_SEPARATOR = '-'
+        MSG = 'Prefer %<style>s case for magic comments.'
+        MSG_VALUE = 'Prefer %<case>s for magic comment values.'
+
+        # Value object to extract source ranges for the different parts of a magic comment
+        class CommentRange
+          extend Forwardable
+
+          DIRECTIVE_REGEXP = Regexp.union(MagicComment::KEYWORDS.map do |_, v|
+            Regexp.new(v, Regexp::IGNORECASE)
+          end).freeze
+
+          VALUE_REGEXP = Regexp.new("(?:#{DIRECTIVE_REGEXP}:\s*)(.*?)(?=;|$)")
+
+          def_delegators :@comment, :text, :loc
+          attr_reader :comment
+
+          def initialize(comment)
+            @comment = comment
+          end
+
+          # A magic comment can contain one directive (normal style) or
+          # multiple directives (emacs style)
+          def directives
+            @directives ||= begin
+              matches = []
+
+              text.scan(DIRECTIVE_REGEXP) do
+                offset = Regexp.last_match.offset(0)
+                matches << loc.expression.adjust(begin_pos: offset.first)
+                              .with(end_pos: loc.expression.begin_pos + offset.last)
+              end
+
+              matches
+            end
+          end
+
+          # A magic comment can contain one value (normal style) or
+          # multiple directives (emacs style)
+          def values
+            @values ||= begin
+              matches = []
+
+              text.scan(VALUE_REGEXP) do
+                offset = Regexp.last_match.offset(1)
+                matches << loc.expression.adjust(begin_pos: offset.first)
+                              .with(end_pos: loc.expression.begin_pos + offset.last)
+              end
+
+              matches
+            end
+          end
+        end
+
+        def on_new_investigation
+          return unless processed_source.ast
+
+          magic_comments.each do |comment|
+            issues = find_issues(comment)
+            register_offenses(issues) if issues.any?
+          end
+        end
+
+        private
+
+        def magic_comments
+          processed_source.each_comment_in_lines(leading_comment_lines)
+                          .select { |comment| MagicComment.parse(comment.text).valid? }
+                          .map { |comment| CommentRange.new(comment) }
+        end
+
+        def leading_comment_lines
+          first_non_comment_token = processed_source.tokens.find { |token| !token.comment? }
+
+          if first_non_comment_token
+            0...first_non_comment_token.line
+          else
+            (0..)
+          end
+        end
+
+        def find_issues(comment)
+          issues = { directives: [], values: [] }
+
+          comment.directives.each do |directive|
+            issues[:directives] << directive if directive_offends?(directive)
+          end
+
+          comment.values.each do |value| # rubocop:disable Style/HashEachMethods
+            issues[:values] << value if wrong_capitalization?(value.source, value_capitalization)
+          end
+
+          issues
+        end
+
+        def directive_offends?(directive)
+          incorrect_separator?(directive.source) ||
+            wrong_capitalization?(directive.source, directive_capitalization)
+        end
+
+        def register_offenses(issues)
+          fix_directives(issues[:directives])
+          fix_values(issues[:values])
+        end
+
+        def fix_directives(issues)
+          return if issues.empty?
+
+          msg = format(MSG, style: expected_style)
+
+          issues.each do |directive|
+            add_offense(directive, message: msg) do |corrector|
+              replacement = replace_separator(replace_capitalization(directive.source,
+                                                                     directive_capitalization))
+              corrector.replace(directive, replacement)
+            end
+          end
+        end
+
+        def fix_values(issues)
+          return if issues.empty?
+
+          msg = format(MSG_VALUE, case: value_capitalization)
+
+          issues.each do |value|
+            add_offense(value, message: msg) do |corrector|
+              corrector.replace(value, replace_capitalization(value.source, value_capitalization))
+            end
+          end
+        end
+
+        def expected_style
+          [directive_capitalization, style].compact.join(' ').gsub(/_?case\b/, '')
+        end
+
+        def wrong_separator
+          style == :snake_case ? KEBAB_SEPARATOR : SNAKE_SEPARATOR
+        end
+
+        def correct_separator
+          style == :snake_case ? SNAKE_SEPARATOR : KEBAB_SEPARATOR
+        end
+
+        def incorrect_separator?(text)
+          text[wrong_separator]
+        end
+
+        def wrong_capitalization?(text, expected_case)
+          return false unless expected_case
+
+          case expected_case
+          when :lowercase
+            text != text.downcase
+          when :uppercase
+            text != text.upcase
+          end
+        end
+
+        def replace_separator(text)
+          text.tr(wrong_separator, correct_separator)
+        end
+
+        def replace_capitalization(text, style)
+          return text unless style
+
+          case style
+          when :lowercase
+            text.downcase
+          when :uppercase
+            text.upcase
+          end
+        end
+
+        def line_range(line)
+          processed_source.buffer.line_range(line)
+        end
+
+        def directive_capitalization
+          cop_config['DirectiveCapitalization']&.to_sym.tap do |style|
+            unless valid_capitalization?(style)
+              raise "Unknown `DirectiveCapitalization` #{style} selected!"
+            end
+          end
+        end
+
+        def value_capitalization
+          cop_config['ValueCapitalization']&.to_sym.tap do |style|
+            unless valid_capitalization?(style)
+              raise "Unknown `ValueCapitalization` #{style} selected!"
+            end
+          end
+        end
+
+        def valid_capitalization?(style)
+          return true unless style
+
+          supported_capitalizations.include?(style)
+        end
+
+        def supported_capitalizations
+          cop_config['SupportedCapitalizations'].map(&:to_sym)
+        end
+      end
+    end
+  end
+end