rubocop 1.32.0 → 1.37.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/method_call_with_args_parentheses/omit_parentheses.rb

@@ -20,8 +20,8 @@ module RuboCop
             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|
@@ -97,7 +97,8 @@ module RuboCop
               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)
           end
 
           def call_in_literals?(node)
@@ -130,7 +131,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 +167,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 +203,16 @@ 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
         end
         # rubocop:enable Metrics/ModuleLength, Metrics/CyclomaticComplexity
       end

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

@@ -12,7 +12,7 @@ module RuboCop
           private
 
           def require_parentheses(node)
-            return if ignored_method?(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

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

@@ -6,8 +6,8 @@ module RuboCop
       # Enforces the presence (default) or absence of parentheses in
       # method calls containing parameters.
       #
-      # In the default style (require_parentheses), macro methods are ignored.
-      # Additional methods can be added to the `IgnoredMethods`
+      # In the default style (require_parentheses), macro methods are allowed.
+      # Additional methods can be added to the `AllowedMethods`
       # or `AllowedPatterns` list. These options are
       # valid only in the default style. Macros can be included by
       # either setting `IgnoreMacros` to false or adding specific macros to
@@ -15,13 +15,13 @@ module RuboCop
       #
       # Precedence of options is all follows:
       #
-      # 1. `IgnoredMethods`
+      # 1. `AllowedMethods`
       # 2. `AllowedPatterns`
       # 3. `IncludedMacros`
       #
       # eg. If a method is listed in both
-      # `IncludedMacros` and `IgnoredMethods`, then the latter takes
-      # precedence (that is, the method is ignored).
+      # `IncludedMacros` and `AllowedMethods`, then the latter takes
+      # precedence (that is, the method is allowed).
       #
       # In the alternative style (omit_parentheses), there are three additional
       # options.
@@ -65,7 +65,7 @@ module RuboCop
       #   # Setter methods don't need parens
       #   foo.bar = baz
       #
-      #   # okay with `puts` listed in `IgnoredMethods`
+      #   # okay with `puts` listed in `AllowedMethods`
       #   puts 'test'
       #
       #   # okay with `^assert` listed in `AllowedPatterns`
@@ -197,7 +197,7 @@ module RuboCop
         require_relative 'method_call_with_args_parentheses/require_parentheses'
 
         include ConfigurableEnforcedStyle
-        include IgnoredMethods
+        include AllowedMethods
         include AllowedPattern
         include RequireParentheses
         include OmitParentheses

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

@@ -5,8 +5,8 @@ module RuboCop
     module Style
       # Checks for unwanted parentheses in parameterless method calls.
       #
-      # 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
       #   # bad
@@ -15,16 +15,17 @@ module RuboCop
       #   # good
       #   object.some_method
       #
-      # @example IgnoredMethods: [] (default)
+      # @example AllowedMethods: [] (default)
       #   # bad
       #   object.foo()
       #
-      # @example IgnoredMethods: [foo]
+      # @example AllowedMethods: [foo]
       #   # good
       #   object.foo()
       #
       class MethodCallWithoutArgsParentheses < Base
-        include IgnoredMethods
+        include AllowedMethods
+        include AllowedPattern
         extend AutoCorrector
 
         MSG = 'Do not use parentheses for method calls with no arguments.'
@@ -33,7 +34,7 @@ module RuboCop
           return unless !node.arguments? && node.parenthesized?
           return if ineligible_node?(node)
           return if default_argument?(node)
-          return if ignored_method?(node.method_name)
+          return if allowed_method_name?(node.method_name)
           return if same_name_assignment?(node)
 
           register_offense(node)
@@ -56,6 +57,10 @@ module RuboCop
           node.parent&.optarg_type?
         end
 
+        def allowed_method_name?(name)
+          allowed_method?(name) || matches_allowed_pattern?(name)
+        end
+
         def same_name_assignment?(node)
           any_assignment?(node) do |asgn_node|
             next variable_in_mass_assignment?(node.method_name, asgn_node) if asgn_node.masgn_type?

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

@@ -35,12 +35,15 @@ module RuboCop
           ignore_node(node.send_node)
         end
 
+        alias on_numblock on_block
+
         def on_send(node)
           return if ignored_node?(node)
 
           receiver = node.receiver
 
-          return unless receiver&.block_type? && receiver.loc.end.is?('end')
+          return unless (receiver&.block_type? || receiver&.numblock_type?) &&
+                        receiver.loc.end.is?('end')
 
           range = range_between(receiver.loc.end.begin_pos, node.source_range.end_pos)
 

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

@@ -31,7 +31,7 @@ module RuboCop
           node.send_node.each_node(:send) do |send_node|
             receiver = send_node.receiver
 
-            next unless receiver&.block_type? && receiver&.multiline?
+            next unless (receiver&.block_type? || receiver&.numblock_type?) && receiver&.multiline?
 
             range = range_between(receiver.loc.end.begin_pos, node.send_node.source_range.end_pos)
 
@@ -42,6 +42,8 @@ module RuboCop
             break
           end
         end
+
+        alias on_numblock on_block
       end
     end
   end

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

@@ -49,7 +49,7 @@ module RuboCop
 
         # 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 true unless in_pattern_node.pattern.single_line?
           return false unless in_pattern_node.body
 
           same_line?(in_pattern_node, in_pattern_node.body)

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

@@ -49,7 +49,8 @@ module RuboCop
         def on_if(node)
           return unless if_else?(node)
 
-          condition = node.condition
+          condition = unwrap_begin_nodes(node.condition)
+
           return if double_negation?(condition) || !negated_condition?(condition)
 
           type = node.ternary? ? 'ternary' : 'if-else'
@@ -71,6 +72,11 @@ module RuboCop
           !node.elsif? && else_branch && (!else_branch.if_type? || !else_branch.elsif?)
         end
 
+        def unwrap_begin_nodes(node)
+          node = node.children.first while node.begin_type? || node.kwbegin_type?
+          node
+        end
+
         def negated_condition?(node)
           node.send_type? &&
             (node.negation_method? || NEGATED_EQUALITY_METHODS.include?(node.method_name))

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

@@ -71,6 +71,8 @@ module RuboCop
           check(node)
         end
 
+        alias on_numblock on_block
+
         def on_while(node)
           check(node)
         end
@@ -223,11 +225,7 @@ module RuboCop
           adjustment = delta + @reindented_lines[lineno]
           @reindented_lines[lineno] = adjustment
 
-          if adjustment.positive?
-            corrector.remove_leading(buffer.line_range(lineno), adjustment)
-          elsif adjustment.negative?
-            corrector.insert_before(buffer.line_range(lineno), ' ' * -adjustment)
-          end
+          corrector.remove_leading(buffer.line_range(lineno), adjustment) if adjustment.positive?
         end
       end
     end

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

@@ -43,7 +43,7 @@ module RuboCop
           { ({return next break} nil) (nil) }
         PATTERN
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return unless node.lambda? || node.proc?
           return unless nil_return?(node.body)
 

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

@@ -3,9 +3,17 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for big numeric literals without _ between groups
+      # Checks for big numeric literals without `_` between groups
       # of digits in them.
       #
+      # Additional allowed patterns can be added by adding regexps to
+      # the `AllowedPatterns` configuration. All regexps are treated
+      # as anchored even if the patterns do not contain anchors (so
+      # `\d{4}_\d{4}` will allow `1234_5678` but not `1234_5678_9012`).
+      #
+      # NOTE: Even if `AllowedPatterns` are given, autocorrection will
+      # only correct to the standard pattern of an `_` every 3 digits.
+      #
       # @example
       #
       #   # bad
@@ -34,6 +42,7 @@ module RuboCop
       #
       class NumericLiterals < Base
         include IntegerNode
+        include AllowedPattern
         extend AutoCorrector
 
         MSG = 'Use underscores(_) as thousands separator and separate every 3 digits with them.'
@@ -59,6 +68,7 @@ module RuboCop
           # TODO: handle non-decimal literals as well
           return if int.start_with?('0')
           return if allowed_numbers.include?(int)
+          return if matches_allowed_pattern?(int)
           return unless int.size >= min_digits
 
           case int
@@ -108,6 +118,11 @@ module RuboCop
         def allowed_numbers
           cop_config.fetch('AllowedNumbers', []).map(&:to_s)
         end
+
+        def allowed_patterns
+          # Convert the patterns to be anchored
+          super.map { |regexp| Regexp.new(/\A#{regexp}\z/) }
+        end
       end
     end
   end