rubocop-crystal 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3beb9db336ee0d664fdd093775a9c14dc9512c8ec84be250ec177a6763b4924d
-  data.tar.gz: 015acc39018447fef5d62304bf91dddab3b66faa795149f00b3e447de6db5990
+  metadata.gz: 3e7cede16a18df18a0021747a7a5305d1503af8229d0a2790242b3b4ac5e27c2
+  data.tar.gz: 2373953ed41151d8a00749f28db4ac84ff144db91e02413b50e71f4d97c5627b
 SHA512:
-  metadata.gz: 2077733fe1bc6189b71854a249601f8294366a2d86cd013822bb6ec9fd1371e9229ad6622dc169426ae35c75b1f65e26f5308538a749e2b02fb7239ac99a087e
-  data.tar.gz: ea546caea1eeb127c946df8c97ec77ba7e5572db33c63402bba1ad4ffeeaca05d19d402d6c6a96aa37d4641f2aeda11d95a8f26a2e6b1c18a473961b8468d221
+  metadata.gz: e33199a6a2a74eb3e7739f0b2355b58e65b89d6bcc9001c4c62e246eea89fa7cb098dfb274da12b7dac220f90de5d672d94f2abb27d078c8a2ec273f8b81f990
+  data.tar.gz: bccb8bb8fba84d6b2208cb578bcbcc7e7a3c6c2202cee707e8fe511018ff128cb4dd6113aefd11912df78a9971183ea8497fe344b684002aa3144279756732c4

data/.github/workflows/rspec.yml

@@ -0,0 +1,16 @@
+name: RSpec
+on: [push, pull_request]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download source
+        uses: actions/checkout@v4
+      - name: Install Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.1.2'
+      - name: Install dependencies
+        run: gem install rspec rubocop
+      - name: Run spec
+        run: rspec

data/.github/workflows/rubocop.yml

@@ -0,0 +1,16 @@
+name: Rubocop
+on: [push, pull_request]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download source
+        uses: actions/checkout@v4
+      - name: Install Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '3.1.2'
+      - name: Install rubocop
+        run: gem install rubocop
+      - name: Run rubocop
+        run: rubocop

data/.github/workflows/test.yml

@@ -21,6 +21,6 @@ jobs:
           gem build rubocop-crystal
           gem install rubocop-crystal
       - name: Convert test files
-        run: rubocop --require rubocop-crystal --fail-level fatal -A test
+        run: rubocop --plugin rubocop-crystal -c config/default.yml --fail-level fatal -A test
       - name: Run tests (Crystal)
         run: crystal run test/string.cr

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,37 @@
+plugins:
+  - rubocop-internal_affairs
+
+AllCops:
+  NewCops: enable
+  Exclude:
+    - 'test/*'
+
+Gemspec/RequireMFA:
+  Enabled: false
+
+# TODO: Find out what ruby version we actually require and then remove this.
+Gemspec/RequiredRubyVersion:
+  Enabled: false
+
+InternalAffairs/OnSendWithoutOnCSend:
+  Exclude:
+    - 'lib/rubocop/cop/crystal/require_at_top_level.rb'
+    - 'lib/rubocop/cop/crystal/require_relative.rb'
+
+Layout/LineLength:
+  Enabled: false
+
+Metrics:
+  Enabled: false
+
+Naming/FileName:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: False
+
+Style/FrozenStringLiteralComment:
+  Enabled: False
+
+Style/MutableConstant:
+  Enabled: False

data/CHANGELOG.md

@@ -1,3 +1,29 @@
+## 0.0.4 (2025-09-21)
+
+### New features
+
+* Add Crystal/EnumerableReduce cop ([@zopolis4][])
+* Add Crystal/EnumerableSize cop ([@zopolis4][])
+* Add Crystal/FileReadLines cop ([@zopolis4][])
+* Add Crystal/MethodReturningChar cop ([@zopolis4][])
+* Add Crystal/RequireAtTopLevel cop ([@zopolis4][])
+
+### Changes
+
+* Add files ending in .cr to the list of files to be checked in the default config ([@zopolis4][])
+
+## 0.0.3 (2025-04-28)
+
+### New features
+
+* Enable Style/BlockComments cop ([@zopolis4][])
+* Enable Style/WhileUntilDo cop ([@zopolis4][])
+* Add Crystal/MethodNameStartingWithUppercaseLetter cop ([@zopolis4][])
+
+### Changes
+
+* Convert to Rubocop plugin ([@zopolis4][])
+
 ## 0.0.2 (2024-08-01)
 
 ### New features

