rubocop 1.27.0 → 1.51.0

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

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

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Prefer `select` or `reject` over `map { ... }.compact`.
+      #
+      # @example
+      #
+      #   # bad
+      #   array.map { |e| some_condition? ? e : next }.compact
+      #
+      #   # bad
+      #   array.map do |e|
+      #     if some_condition?
+      #       e
+      #     else
+      #       next
+      #     end
+      #   end.compact
+      #
+      #   # bad
+      #   array.map do |e|
+      #     next if some_condition?
+      #
+      #     e
+      #   end.compact
+      #
+      #   # bad
+      #   array.map do |e|
+      #     e if some_condition?
+      #   end.compact
+      #
+      #   # good
+      #   array.select { |e| some_condition? }
+      #
+      #   # good
+      #   array.reject { |e| some_condition? }
+      #
+      class MapCompactWithConditionalBlock < Base
+        extend AutoCorrector
+
+        MSG = 'Replace `map { ... }.compact` with `%<method>s`.'
+
+        # @!method map_and_compact?(node)
+        def_node_matcher :map_and_compact?, <<~RUBY
+          (send
+            (block
+              (send _ :map)
+              (args
+                $(arg _))
+              {
+                (if $_ $(lvar _) {next nil?})
+                (if $_ {next nil?} $(lvar _))
+                (if $_ (next $(lvar _)) {next nil nil?})
+                (if $_ {next nil nil?} (next $(lvar _)))
+                (begin
+                  {
+                    (if $_ next nil?)
+                    (if $_ nil? next)
+                  }
+                  $(lvar _))
+                (begin
+                  {
+                    (if $_ (next $(lvar _)) nil?)
+                    (if $_ nil? (next $(lvar _)))
+                  }
+                  (nil))
+              }) :compact)
+        RUBY
+
+        def on_send(node)
+          map_and_compact?(node) do |block_argument_node, condition_node, return_value_node|
+            return unless returns_block_argument?(block_argument_node, return_value_node)
+            return if condition_node.parent.elsif?
+
+            method = truthy_branch?(return_value_node) ? 'select' : 'reject'
+            range = range(node)
+
+            add_offense(range, message: format(MSG, method: method)) do |corrector|
+              corrector.replace(
+                range,
+                "#{method} { |#{block_argument_node.source}| #{condition_node.source} }"
+              )
+            end
+          end
+        end
+
+        private
+
+        def returns_block_argument?(block_argument_node, return_value_node)
+          block_argument_node.name == return_value_node.children.first
+        end
+
+        def truthy_branch?(node)
+          if node.parent.begin_type?
+            truthy_branch_for_guard?(node)
+          elsif node.parent.next_type?
+            truthy_branch_for_if?(node.parent)
+          else
+            truthy_branch_for_if?(node)
+          end
+        end
+
+        def truthy_branch_for_if?(node)
+          if_node = node.parent
+
+          if if_node.if? || if_node.ternary?
+            if_node.if_branch == node
+          elsif if_node.unless?
+            if_node.else_branch == node
+          end
+        end
+
+        def truthy_branch_for_guard?(node)
+          if_node = node.left_sibling
+
+          if if_node.if? || if_node.ternary?
+            if_node.else_branch.nil?
+          elsif if_node.unless?
+            if_node.if_branch.nil?
+          end
+        end
+
+        def range(node)
+          buffer = node.source_range.source_buffer
+          map_node = node.receiver.send_node
+          begin_pos = map_node.loc.selector.begin_pos
+          end_pos = node.source_range.end_pos
+
+          Parser::Source::Range.new(buffer, begin_pos, end_pos)
+        end
+      end
+    end
+  end
+end

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # This cop looks for uses of `map.to_h` or `collect.to_h` that could be
+      # Looks for uses of `map.to_h` or `collect.to_h` that could be
       # written with just `to_h` in Ruby >= 2.6.
       #
       # NOTE: `Style/HashTransformKeys` and `Style/HashTransformValues` will
@@ -39,7 +39,10 @@ module RuboCop
 
         # @!method map_to_h?(node)
         def_node_matcher :map_to_h?, <<~PATTERN
-          $(send (block $(send _ {:map :collect}) ...) :to_h)
+          {
+            $(send ({block numblock} $(send _ {:map :collect}) ...) :to_h)
+            $(send $(send _ {:map :collect} (block_pass sym)) :to_h)
+          }
         PATTERN
 
         def on_send(node)
