rubocop 1.56.2 → 1.57.1

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

@@ -13,25 +13,68 @@ module RuboCop
       #   # good
       #   do_something(foo: bar, baz: qux)
       #
+      #   # bad
+      #   do_something(**{foo: bar, baz: qux}.merge(options))
+      #
+      #   # good
+      #   do_something(foo: bar, baz: qux, **options)
+      #
       class RedundantDoubleSplatHashBraces < Base
         extend AutoCorrector
 
         MSG = 'Remove the redundant double splat and braces, use keyword arguments directly.'
+        MERGE_METHODS = %i[merge merge!].freeze
 
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def on_hash(node)
           return if node.pairs.empty? || node.pairs.any?(&:hash_rocket?)
           return unless (parent = node.parent)
-          return unless parent.kwsplat_type?
+          return if parent.call_type? && !merge_method?(parent)
+          return unless (kwsplat = node.each_ancestor(:kwsplat).first)
+          return if allowed_double_splat_receiver?(kwsplat)
 
-          add_offense(parent) do |corrector|
-            corrector.remove(parent.loc.operator)
-            corrector.remove(opening_brace(node))
-            corrector.remove(closing_brace(node))
+          add_offense(kwsplat) do |corrector|
+            autocorrect(corrector, node, kwsplat)
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         private
 
+        def allowed_double_splat_receiver?(kwsplat)
+          return false unless kwsplat.children.first.call_type?
+
+          root_receiver = root_receiver(kwsplat.children.first)
+
+          !root_receiver&.hash_type?
+        end
+
+        def autocorrect(corrector, node, kwsplat)
+          corrector.remove(kwsplat.loc.operator)
+          corrector.remove(opening_brace(node))
+          corrector.remove(closing_brace(node))
+
+          merge_methods = select_merge_method_nodes(kwsplat)
+          return if merge_methods.empty?
+
+          autocorrect_merge_methods(corrector, merge_methods, kwsplat)
+        end
+
+        def root_receiver(node)
+          receiver = node.receiver
+          if receiver&.receiver
+            root_receiver(receiver)
+          else
+            receiver
+          end
+        end
+
+        def select_merge_method_nodes(kwsplat)
+          extract_send_methods(kwsplat).select do |node|
+            merge_method?(node)
+          end
+        end
+
         def opening_brace(node)
           node.loc.begin.join(node.children.first.source_range.begin)
         end
@@ -39,6 +82,44 @@ module RuboCop
         def closing_brace(node)
           node.children.last.source_range.end.join(node.loc.end)
         end
+
+        def autocorrect_merge_methods(corrector, merge_methods, kwsplat)
+          range = range_of_merge_methods(merge_methods)
+
+          new_kwsplat_arguments = extract_send_methods(kwsplat).map do |descendant|
+            convert_to_new_arguments(descendant)
+          end
+          new_source = new_kwsplat_arguments.compact.reverse.unshift('').join(', ')
+
+          corrector.replace(range, new_source)
+        end
+
+        def range_of_merge_methods(merge_methods)
+          begin_merge_method = merge_methods.last
+          end_merge_method = merge_methods.first
+
+          begin_merge_method.loc.dot.begin.join(end_merge_method.source_range.end)
+        end
+
+        def extract_send_methods(kwsplat)
+          kwsplat.each_descendant(:send, :csend)
+        end
+
+        def convert_to_new_arguments(node)
+          return unless merge_method?(node)
+
+          node.arguments.map do |arg|
+            if arg.hash_type?
+              arg.source
+            else
+              "**#{arg.source}"
+            end
+          end
+        end
+
+        def merge_method?(node)
+          MERGE_METHODS.include?(node.method_name)
+        end
       end
     end
   end

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

@@ -5,17 +5,21 @@ module RuboCop
     module Style
       # Checks for RuntimeError as the argument of raise/fail.
       #
-      # It checks for code like this:
-      #
       # @example
-      #   # Bad
+      #   # bad
       #   raise RuntimeError, 'message'