data/README.md

@@ -10,7 +10,7 @@ Getting static type information about Ruby files isn't the difficult part, the p
 
 Inserting Crystal types into Ruby code is a no-go, because that causes `Lint/Syntax` errors in RuboCop.
 
-Possible paths foward:
+Possible paths forward:
 - Modify the parser to accept Crystal type declarations, or at least not break on them.
 - Modify Crystal to accept type declarations from `.rbs` and/or `.rbi` files.
 - Modify Crystal to accept type declarations from sorbet/rbs-inline/other annotations.
@@ -38,5 +38,9 @@ gem install rubocop-crystal
 ## Usage
 
 ```
-rubocop --require rubocop-crystal
+rubocop --plugin rubocop-crystal
 ```
+
+Note that there are some differences between Ruby and Crystal that can be automatically resolved, while some (at least for now) require manual intervention.
+
+If you wish to only process the autocorrectable offenses, add `--disable-uncorrectable`, while reporting only the offenses requiring manual intervention is waiting on rubocop/rubocop#13275.

data/config/default.yml

@@ -1,14 +1,43 @@
 AllCops:
   DisabledByDefault: true
+  inherit_mode:
+    merge:
+      - Include
+  Include:
+    - '**/*.cr'
+
+Crystal/EnumerableReduce:
+  Description: 'This cop replaces .inject with .reduce and converts reducer functions to their block counterparts.'
+  Enabled: true
+
+Crystal/EnumerableSize:
+  Description: 'This cop replaces .length and .count with .size when they are used as aliases for .size'
+  Enabled: true
 
 Crystal/FileExtension:
   Description: 'This cop renames files ending in `.rb` to `.cr`.'
   Enabled: true
 
+Crystal/FileReadLines:
+  Description: "This cop replaces Ruby's IO.readlines with Crystal's File.read_lines or IO.each_line."
+  Enabled: true
+
 Crystal/InterpolationInSingleQuotes:
   Description: "This cop uses %q in place of ' if the enclosed string would be affected by interpolation."
   Enabled: true
 
+Crystal/MethodNameStartingWithUppercaseLetter:
+  Description: 'This cop detects method names that start with uppercase letters.'
+  Enabled: true
+
+Crystal/MethodReturningChar:
+  Description: 'This cop detects methods that, in Crystal, return the Char type instead of a 1-character string, and modifies them accordingly.'
+  Enabled: true
+
+Crystal/RequireAtTopLevel:
+  Description: 'This cop detects instances of require that are not at the top level.'
+  Enabled: true
+
 Crystal/RequireRelative:
   Description: 'This cop replaces require_relative with require while maintaining behavior.'
   Enabled: true
@@ -16,9 +45,15 @@ Crystal/RequireRelative:
 Lint/ImplicitStringConcatenation:
   Enabled: true
 
+Style/BlockComments:
+  Enabled: true
+
+Style/MethodDefParentheses:
+  Enabled: true
+
 Style/StringLiterals:
   Enabled: true
   EnforcedStyle: double_quotes
 
-Style/MethodDefParentheses:
+Style/WhileUntilDo:
   Enabled: true

data/lib/rubocop/cop/crystal/enumerable_reduce.rb