@@ -47,7 +50,7 @@ module RuboCop
 
           message = format(MSG, method: map_node.loc.selector.source)
           add_offense(map_node.loc.selector, message: message) do |corrector|
-            # If the `to_h` call already has a block, do not auto-correct.
+            # If the `to_h` call already has a block, do not autocorrect.
             next if to_h_node.block_node
 
             autocorrect(corrector, to_h_node, map_node)
@@ -59,7 +62,7 @@ module RuboCop
         def autocorrect(corrector, to_h, map)
           removal_range = range_between(to_h.loc.dot.begin_pos, to_h.loc.selector.end_pos)
 
-          corrector.remove(range_with_surrounding_space(range: removal_range, side: :left))
+          corrector.remove(range_with_surrounding_space(removal_range, side: :left))
           corrector.replace(map.loc.selector, 'to_h')
         end
       end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Looks for uses of `map.to_set` or `collect.to_set` that could be
+      # written with just `to_set`.
+      #
+      # @safety
+      #   This cop is unsafe, as it can produce false positives if the receiver
+      #   is not an `Enumerable`.
+      #
+      # @example
+      #   # bad
+      #   something.map { |i| i * 2 }.to_set
+      #
+      #   # good
+      #   something.to_set { |i| i * 2 }
+      #
+      #   # bad
+      #   [1, 2, 3].collect { |i| i.to_s }.to_set
+      #
+      #   # good
+      #   [1, 2, 3].to_set { |i| i.to_s }
+      #
+      class MapToSet < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = 'Pass a block to `to_set` instead of calling `%<method>s.to_set`.'
+        RESTRICT_ON_SEND = %i[to_set].freeze
+
+        # @!method map_to_set?(node)
+        def_node_matcher :map_to_set?, <<~PATTERN
+          {
+            $(send ({block numblock} $(send _ {:map :collect}) ...) :to_set)
+            $(send $(send _ {:map :collect} (block_pass sym)) :to_set)
+          }
+        PATTERN
+
+        def on_send(node)
+          return unless (to_set_node, map_node = map_to_set?(node))
+
+          message = format(MSG, method: map_node.loc.selector.source)
+          add_offense(map_node.loc.selector, message: message) do |corrector|
+            # If the `to_set` call already has a block, do not autocorrect.
+            next if to_set_node.block_node
+
+            autocorrect(corrector, to_set_node, map_node)
+          end
+        end
+
+        private
+
+        def autocorrect(corrector, to_set, map)
+          removal_range = range_between(to_set.loc.dot.begin_pos, to_set.loc.selector.end_pos)
+
+          corrector.remove(range_with_surrounding_space(removal_range, side: :left))
+          corrector.replace(map.loc.selector, 'to_set')
+        end
+      end
+    end
+  end
+end

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

@@ -13,24 +13,22 @@ module RuboCop
 
           private
 
-          # rubocop:disable Metrics/PerceivedComplexity
-          def omit_parentheses(node)
+          def omit_parentheses(node) # rubocop:disable Metrics/PerceivedComplexity
             return unless node.parenthesized?
             return if inside_endless_method_def?(node)
             return if require_parentheses_for_hash_value_omission?(node)
             return if syntax_like_method_call?(node)
             return if super_call_without_arguments?(node)
-            return if allowed_camel_case_method_call?(node)
             return if legitimate_call_with_parentheses?(node)
+            return if allowed_camel_case_method_call?(node)
             return if allowed_string_interpolation_method_call?(node)
 
             add_offense(offense_range(node), message: OMIT_MSG) do |corrector|
-              auto_correct(corrector, node)
+              autocorrect(corrector, node)
             end
           end
-          # rubocop:enable Metrics/PerceivedComplexity
 
-          def auto_correct(corrector, node)
+          def autocorrect(corrector, node)
             if parentheses_at_the_end_of_multiline_call?(node)
               corrector.replace(args_begin(node), ' \\')
             else
@@ -52,17 +50,13 @@ module RuboCop
             return false unless (last_argument = node.last_argument)
             return false if !last_argument.hash_type? || !last_argument.pairs.last&.value_omission?
 
-            modifier_form?(node) || exist_next_line_expression?(node)
-          end
-
-          def modifier_form?(node)
-            node.parent.respond_to?(:modifier_form?) && node.parent.modifier_form?
+            node.parent&.conditional? || !last_expression?(node)
           end
 
           # Require hash value omission be enclosed in parentheses to prevent the following issue:
           # https://bugs.ruby-lang.org/issues/18396.