-      #
-      #   # Bad
       #   raise RuntimeError.new('message')
       #
-      #   # Good
+      #   # good
       #   raise 'message'
+      #
+      #   # bad - message is not a string
+      #   raise RuntimeError, Object.new
+      #   raise RuntimeError.new(Object.new)
+      #
+      #   # good
+      #   raise Object.new.to_s
+      #
       class RedundantException < Base
         extend AutoCorrector
 
@@ -30,26 +34,42 @@ module RuboCop
           fix_exploded(node) || fix_compact(node)
         end
 
+        private
+
         def fix_exploded(node)
           exploded?(node) do |command, message|
             add_offense(node, message: MSG_1) do |corrector|
-              if node.parenthesized?
-                corrector.replace(node, "#{command}(#{message.source})")
-              else
-                corrector.replace(node, "#{command} #{message.source}")
-              end
+              corrector.replace(node, replaced_exploded(node, command, message))
             end
           end
         end
 
+        def replaced_exploded(node, command, message)
+          arg = string_message?(message) ? message.source : "#{message.source}.to_s"
+          arg = node.parenthesized? ? "(#{arg})" : " #{arg}"
+          "#{command}#{arg}"
+        end
+
+        def string_message?(message)
+          message.str_type? || message.dstr_type? || message.xstr_type?
+        end
+
         def fix_compact(node)
           compact?(node) do |new_call, message|
             add_offense(node, message: MSG_2) do |corrector|
-              corrector.replace(new_call, message.source)
+              corrector.replace(new_call, replaced_compact(message))
             end
           end
         end
 
+        def replaced_compact(message)
+          if string_message?(message)
+            message.source
+          else
+            "#{message.source}.to_s"
+          end
+        end
+
         # @!method exploded?(node)
         def_node_matcher :exploded?, <<~PATTERN
           (send nil? ${:raise :fail} (const {nil? cbase} :RuntimeError) $_)

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

@@ -6,6 +6,12 @@ module RuboCop
       # Identifies usages of `any?`, `empty?` or `none?` predicate methods
       # chained to `select`/`filter`/`find_all` and change them to use predicate method instead.
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because `array.select.any?` evaluates all elements
+      #   through the `select` method, while `array.any?` uses short-circuit evaluation.
+      #   In other words, `array.select.any?` guarantees the evaluation of every element,
+      #   but `array.any?` does not necessarily evaluate all of them.
+      #
       # @example
       #   # bad
       #   arr.select { |x| x > 1 }.any?
@@ -28,6 +34,9 @@ module RuboCop
       #   # good
       #   arr.select { |x| x > 1 }.many?
       #
+      #   # good
+      #   arr.select { |x| x > 1 }.present?
+      #
       # @example AllCops:ActiveSupportExtensionsEnabled: true
       #   # bad
       #   arr.select { |x| x > 1 }.many?
@@ -35,12 +44,18 @@ module RuboCop
       #   # good
       #   arr.many? { |x| x > 1 }
       #
+      #   # bad
+      #   arr.select { |x| x > 1 }.present?
+      #
+      #   # good
+      #   arr.any? { |x| x > 1 }
+      #
       class RedundantFilterChain < Base
         extend AutoCorrector
 
         MSG = 'Use `%<prefer>s` instead of `%<first_method>s.%<second_method>s`.'
 
-        RAILS_METHODS = %i[many?].freeze
+        RAILS_METHODS = %i[many? present?].freeze
         RESTRICT_ON_SEND = (%i[any? empty? none? one?] + RAILS_METHODS).freeze
 
         # @!method select_predicate?(node)
@@ -58,7 +73,8 @@ module RuboCop
           empty?: :none?,
           none?: :none?,
           one?: :one?,
-          many?: :many?
+          many?: :many?,
+          present?: :any?
         }.freeze
         private_constant :REPLACEMENT_METHODS
 

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

@@ -126,16 +126,32 @@ module RuboCop
 
         def check(begin_node)
           node = begin_node.children.first