@@ -0,0 +1,58 @@
+module RuboCop
+  module Cop
+    module Crystal
+      # Ruby has Enumerable.inject, which can take either a block or a reducer function,
+      # and an optional initial value. Enumerable.reduce is an alias of this.
+      # Crystal only has Enumerable.reduce, which does not support reducer functions.
+      #
+      # @example
+      #   # bad
+      #   x.inject { |r,v| r + v }
+      #   x.inject(:+)
+      #   x.reduce(:+)
+      #
+      #   # good
+      #   x.reduce { |r,v| r + v }
+      #
+      #   # bad
+      #   x.inject(y) { |r,v| r + v }
+      #   x.inject(y, :+)
+      #   x.reduce(y, :+)
+      #
+      #   # good
+      #   x.reduce(y) { |r,v| r + v }
+      #
+      class EnumerableReduce < Base
+        extend AutoCorrector
+
+        MSG = 'Crystal has .reduce instead of .inject'
+        RESTRICT_ON_SEND = %i[inject reduce]
+
+        def on_send(node)
+          new_node = node.receiver.source
+          new_node << if node.csend_type?
+                        '&.'
+                      else
+                        '.'
+                      end
+          new_node << 'reduce'
+          if node.arguments?
+            if node.parent&.block_type?
+              new_node << "(#{node.first_argument.source})"
+            else
+              new_node << "(#{node.first_argument.source})" if node.arguments.size == 2
+              new_node << " { |r,v| r.#{node.last_argument.source.delete_prefix(':')}(v) }"
+            end
+          end
+
+          return if node.source == new_node
+
+          add_offense(node.selector) do |corrector|
+            corrector.replace(node, new_node)
+          end
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

data/lib/rubocop/cop/crystal/enumerable_size.rb

@@ -0,0 +1,31 @@
+module RuboCop
+  module Cop
+    module Crystal
+      # Crystal does not have the .length or .count methods as aliases to .size
+      #
+      # @example
+      #   # bad
+      #   x.length
+      #   x.count
+      #
+      #   # good
+      #   x.size
+      #
+      class EnumerableSize < Base
+        extend AutoCorrector
+
+        MSG = 'Crystal does not have the .length or .count methods as aliases to .size'
+        RESTRICT_ON_SEND = %i[count length]
+
+        def on_send(node)
+          return if node.arguments? || node.parent&.block_type?
+
+          add_offense(node.selector) do |corrector|
+            corrector.replace(node.selector, 'size')
+          end
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

data/lib/rubocop/cop/crystal/file_extension.rb

@@ -13,6 +13,7 @@ module RuboCop
       #
       class FileExtension < Base
         extend AutoCorrector
+
         MSG = 'Crystal files have `.cr` extensions, while Ruby files have `.rb` extensions.'
 
         def on_new_investigation

data/lib/rubocop/cop/crystal/file_read_lines.rb