-          def exist_next_line_expression?(node)
-            node.parent&.assignment? ? node.parent.right_sibling : node.right_sibling
+          def last_expression?(node)
+            !(node.parent&.assignment? ? node.parent.right_sibling : node.right_sibling)
           end
 
           def syntax_like_method_call?(node)
@@ -90,31 +84,36 @@ module RuboCop
                   .end_with?('(')
           end
 
-          def legitimate_call_with_parentheses?(node)
+          def legitimate_call_with_parentheses?(node) # rubocop:disable Metrics/PerceivedComplexity
             call_in_literals?(node) ||
               call_with_ambiguous_arguments?(node) ||
               call_in_logical_operators?(node) ||
               call_in_optional_arguments?(node) ||
               call_in_single_line_inheritance?(node) ||
               allowed_multiline_call_with_parentheses?(node) ||
-              allowed_chained_call_with_parentheses?(node)
+              allowed_chained_call_with_parentheses?(node) ||
+              assignment_in_condition?(node) ||
+              forwards_anonymous_rest_arguments?(node)
           end
 
           def call_in_literals?(node)
-            node.parent &&
-              (node.parent.pair_type? ||
-              node.parent.array_type? ||
-              node.parent.range_type? ||
-              splat?(node.parent) ||
-              ternary_if?(node.parent))
+            parent = node.parent&.block_type? ? node.parent.parent : node.parent
+            return unless parent
+
+            parent.pair_type? ||
+              parent.array_type? ||
+              parent.range_type? ||
+              splat?(parent) ||
+              ternary_if?(parent)
           end
 
           def call_in_logical_operators?(node)
             parent = node.parent&.block_type? ? node.parent.parent : node.parent
-            parent &&
-              (logical_operator?(parent) ||
+            return unless parent
+
+            logical_operator?(parent) ||
               (parent.send_type? &&
-              parent.arguments.any? { |argument| logical_operator?(argument) }))
+              parent.arguments.any? { |argument| logical_operator?(argument) })
           end
 
           def call_in_optional_arguments?(node)
@@ -130,7 +129,7 @@ module RuboCop
               call_as_argument_or_chain?(node) ||
               hash_literal_in_arguments?(node) ||
               node.descendants.any? do |n|
-                n.forwarded_args_type? || ambigious_literal?(n) || logical_operator?(n) ||
+                n.forwarded_args_type? || ambiguous_literal?(n) || logical_operator?(n) ||
                   call_with_braced_block?(n)
               end
           end
@@ -166,7 +165,7 @@ module RuboCop
             previous.parenthesized? || allowed_chained_call_with_parentheses?(previous)
           end
 
-          def ambigious_literal?(node)
+          def ambiguous_literal?(node)
             splat?(node) || ternary_if?(node) || regexp_slash_literal?(node) || unary_literal?(node)
           end
 
@@ -202,6 +201,23 @@ module RuboCop
           def inside_string_interpolation?(node)
             node.ancestors.drop_while { |a| !a.begin_type? }.any?(&:dstr_type?)
           end
+
+          def assignment_in_condition?(node)
+            parent = node.parent
+            return false unless parent
+
+            grandparent = parent.parent
+            return false unless grandparent
+
+            parent.assignment? && (grandparent.conditional? || grandparent.when_type?)
+          end
+
+          def forwards_anonymous_rest_arguments?(node)
+            return false unless (last_argument = node.last_argument)
+            return true if last_argument.forwarded_restarg_type?
+
+            last_argument.hash_type? && last_argument.children.first&.forwarded_kwrestarg_type?
+          end
         end
         # rubocop:enable Metrics/ModuleLength, Metrics/CyclomaticComplexity
       end

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

@@ -12,8 +12,8 @@ module RuboCop
           private
 
           def require_parentheses(node)
-            return if ignored_method?(node.method_name)
-            return if matches_ignored_pattern?(node.method_name)
+            return if allowed_method_name?(node.method_name)
+            return if matches_allowed_pattern?(node.method_name)
             return if eligible_for_parentheses_omission?(node)
             return unless node.arguments? && !node.parenthesized?
 
@@ -24,6 +24,10 @@ module RuboCop
             end
           end
 
+          def allowed_method_name?(name)
+            allowed_method?(name) || matches_allowed_pattern?(name)
+          end
+
           def eligible_for_parentheses_omission?(node)
             node.operator_method? || node.setter_method? || ignored_macro?(node)
           end