-          return offense(begin_node, 'a keyword') if keyword_with_redundant_parentheses?(node)
-          return offense(begin_node, 'a literal') if disallowed_literal?(begin_node, node)
-          return offense(begin_node, 'a variable') if node.variable?
-          return offense(begin_node, 'a constant') if node.const_type?
 
-          return offense(begin_node, 'an interpolated expression') if interpolation?(begin_node)
+          if (message = find_offense_message(begin_node, node))
+            return offense(begin_node, message)
+          end
 
           check_send(begin_node, node) if node.call_type?
         end
 
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def find_offense_message(begin_node, node)
+          return 'a keyword' if keyword_with_redundant_parentheses?(node)
+          return 'a literal' if disallowed_literal?(begin_node, node)
+          return 'a variable' if node.variable?
+          return 'a constant' if node.const_type?
+          return 'an interpolated expression' if interpolation?(begin_node)
+
+          return if begin_node.chained? || !begin_node.parent.nil?
+
+          if node.and_type? || node.or_type?
+            'a logical expression'
+          elsif node.respond_to?(:comparison_method?) && node.comparison_method?
+            'a comparison expression'
+          end
+        end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
         # @!method interpolation?(node)
         def_node_matcher :interpolation?, '[^begin ^^dstr]'
 

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

@@ -3,9 +3,13 @@
 module RuboCop
   module Cop
     module Style
-      # Enforces consistency between 'return nil' and 'return'.
+      # Enforces consistency between `return nil` and `return`.
       #
-      # Supported styles are: return, return_nil.
+      # This cop is disabled by default. Because there seems to be a perceived semantic difference
+      # between `return` and `return nil`. The former can be seen as just halting evaluation,
+      # while the latter might be used when the return value is of specific concern.
+      #
+      # Supported styles are `return` and `return_nil`.
       #
       # @example EnforcedStyle: return (default)
       #   # bad

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Style
+      # Checks for single-line `do`...`end` block.
+      #
+      # In practice a single line `do`...`end` is autocorrected when `EnforcedStyle: semantic`
+      # in `Style/BlockDelimiters`. The autocorrection maintains the `do` ... `end` syntax to
+      # preserve semantics and does not change it to `{`...`}` block.
+      #
+      # @example
+      #
+      #   # bad
+      #   foo do |arg| bar(arg) end
+      #
+      #   # good
+      #   foo do |arg|
+      #     bar(arg)
+      #   end
+      #
+      #   # bad
+      #   ->(arg) do bar(arg) end
+      #
+      #   # good
+      #   ->(arg) { bar(arg) }
+      #
+      class SingleLineDoEndBlock < Base
+        extend AutoCorrector
+
+        MSG = 'Prefer multiline `do`...`end` block.'
+
+        def on_block(node)
+          return if !node.single_line? || node.braces?
+
+          add_offense(node) do |corrector|
+            corrector.insert_after(do_line(node), "\n")
+
+            node_body = node.body
+
+            if node_body.respond_to?(:heredoc?) && node_body.heredoc?
+              corrector.remove(node.loc.end)
+              corrector.insert_after(node_body.loc.heredoc_end, "\nend")
+            else
+              corrector.insert_after(node_body, "\n")
+            end
+          end
+        end
+        alias on_numblock on_block
+
+        private
+
+        def do_line(node)
+          if node.numblock_type? || node.arguments.children.empty? || node.send_node.lambda_literal?
+            node.loc.begin
+          else
+            node.arguments
+          end
+        end
+
+        def x(corrector, node); end
+      end
+    end
+  end
+end

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

@@ -173,7 +173,9 @@ module RuboCop
         end
 
         def correct_for_comment(corrector, node, if_branch)
-          comments = processed_source.ast_with_comments[if_branch]
+          comments = processed_source.ast_with_comments[if_branch].select do |comment|
+            comment.loc.line < if_branch.condition.first_line
+          end
           comment_text = comments.map(&:text).join("\n") << "\n"
 
           corrector.insert_before(node.loc.keyword, comment_text) unless comments.empty?

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