@@ -0,0 +1,115 @@
+module RuboCop
+  module Cop
+    module Crystal
+      # Ruby has IO.readlines, which supports chomp (false by default), limit and separator arguments, and has special behaviors for empty and nil separators.
+      # Crystal has File.read_lines, which only supports the chomp (true by default) argument, and IO.each_line, which supports limit and separator arguments,
+      # but does not have special behaviors for empty and nil separators, so we recreate that ourselves.
+      #
+      # @example
+      #   # bad
+      #   File.readlines('foo')
+      #   IO.readlines('foo')
+      #
+      #   # good
+      #   File.read_lines('foo', chomp: false)
+      #
+      #   # bad
+      #   File.readlines('foo', 'b', 3)
+      #   IO.readlines('foo', 'b', 3)
+      #
+      #   # good
+      #   File.open('foo').each_line('b', 3).to_a
+      #
+      #   # bad
+      #   File.readlines('foo', nil)
+      #   IO.readlines('foo', nil)
+      #
+      #   # bad
+      #   File.readlines("foo", '')
+      #   IO.readlines("foo", '')
+      #
+      #   # good
+      #   File.open("foo").each_line("\n").to_a.join.split(/\n{2,}/).reject { |e| e.empty? }.reverse.map_with_index {|e, i| i == 0 ? e : "#{e}\n\n" }.reverse
+      #
+      class FileReadLines < Base
+        extend AutoCorrector
+
+        MSG = 'Ruby has IO.readlines, while Crystal has File.read_lines and IO.each_line'
+        RESTRICT_ON_SEND = %i[readlines]
+
+        # @!method no_arguments?(node)
+        def_node_matcher :no_arguments?, <<~PATTERN
+          (send (send (const {nil? cbase} :File) ... ) :readlines)
+        PATTERN
+
+        # @!method path_argument?(node)
+        def_node_matcher :path_argument?, <<~PATTERN
+          (send (const {nil? cbase} {:File :IO}) :readlines (str $_))
+        PATTERN
+
+        # @!method path_and_chomp_argument?(node)
+        def_node_matcher :path_and_chomp_argument?, <<~PATTERN
+          (send (const {nil? cbase} {:File :IO}) :readlines (str _) (hash (pair (sym :chomp) _)))
+        PATTERN
+
+        # TODO: Do this properly once https://github.com/rubocop/rubocop-ast/pull/386 is merged.
+        # @!method path_and_empty_separator_argument?(node)
+        def_node_matcher :path_and_empty_separator_argument?, <<~PATTERN
+          (send (const {nil? cbase} {:File :IO}) :readlines (str $_) (str empty?))
+        PATTERN
+
+        # @!method path_and_nil_separator_argument?(node)
+        def_node_matcher :path_and_nil_separator_argument?, <<~PATTERN
+          (send (const {nil? cbase} {:File :IO}) :readlines (str $_) nil)
+        PATTERN
+
+        # @!method path_and_separator_argument?(node)
+        def_node_matcher :path_and_separator_argument?, <<~PATTERN
+          (send (const {nil? cbase} {:File :IO}) :readlines (str $_) (str $_))
+        PATTERN
+
+        # @!method path_and_limiter_argument?(node)
+        def_node_matcher :path_and_limiter_argument?, <<~PATTERN
+          (send (const {nil? cbase} {:File :IO}) :readlines (str $_) (int $_))
+        PATTERN
+
+        # @!method path_separator_and_limiter_argument?(node)
+        def_node_matcher :path_separator_and_limiter_argument?, <<~PATTERN
+          (send (const {nil? cbase} {:File :IO}) :readlines (str $_) (str $_) (int $_))
+        PATTERN
+
+        def on_send(node)
+          if no_arguments?(node)
+            autocorrect(node, node.source.sub('.readlines', '.each_line.to_a'))
+          elsif (path = path_argument?(node))
+            autocorrect(node, "File.read_lines(\"#{path}\", chomp: false)")
+          elsif path_and_chomp_argument?(node)
+            autocorrect(node, node.source.sub(/(File|IO)\.readlines/, 'File.read_lines'))
+          elsif (path = path_and_empty_separator_argument?(node))
+            # TODO: There's probably a slightly cleaner way to replicate Ruby's "paragraph" separator behavior.
+            autocorrect(node, "File.open(\"#{path}\").each_line(\"\\n\").to_a.join.split(/\\n{2,}/).reject { |e| e.empty? }.reverse.map_with_index {|e, i| i == 0 ? e : \"\#{e}\\n\\n\" }.reverse")
+          elsif (path = path_and_nil_separator_argument?(node))
+            # TODO: Crystal might technically support this more cleanly, although this doesn't appear to be documented.
+            # https://github.com/crystal-lang/crystal/blob/1.17.1/src/io.cr#L818-L822
+            autocorrect(node, "[File.open(\"#{path}\").each_line(chomp: false).to_a.join]")
+          elsif (path, separator = path_and_separator_argument?(node))
+            autocorrect(node, "File.open(\"#{path}\").each_line(\"#{separator}\").to_a")
+          elsif (path, limiter = path_and_limiter_argument?(node))
+            autocorrect(node, "File.open(\"#{path}\").each_line(#{limiter}).to_a")
+          elsif (path, separator, limiter = path_separator_and_limiter_argument?(node))
+            autocorrect(node, "File.open(\"#{path}\").each_line(\"#{separator}\", #{limiter}).to_a")
+          end
+        end
+        alias on_csend on_send
+
+        private
+
+        def autocorrect(node, replacement)
+          add_offense(node.selector) do |corrector|
+            corrector.replace(node, replacement)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/crystal/interpolation_in_single_quotes.rb

@@ -16,6 +16,7 @@ module RuboCop
       #
       class InterpolationInSingleQuotes < Base
         extend AutoCorrector
+
         MSG = 'Crystal does not support the use of single-quote deliminated strings to avoid interpolation.'
 
         def on_str(node)
@@ -23,10 +24,10 @@ module RuboCop
           return unless node.source.start_with?("'")
           # Replace the single quotes deliminating the string with double quotes, and check if the resulting ast is still the same.
           # If it is, the string doesn't have any interpolation to avoid, and we're done here.
-          return if node == parse('"' + node.source[1..-2] + '"').ast
+          return if node == parse("\"#{node.source[1..-2]}\"").ast
 
           add_offense(node) do |corrector|
-            corrector.replace(node, '%q(' + node.source[1..-2] + ')')
+            corrector.replace(node, "%q(#{node.source[1..-2]})")
           end
         end
       end

data/lib/rubocop/cop/crystal/method_name_starting_with_uppercase_letter.rb

@@ -0,0 +1,30 @@
+module RuboCop
+  module Cop
+    module Crystal
+      # Method names cannot start with uppercase letters in Crystal:
+      # https://crystal-lang.org/reference/latest/syntax_and_semantics/methods_and_instance_variables.html
+      # ^ "Method names begin with a lowercase letter and, as a convention, only use lowercase letters, underscores and numbers."
+      #
+      # @example
+      #   # bad
+      #   def Foo(bar)
+      #     qux
+      #   end
+      #   Foo(bar)
+      #
+      #   # good
+      #   def foo(bar)
+      #     qux
+      #   end
+      #   foo(bar)
+      #
+      class MethodNameStartingWithUppercaseLetter < Base
+        MSG = 'Method names must start with a lowercase letter in Crystal.'
+
+        def on_def(node)
+          add_offense(node.loc.name) if node.method_name.to_s.chr.capitalize!.nil?
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/crystal/method_returning_char.rb

@@ -0,0 +1,54 @@
+module RuboCop
+  module Cop
+    module Crystal
+      # In Crystal, certain methods return a single character of type Char, while in Ruby they return a 1-character string.
+      # Chars and 1-character strings are treated differently in Crystal, and will not count as equal even if they contain the same content.
+      #
+      # @example
+      #   # bad
+      #   x.chars
+      #
+      #   # good
+      #   x.chars.map { |c| c.to_s }
+      #
+      #   # bad
+      #   x.each_char { |c| y << c }
+      #
+      #   # good
+      #   x.each_char { |c| y << c.to_s }
+      #
+      class MethodReturningChar < Base
+        extend AutoCorrector
+
+        MSG = 'In Crystal, this method returns the Char type instead of a 1-character string.'
+        RESTRICT_ON_SEND = %i[chars each_char]
+
+        # @!method map_to_s?(node)
+        def_node_matcher :map_to_s?, <<~PATTERN
+          (block (send (call (...) :chars) :map) (args (arg :c)) (send (lvar :c) :to_s))
+        PATTERN
+
+        def on_send(node)
+          if node.method?(:chars) && !map_to_s?(node.parent&.parent)
+            add_offense(node.selector) do |corrector|
+              corrector.insert_after(node.selector, '.map { |c| c.to_s }')
+            end
+          elsif node.method?(:each_char)
+            nodes_to_correct = []
+            node.parent.body.each_descendant do |n|
+              # If a node is an lvar with the same name as the character argument and it does not have a .to_s, it needs to be corrected.
+              nodes_to_correct << n if n.lvar_type? && n.source == node.parent.first_argument.source.gsub('|', '') && !n.parent.method?(:to_s)
+            end
+
+            return if nodes_to_correct.empty?
+
+            add_offense(node.selector) do |corrector|
+              nodes_to_correct.each { |n| corrector.insert_after(n, '.to_s') }
+            end
+          end
+        end
+        alias on_csend on_send
+      end
+    end
+  end
+end

data/lib/rubocop/cop/crystal/require_at_top_level.rb