@@ -50,6 +50,14 @@ module RuboCop
         PERCENT_MSG = 'Use `%i` or `%I` for an array of symbols.'
         ARRAY_MSG = 'Use %<prefer>s for an array of symbols.'
         DELIMITERS = ['[', ']', '(', ')'].freeze
+        SPECIAL_GVARS = %w[
+          $! $" $$ $& $' $* $+ $, $/ $; $: $. $< $= $> $? $@ $\\ $_ $` $~ $0
+          $-0 $-F $-I $-K $-W $-a $-d $-i $-l $-p $-v $-w
+        ].freeze
+        REDEFINABLE_OPERATORS = %w(
+          | ^ & <=> == === =~ > >= < <= << >>
+          + - * / % ** ~ +@ -@ [] []= ` ! != !~
+        ).freeze
 
         class << self
           attr_accessor :largest_brackets
@@ -109,15 +117,6 @@ module RuboCop
         end
 
         def symbol_without_quote?(string)
-          special_gvars = %w[
-            $! $" $$ $& $' $* $+ $, $/ $; $: $. $< $= $> $? $@ $\\ $_ $` $~ $0
-            $-0 $-F $-I $-K $-W $-a $-d $-i $-l $-p $-v $-w
-          ]
-          redefinable_operators = %w(
-            | ^ & <=> == === =~ > >= < <= << >>
-            + - * / % ** ~ +@ -@ [] []= ` ! != !~
-          )
-
           # method name
           /\A[a-zA-Z_]\w*[!?]?\z/.match?(string) ||
             # instance / class variable
@@ -125,8 +124,8 @@ module RuboCop
             # global variable
             /\A\$[1-9]\d*\z/.match?(string) ||
             /\A\$[a-zA-Z_]\w*\z/.match?(string) ||
-            special_gvars.include?(string) ||
-            redefinable_operators.include?(string)
+            SPECIAL_GVARS.include?(string) ||
+            REDEFINABLE_OPERATORS.include?(string)
         end
       end
     end

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

@@ -19,22 +19,23 @@ module RuboCop
       #   differently on different classes, and are not guaranteed to
       #   have the same result if reversed.
       #
-      # @example SupportedOperators: ['*', '+', '&'']
+      # @example SupportedOperators: ['*', '+', '&', '|', '^'] (default)
       #   # bad
-      #   1 + x
       #   10 * y
+      #   1 + x
       #   1 & z
+      #   1 | x
+      #   1 ^ x
       #   1 + CONST
       #
       #   # good
-      #   60 * 24
-      #   x + 1
       #   y * 10
+      #   x + 1
       #   z & 1
+      #   x | 1
+      #   x ^ 1
       #   CONST + 1
-      #
-      #   # good
-      #   1 | x
+      #   60 * 24
       #
       class YodaExpression < Base
         extend AutoCorrector

data/lib/rubocop/file_finder.rb

@@ -6,12 +6,8 @@ module RuboCop
   # Common methods for finding files.
   # @api private
   module FileFinder
-    def self.root_level=(level)
-      @root_level = level
-    end
-
-    def self.root_level?(path, stop_dir)
-      (@root_level || stop_dir) == path.to_s
+    class << self
+      attr_accessor :root_level
     end
 
     def find_file_upwards(filename, start_dir, stop_dir = nil)
@@ -34,7 +30,8 @@ module RuboCop
         file = dir + filename
         yield(file.to_s) if file.exist?
 
-        break if FileFinder.root_level?(dir, stop_dir)
+        dir = dir.to_s
+        break if dir == stop_dir || dir == FileFinder.root_level
       end
     end
   end

data/lib/rubocop/magic_comment.rb

@@ -7,7 +7,7 @@ module RuboCop
   class MagicComment
     # IRB's pattern for matching magic comment tokens.
     # @see https://github.com/ruby/ruby/blob/b4a55c1/lib/irb/magic-file.rb#L5
-    TOKEN = /[[:alnum:]\-_]+/.freeze
+    TOKEN = '(?<token>[[:alnum:]\-_]+)'
     KEYWORDS = {
       encoding: '(?:en)?coding',
       frozen_string_literal: 'frozen[_-]string[_-]literal',
@@ -129,7 +129,7 @@ module RuboCop
     # @return [String] if pattern matched
     # @return [nil] otherwise
     def extract(pattern)
-      @comment[pattern, 1]
+      @comment[pattern, :token]
     end
 
     # Parent to Vim and Emacs magic comment handling.
@@ -157,10 +157,10 @@ module RuboCop
       # @return [String] extracted value if it is found
       # @return [nil] otherwise
       def match(keyword)
-        pattern = /\A#{keyword}\s*#{self.class::OPERATOR}\s*(#{TOKEN})\z/
+        pattern = /\A#{keyword}\s*#{self.class::OPERATOR}\s*#{TOKEN}\z/
 
         tokens.each do |token|
-          next unless (value = token[pattern, 1])
+          next unless (value = token[pattern, :token])
 
           return value.downcase
         end
@@ -188,7 +188,7 @@ module RuboCop
     # @see https://www.gnu.org/software/emacs/manual/html_node/emacs/Specify-Coding.html
     # @see https://github.com/ruby/ruby/blob/3f306dc/parse.y#L6873-L6892 Emacs handling in parse.y
     class EmacsComment < EditorComment
-      REGEXP    = /-\*-(.+)-\*-/.freeze
+      REGEXP    = /-\*-(?<token>.+)-\*-/.freeze
       FORMAT    = '# -*- %s -*-'
       SEPARATOR = ';'
       OPERATOR  = ':'
@@ -216,7 +216,7 @@ module RuboCop
     #
     #   comment.encoding # => 'ascii-8bit'
     class VimComment < EditorComment
-      REGEXP    = /#\s*vim:\s*(.+)/.freeze
+      REGEXP    = /#\s*vim:\s*(?<token>.+)/.freeze
       FORMAT    = '# vim: %s'
       SEPARATOR = ', '
       OPERATOR  = '='
@@ -259,9 +259,11 @@ module RuboCop
     #   comment2.frozen_string_literal # => nil
     #   comment2.encoding              # => 'utf-8'
     class SimpleComment < MagicComment
+      FSTRING_LITERAL_COMMENT = 'frozen_string_literal:\s*(true|false)'
+
       # Match `encoding` or `coding`
       def encoding
-        extract(/\A\s*\#.*\b#{KEYWORDS[:encoding]}: (#{TOKEN})/io)
+        extract(/\A\s*\#\s*(#{FSTRING_LITERAL_COMMENT})?\s*#{KEYWORDS[:encoding]}: (#{TOKEN})/io)
       end
 
       # Rewrite the comment without a given token type
@@ -283,15 +285,15 @@ module RuboCop
       # Case-insensitive and dashes/underscores are acceptable.
       # @see https://github.com/ruby/ruby/blob/78b95b4/parse.y#L7134-L7138
       def extract_frozen_string_literal
-        extract(/\A\s*#\s*#{KEYWORDS[:frozen_string_literal]}:\s*(#{TOKEN})\s*\z/io)
+        extract(/\A\s*#\s*#{KEYWORDS[:frozen_string_literal]}:\s*#{TOKEN}\s*\z/io)
       end
 
       def extract_shareable_constant_value
-        extract(/\A\s*#\s*#{KEYWORDS[:shareable_constant_value]}:\s*(#{TOKEN})\s*\z/io)
+        extract(/\A\s*#\s*#{KEYWORDS[:shareable_constant_value]}:\s*#{TOKEN}\s*\z/io)
       end
 
       def extract_typed
-        extract(/\A\s*#\s*#{KEYWORDS[:typed]}:\s*(#{TOKEN})\s*\z/io)
+        extract(/\A\s*#\s*#{KEYWORDS[:typed]}:\s*#{TOKEN}\s*\z/io)
       end
     end
   end

data/lib/rubocop/rspec/shared_contexts.rb

@@ -11,6 +11,8 @@ RSpec.shared_context 'isolated environment' do # rubocop:disable Metrics/BlockLe
       # Make sure to expand all symlinks in the path first. Otherwise we may
       # get mismatched pathnames when loading config files later on.
       tmpdir = File.realpath(tmpdir)
+      # Make upwards search for .rubocop.yml files stop at this directory.
+      RuboCop::FileFinder.root_level = tmpdir
 
       virtual_home = File.expand_path(File.join(tmpdir, 'home'))
       Dir.mkdir(virtual_home)
@@ -21,9 +23,6 @@ RSpec.shared_context 'isolated environment' do # rubocop:disable Metrics/BlockLe
       root = example.metadata[:root]
       working_dir = root ? File.join(base_dir, 'work', root) : File.join(base_dir, 'work')
 
-      # Make upwards search for .rubocop.yml files stop at this directory.
-      RuboCop::FileFinder.root_level = working_dir
-
       begin
         FileUtils.mkdir_p(working_dir)
 

data/lib/rubocop/server/cache.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'fileutils'
 require 'pathname'
 require_relative '../cache_config'
 require_relative '../config_finder'

data/lib/rubocop/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   # This module holds the RuboCop version information.
   module Version
-    STRING = '1.56.2'
+    STRING = '1.57.1'
 
     MSG = '%<version>s (using Parser %<parser_version>s, ' \
           'rubocop-ast %<rubocop_ast_version>s, ' \

data/lib/rubocop.rb

@@ -580,6 +580,7 @@ require_relative 'rubocop/cop/style/redundant_regexp_constructor'
 require_relative 'rubocop/cop/style/redundant_self_assignment'
 require_relative 'rubocop/cop/style/redundant_self_assignment_branch'
 require_relative 'rubocop/cop/style/require_order'
+require_relative 'rubocop/cop/style/single_line_do_end_block'
 require_relative 'rubocop/cop/style/sole_nested_conditional'
 require_relative 'rubocop/cop/style/static_class'
 require_relative 'rubocop/cop/style/map_compact_with_conditional_block'

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: rubocop
 version: !ruby/object:Gem::Version
-  version: 1.56.2
+  version: 1.57.1
 platform: ruby
 authors:
 - Bozhidar Batsov
 - Jonas Arvidsson
 - Yuji Nakayama
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-08-29 00:00:00.000000000 Z
+date: 2023-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -74,14 +74,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.2.3
+        version: 3.2.2.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.2.2.3
+        version: 3.2.2.4
 - !ruby/object:Gem::Dependency
   name: rainbow
   requirement: !ruby/object:Gem::Requirement
@@ -895,6 +895,7 @@ files:
 - lib/rubocop/cop/style/signal_exception.rb
 - lib/rubocop/cop/style/single_argument_dig.rb
 - lib/rubocop/cop/style/single_line_block_params.rb
+- lib/rubocop/cop/style/single_line_do_end_block.rb
 - lib/rubocop/cop/style/single_line_methods.rb
 - lib/rubocop/cop/style/slicing_with_range.rb
 - lib/rubocop/cop/style/sole_nested_conditional.rb
@@ -1038,10 +1039,10 @@ metadata:
   homepage_uri: https://rubocop.org/
   changelog_uri: https://github.com/rubocop/rubocop/blob/master/CHANGELOG.md
   source_code_uri: https://github.com/rubocop/rubocop/
-  documentation_uri: https://docs.rubocop.org/rubocop/1.56/
+  documentation_uri: https://docs.rubocop.org/rubocop/1.57/
   bug_tracker_uri: https://github.com/rubocop/rubocop/issues
   rubygems_mfa_required: 'true'
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -1056,8 +1057,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.6
-signing_key: 
+rubygems_version: 3.3.7
+signing_key:
 specification_version: 4
 summary: Automatic Ruby code style checking tool.
 test_files: []