@@ -0,0 +1,35 @@
+module RuboCop
+  module Cop
+    module Crystal
+      # As of Crystal 0.7.7, require is only allowed at the top level:
+      # https://github.com/crystal-lang/crystal/releases/tag/0.7.7
+      # ^ "(breaking change) require is now only allowed at the top-level, never inside other types or methods."
+      #
+      # @example
+      #   # bad
+      #   def foo
+      #     require 'bar'
+      #   end
+      #
+      #   class Foo
+      #     require 'bar'
+      #   end
+      #
+      #   module Foo
+      #     require 'bar'
+      #   end
+      #
+      #   # good
+      #   require 'bar'
+      #
+      class RequireAtTopLevel < Base
+        MSG = 'Crystal does not allow require anywhere other than the top level.'
+        RESTRICT_ON_SEND = [:require]
+
+        def on_send(node)
+          add_offense(node) if %i[def class module].include?(node.parent&.type)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/crystal/require_relative.rb

@@ -19,16 +19,17 @@ module RuboCop
       #
       class RequireRelative < Base
         extend AutoCorrector
+
         MSG = 'Crystal does not support require_relative.'
         RESTRICT_ON_SEND = [:require_relative]
 
         def on_send(node)
           add_offense(node) do |corrector|
-            if node.first_argument.value.start_with?('.', '/')
-              require_value = node.first_argument.value
-            else
-              require_value = "./#{node.first_argument.value}"
-            end
+            require_value = if node.first_argument.value.start_with?('.', '/')
+                              node.first_argument.value
+                            else
+                              "./#{node.first_argument.value}"
+                            end
             corrector.replace(node, "require '#{require_value}'")
           end
         end

data/lib/rubocop/cop/crystal_cops.rb

@@ -1,3 +1,9 @@
+require_relative 'crystal/enumerable_reduce'
+require_relative 'crystal/enumerable_size'
 require_relative 'crystal/file_extension'
+require_relative 'crystal/file_read_lines'
 require_relative 'crystal/interpolation_in_single_quotes'
+require_relative 'crystal/method_name_starting_with_uppercase_letter'
+require_relative 'crystal/method_returning_char'
+require_relative 'crystal/require_at_top_level'
 require_relative 'crystal/require_relative'

data/lib/rubocop/crystal/plugin.rb

@@ -0,0 +1,28 @@
+require 'lint_roller'
+
+module RuboCop
+  module Crystal
+    class Plugin < LintRoller::Plugin
+      def about
+        LintRoller::About.new(
+          name: 'rubocop-crystal',
+          version: '0.0.4',
+          homepage: 'https://github.com/Zopolis4/rubocop-crystal',
+          description: 'A RuboCop extension for converting Ruby to Crystal.'
+        )
+      end
+
+      def supported?(context)
+        context.engine == :rubocop
+      end
+
+      def rules(_context)
+        LintRoller::Rules.new(
+          type: :path,
+          config_format: :rubocop,
+          value: Pathname.new(__dir__).join('../../../config/default.yml')
+        )
+      end
+    end
+  end
+end

data/lib/rubocop-crystal.rb

@@ -1,8 +1,6 @@
 require 'rubocop'
 
 require_relative 'rubocop/crystal'
-require_relative 'rubocop/crystal/inject'
-
-RuboCop::Crystal::Inject.defaults!
+require_relative 'rubocop/crystal/plugin'
 
 require_relative 'rubocop/cop/crystal_cops'

data/rubocop-crystal.gemspec

@@ -1,14 +1,17 @@
 Gem::Specification.new do |spec|
   spec.name     = 'rubocop-crystal'
   spec.summary  = 'A RuboCop extension for converting Ruby to Crystal.'
-  spec.version  = '0.0.2'
+  spec.version  = '0.0.4'
   spec.license  = 'GPL-3.0-or-later'
   spec.author   = 'Zopolis4'
   spec.email    = 'creatorsmithmdt@gmail.com'
   spec.homepage = 'https://github.com/Zopolis4/rubocop-crystal'
 
+  spec.metadata['default_lint_roller_plugin'] = 'RuboCop::Crystal::Plugin'
+
   spec.files         = `git ls-files`.split("\n")
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'rubocop', '>= 1.65.1'
+  spec.add_dependency 'lint_roller'
+  spec.add_dependency 'rubocop', '>= 1.80.2'
 end