spoom 1.8.4 → 1.8.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f138cb37a9cdcc10a7195440a948f6f9a3d2225ac032e2179823cf327b3d803
-  data.tar.gz: 9d8b55599e6de489d29362353f9ac3802b12ad85b6e9e34b40c09b07127ace47
+  metadata.gz: 80c79d30a04cc756ee5992c7ced516b76b7cf9887a68b63862118a439404f972
+  data.tar.gz: c2f33b188c0972d39afe6c1b5b1ff789ab13afd89e473c621798bf7c7bca97b3
 SHA512:
-  metadata.gz: 708cb8b80b385e27c7d5a3e9cc05fbc475df994977a3cbf3ef4a1ea2cf592c91376bf9f1000aa7991ed0c154bb0e3ecc5120bd5ab01c94ca6e20a9a1bac98322
-  data.tar.gz: 262a4f6b42009e39c91a6e312ed54aba0056e6dd71d5ce136448c4f1343ee1037159a13ebb77d6f68113d64db7ebc3de61bad289440f0fa8b5efcca5e3444ee6
+  metadata.gz: e3769e883671aca623fdc186ca25e86a3c10e02e70206d6f3a8e282d5355a9a0c55ae82ea760994746d923738151d923e519337b64352bb06ce4fae4d7139ea1
+  data.tar.gz: 2fd05b69029f46c77ae5716ebdbff8e887ebd894a20d60520299a47bee1d6a69531f910a3663d64963fbdac0353a2cabde8b1d891b53637d5188336cea5f3c5a

data/README.md

@@ -1,174 +1,190 @@
 # Spoom
 
-Useful tools for Sorbet enthusiasts.
+Useful tools for Sorbet projects.
+
+Spoom provides a CLI and a Ruby API to inspect Sorbet projects, improve typing coverage, translate signatures, query Sorbet LSP, and find dead code.
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Add Spoom to your application's Gemfile:
 
 ```ruby
-gem 'spoom'
+gem "spoom"
 ```
 
-And then execute:
+Then install it:
 
-    $ bundle
+```sh
+bundle install
+```
 
-Or install it yourself as:
+Or install it directly:
 
-    $ gem install spoom
+```sh
+gem install spoom
+```
 
-## Usage
+Spoom requires Ruby 3.3 or newer.
 
-`spoom` provides both a CLI and an API to interact with Sorbet.
+## Command line interface
 
-### Generate a typing coverage report
+Run `spoom help` or `spoom help COMMAND` to list all available commands.
 
-Spoom can create a typing coverage report from Sorbet and Git data:
+### Typechecking errors
 
-![Coverage Report](docs/report.png)
+`spoom srb tc` runs `srb tc` and can sort, filter, format, and export errors.
 
-After installing the `spoom` gem, run the `timeline` command to collect the history data:
+List errors sorted by location:
 
-```
-$ spoom srb coverage timeline --save
+```sh
+spoom srb tc --sort loc
 ```
 
-Then create the HTML page with `report`:
+List errors sorted by error code:
 
-```
-$ spoom srb coverage report
+```sh
+spoom srb tc --sort code
 ```
 
-Your report will be generated under `spoom_report.html`.
+List only errors with a specific code:
 
-See all the [Typing Coverage](#typing-coverage) CLI commands for more details.
+```sh
+spoom srb tc --code 7004
+```
 
-### Command Line Interface
+Limit the number of displayed errors:
 
-#### Errors sorting and filtering
+```sh
+spoom srb tc --limit 10
+```
 
-List all typechecking errors sorted by location:
+Options can be combined:
 
-```
-$ spoom srb tc -s loc
+```sh
+spoom srb tc --sort code --code 7004 --limit 10
 ```
 
-List all typechecking errors sorted by error code first:
+Remove duplicated error lines:
 
-```
-$ spoom srb tc -s code
+```sh
+spoom srb tc --uniq
 ```
 
-List only typechecking errors from a specific error code:
+Format each error line:
 
-```
-$ spoom srb tc -c 7004
+```sh
+spoom srb tc --format "%C - %F:%L: %M"
 ```
 
-List only the first 10 typechecking errors
+Format tokens:
 
-```
-$ spoom srb tc -l 10
-```
+* `%C`: error code
+* `%F`: file path
+* `%L`: line number
+* `%M`: error message
 
-These options can be combined:
+Hide the final `Errors: X` count:
 
-```
-$ spoom srb tc -s -c 7004 -l 10
+```sh
+spoom srb tc --no-count
 ```
 
-Remove duplicated error lines:
+List only errors from specific files or directories:
 
-```
-$ spoom srb tc -u
+```sh
+spoom srb tc file1.rb path1/ path2/
 ```
 
-Format each error line:
+Write errors to a JUnit XML file:
 
+```sh
+spoom srb tc --junit-output-path junit.xml
 ```
-$ spoom srb tc -f '%C - %F:%L: %M'
+
+Pass extra options to Sorbet:
+
+```sh
+spoom srb tc --sorbet-options="--typed=true"
 ```
 
-Where:
+### Typing coverage
 
-* `%C` is the error code
-* `%F` is the file the error is from
-* `%L` is the line the error is from
-* `%M` is the error message
+`spoom srb coverage` collects Sorbet coverage metrics and can generate an HTML report from Sorbet and Git data.
 
-Hide the `Errors: X` at the end of the list:
+![Coverage Report](docs/report.png)
 
-```
-$ spoom srb tc --no-count
+Show a coverage snapshot:
+
+```sh
+spoom srb coverage
 ```
 
-List only the errors coming from specific directories or files:
+Save a snapshot under `spoom_data/`:
 
+```sh
+spoom srb coverage --save
 ```
-$ spoom srb tc file1.rb path1/ path2/
-```
-
-#### Typing coverage
 
-Show metrics about the project contents and the typing coverage:
+Save a snapshot under a specific directory:
 
-```
-$ spoom srb coverage
+```sh
+spoom srb coverage --save my_data/
 ```
 
-Save coverage data under `spoom_data/`:
+Show typing coverage evolution based on Git history:
 
-```
-$ spoom srb coverage --save
+```sh
+spoom srb coverage timeline
 ```
 
-Save coverage data under a specific directory:
+Replay a specific date range:
 
-```
-$ spoom srb coverage --save my_data/
+```sh
+spoom srb coverage timeline --from YYYY-MM-DD --to YYYY-MM-DD
 ```
 
-Show typing coverage evolution based on the commits history:
+Save timeline snapshots under `spoom_data/`:
 
-```
-$ spoom srb coverage timeline
+```sh
+spoom srb coverage timeline --save
 ```
 
-Show typing coverage evolution based on the commits history between specific dates:
+Save timeline snapshots under a specific directory:
 
-```
-$ spoom srb coverage timeline --from YYYY-MM-DD --to YYYY-MM-DD
+```sh
+spoom srb coverage timeline --save my_data/
 ```
 
-Save the typing coverage evolution as JSON under `spoom_data/`:
+Run `bundle install` before collecting each timeline snapshot:
 
-```
-$ spoom srb coverage timeline --save
+```sh
+spoom srb coverage timeline --bundle-install
 ```
 
-Save the typing coverage evolution as JSON in a specific directory:
+Generate an HTML coverage report from saved snapshots:
 
-```
-$ spoom srb coverage timeline --save my_data/
+```sh
+spoom srb coverage report
 ```
 
-Run `bundle install` for each commit of the timeline (may solve errors due to different Sorbet versions):
+The report is generated at `spoom_report.html` by default.
 
-```
-$ spoom srb coverage timeline --bundle-install
+Generate a report from a custom data directory:
+
+```sh
+spoom srb coverage report --data my_data/
 ```
 
-Generate an HTML typing coverage report:
+Change the generated report path:
 
-```
-$ spoom srb coverage report
+```sh
+spoom srb coverage report --file coverage.html
 ```
 
-Change the colors used for strictnesses (useful for colorblind folks):
+Change report colors:
 
-```
-$ spoom srb coverage report \
+```sh
+spoom srb coverage report \
   --color-true "#648ffe" \
   --color-false "#fe6002" \
   --color-ignore "#feb000" \
@@ -176,123 +192,213 @@ $ spoom srb coverage report \
   --color-strong "#6444f1"
 ```
 
-Open the HTML typing coverage report:
+Open the HTML coverage report:
 
+```sh
+spoom srb coverage open
 ```
-$ spoom srb coverage open
+
+Open a report at a custom path:
+
+```sh
+spoom srb coverage open coverage.html
 ```
 
-#### Change the sigil used in files
+### Sorbet sigils
 
-Bump the strictness from all files currently at `typed: false` to `typed: true` where it does not create typechecking errors:
+`spoom srb bump` changes `# typed:` sigils when the change does not introduce typechecking errors.
 
-```
-$ spoom srb bump --from false --to true
+Bump files from `typed: false` to `typed: true`:
+
+```sh
+spoom srb bump --from false --to true
 ```
 
-Bump the strictness from all files currently at `typed: false` to `typed: true` even if it creates typechecking errors:
+Force the change without typechecking:
 
-```
-$ spoom srb bump --from false --to true -f
+```sh
+spoom srb bump --from false --to true --force
 ```
 
-Bump the strictness from a list of files (one file by line):
+Bump only files listed in a file, one path per line:
 
-```
-$ spoom srb bump --from false --to true -o list.txt
+```sh
+spoom srb bump --from false --to true --only list.txt
 ```
 
-Check if files can be bumped without applying any change and show the list of files that can be bumped without errors.
-Will exit with a non-zero status if some files can be bumped without errors (useful to check for bumpable files on CI for example):
+Check which files can be bumped without applying changes:
 
-```
-$ spoom srb bump --from false --to true --dry
+```sh
+spoom srb bump --from false --to true --dry
 ```
 
-Bump files using a custom instance of Sorbet:
+This command exits with a non-zero status when files can be bumped, which is useful in CI.
 
-```
-$ spoom srb bump --from false --to true --sorbet /path/to/sorbet/bin
+Use a custom Sorbet executable:
+
+```sh
+spoom srb bump --from false --to true --sorbet /path/to/sorbet/bin
 ```
 
-Count the number of type-checking errors if all files were bumped to true:
+Count typechecking errors if all files were bumped:
 
+```sh
+spoom srb bump --from false --to true --count-errors --dry
 ```
-$ spoom srb bump --count-errors --dry
+
+### Signatures and type assertions
+
+`spoom srb sigs` translates signatures between Sorbet RBI syntax and RBS comments.
+
+Translate signatures from RBI to RBS comments:
+
+```sh
+spoom srb sigs translate
 ```
 
-#### Translate sigs between RBI and RBS
+Translate signatures from RBS comments to RBI:
+
+```sh
+spoom srb sigs translate --from rbs --to rbi path/to/file.rb
+```
 
-Translate all file sigs from RBI to RBS:
+Strip Sorbet signatures from files:
 
+```sh
+spoom srb sigs strip path/to/file.rb
 ```
-$ spoom srb sigs translate
+
+Export gem signatures to an RBI file:
+
+```sh
+spoom srb sigs export
 ```
 
-Translate one file's sigs from RBS to RBI:
+Check that the exported RBI file is up to date:
 
+```sh
+spoom srb sigs export --check-sync
 ```
-$ spoom srb sigs translate --from rbs --to rbi /path/to/file.rb
+
+`spoom srb assertions` translates Sorbet type assertions to RBS comments:
+
+```sh
+spoom srb assertions translate path/to/file.rb
 ```
 
-#### Interact with Sorbet LSP mode
+### Sorbet LSP
+
+`spoom srb lsp` sends requests to Sorbet LSP.
 
-**Experimental**
+This command group is experimental.
 
-Find all definitions for `Foo`:
+Find symbols matching `Foo`:
 
+```sh
+spoom srb lsp find Foo
 ```
-$ spoom srb lsp find Foo
+
+List symbols in a file:
+
+```sh
+spoom srb lsp symbols file.rb
 ```
 
-List all symbols in a file:
+List definitions for a code location:
 
+```sh
+spoom srb lsp defs file.rb 10 4
 ```
-$ spoom srb lsp symbols <file.rb>
+
+List references for a code location:
+
+```sh
+spoom srb lsp refs file.rb 10 4
 ```
 
-List all definitions for a specific code location:
+Show hover information for a code location:
 
+```sh
+spoom srb lsp hover file.rb 10 4
 ```
-$ spoom srb lsp defs <file.rb> <line> <column>
+
+Show signature information for a code location:
+
+```sh
+spoom srb lsp sigs file.rb 10 4
 ```
 
-List all references for a specific code location:
+Show type information for a code location:
 
+```sh
+spoom srb lsp types file.rb 10 4
 ```
-$ spoom srb lsp refs <file.rb> <line> <column>
+
+### Sorbet code metrics
+
+`spoom srb metrics` collects metrics about Sorbet usage in Ruby files.
+
+Show metrics for the current project:
+
+```sh
+spoom srb metrics
 ```
 
-Show hover information for a specific code location:
+Show metrics for specific files or directories:
 
+```sh
+spoom srb metrics lib/ test/foo_test.rb
 ```
-$ spoom srb lsp hover <file.rb> <line> <column>
+
+Dump raw metric keys and values:
+
+```sh
+spoom srb metrics --dump
 ```
 
-Show signature information for a specific code location:
+### Dead code
 
+`spoom deadcode` indexes a project and reports definitions that do not appear to be referenced.
+
+Analyze the current project:
+
+```sh
+spoom deadcode
 ```
-$ spoom srb lsp sig <file.rb> <line> <column>
+
+Analyze specific paths:
+
+```sh
+spoom deadcode lib/ app/models/
 ```
 
-Show type information for a specific code location:
+Show files, loaded plugins, definitions, or references used during analysis:
 
+```sh
+spoom deadcode --show-files
+spoom deadcode --show-plugins
+spoom deadcode --show-defs
+spoom deadcode --show-refs
 ```
-$ spoom srb lsp sig <file.rb> <line> <column>
+
+Remove a reported dead code candidate:
+
+```sh
+spoom deadcode remove path/to/file.rb:42:18-47:23
 ```
 
-### API
+## Ruby API
 
-#### Parsing Sorbet config
+### Parsing Sorbet config
 
-Parses a Sorbet config file:
+Parse a Sorbet config file:
 
 ```ruby
 config = Spoom::Sorbet::Config.parse_file("sorbet/config")
-puts config.paths   # "."
+puts config.paths
 ```
 
-Parses a Sorbet config string:
+Parse a Sorbet config string:
 
 ```ruby
 config = Spoom::Sorbet::Config.parse_string(<<~CONFIG)
@@ -300,30 +406,31 @@ config = Spoom::Sorbet::Config.parse_string(<<~CONFIG)
   --file=b
   --ignore=c
 CONFIG
-puts config.paths   # "a", "b"
-puts config.ignore  # "c"
+
+puts config.paths
+puts config.ignore
 ```
 
-List all files typchecked by Sorbet:
+List all files typechecked by Sorbet:
 
 ```ruby
 config = Spoom::Sorbet::Config.parse_file("sorbet/config")
-puts Spoom::Sorbet.srb_files(config)
+puts Spoom::Context.new(".").srb_files(with_config: config)
 ```
 
-#### Parsing Sorbet metrics
+### Parsing Sorbet metrics
 
 Display metrics collected during typechecking:
 
 ```ruby
-puts Spoom::Sorbet.srb_metrics(capture_err: false)
+puts Spoom::Context.new(".").srb_metrics(capture_err: false)
 ```
 
-#### Interacting with LSP
+### Interacting with LSP
 
 Create an LSP client:
 
-```rb
+```ruby
 client = Spoom::LSP::Client.new(
   Spoom::Sorbet::BIN_PATH,
   "--lsp",
@@ -333,71 +440,88 @@ client = Spoom::LSP::Client.new(
 client.open(".")
 ```
 
-Find all the symbols matching a string:
+Find symbols matching a string:
 
-```rb
+```ruby
 puts client.symbols("Foo")
 ```
 
-Find all the symbols for a file:
+Find symbols in a file:
 
-```rb
+```ruby
 puts client.document_symbols("file://path/to/my/file.rb")
 ```
 
-### Backtrace Filtering
+## Backtrace filtering
+
+Spoom provides a Minitest backtrace filter that removes Sorbet frames from test failures.
 
-Spoom provides a backtrace filter for Minitest to remove the Sorbet frames from test failures, giving a more readable output. To enable it:
+Enable it in your test helper:
 
 ```ruby
 # test/test_helper.rb
 require "spoom/backtrace_filter/minitest"
+
 Minitest.backtrace_filter = Spoom::BacktraceFilter::Minitest.new
 ```
 
-### Dead code removal
+## Development
 
-Run dead code detection in your project with:
+After checking out the repo, install dependencies:
 
+```sh
+bin/setup
 ```
-$ spoom deadcode
-```
-
-This will list all the methods and constants that do not appear to be used in your project.
 
-You can remove them with Spoom:
+Run the tests:
 
+```sh
+bin/test
 ```
-$ spoom deadcode remove path/to/file.rb:42:18-47:23
+
+Run an interactive console:
+
+```sh
+bin/console
 ```
 
-## Development
+Run the full local sanity check before pushing:
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment. Don't forget to run `bin/sanity` before pushing your changes.
+```sh
+bin/sanity
+```
+
+Install this gem locally:
 
-To install this gem onto your local machine, run `bundle exec rake install`.
+```sh
+bundle exec rake install
+```
 
 ## Releasing
 
 ### Bump the gem version
 
-- [ ] Locally, update the version number in [`version.rb`](https://github.com/Shopify/spoom/blob/main/lib/spoom/version.rb)
-- [ ] Run `bundle install` to update the version number in `Gemfile.lock`
-- [ ] Commit this change with the message `Bump version to vx.y.z`
-- [ ] Push this change directly to main or open a PR
+* [ ] Update the version number in [`lib/spoom/version.rb`](https://github.com/Shopify/spoom/blob/main/lib/spoom/version.rb)
+* [ ] Run `bundle install` to update the version number in `Gemfile.lock`
+* [ ] Commit the change with `Bump version to vx.y.z`
+* [ ] Push the change directly to `main` or open a pull request
 
 ### Create a new tag
 
-- [ ] Locally, create a new tag with the new version number: `git tag vx.y.z`
-- [ ] Push this tag up to the remote `git push origin vx.y.z`
+* [ ] Create a tag with the new version number: `git tag vx.y.z`
+* [ ] Push the tag: `git push origin vx.y.z`
 
-### Release workflow will run automatically
+### Publish the release
 
-We have a [release workflow](https://github.com/Shopify/spoom/actions/workflows/release.yml) that will publish your new gem version to rubygems.org via [Trusted Publishing](https://guides.rubygems.org/trusted-publishing/). This workflow must be approved by a member of the Ruby and Rails Infrastructure team at Shopify before it will run. Once it is approved, it will automatically publish a new gem version to rubygems.org and create a new GitHub release.
+The [release workflow](https://github.com/Shopify/spoom/actions/workflows/release.yml) publishes new gem versions to RubyGems through [Trusted Publishing](https://guides.rubygems.org/trusted-publishing/).
+
+A member of the Ruby and Rails Infrastructure team at Shopify must approve the workflow before it runs. Once approved, it publishes the gem and creates a GitHub release.
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/Shopify/spoom. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://github.com/Shopify/spoom.
+
+This project is intended to be a safe, welcoming space for collaboration. Contributors are expected to follow the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 ## License
 
@@ -405,4 +529,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the Spoom project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/Shopify/spoom/blob/main/CODE_OF_CONDUCT.md).
+Everyone interacting in Spoom's codebases, issue trackers, chat rooms, and mailing lists is expected to follow the [code of conduct](https://github.com/Shopify/spoom/blob/main/CODE_OF_CONDUCT.md).

data/lib/spoom/backtrace_filter/minitest.rb

@@ -12,7 +12,7 @@ module Spoom
       #: (Array[String]? bt) -> Array[String]
       def filter(bt)
         super.select do |line|
-          SORBET_PATHS.none? { |path| line.include?(path) }
+          !SORBET_PATHS.intersect?(line)
         end
       end
     end

data/lib/spoom/cli/srb/sigs.rb

@@ -26,6 +26,10 @@ module Spoom
         option :translate_generics, type: :boolean, desc: "Translate generics", default: false
         option :translate_helpers, type: :boolean, desc: "Translate helpers", default: false
         option :translate_abstract_methods, type: :boolean, desc: "Translate abstract methods", default: false
+        option :erase_generic_types,
+          type: :boolean,
+          desc: "Drop generic types when translating from RBS to RBI",
+          default: false
         def translate(*paths)
           from = options[:from]
           to = options[:to]
@@ -70,6 +74,7 @@ module Spoom
                 contents,
                 file: file,
                 max_line_length: max_line_length,
+                erase_generic_types: options[:erase_generic_types],
               )
             end
           end

data/lib/spoom/deadcode/erb.rb

@@ -40,6 +40,15 @@ module Spoom
         super
       end
 
+      #: -> String
+      def wrapped_src
+        <<~RUBY
+          def __spoom_deadcode_erb_template__
+            #{src}
+          end
+        RUBY
+      end
+
       private
 
       # @override
@@ -50,32 +59,34 @@ module Spoom
         if text == "\n"
           @newline_pending += 1
         else
-          src << bufvar << ".safe_append='"
-          src << "\n" * @newline_pending if @newline_pending > 0
-          src << text.gsub(/['\\]/, '\\\\\&')
-          src << "'.freeze;"
-
+          with_buffer do
+            src << ".safe_append='"
+            src << "\n" * @newline_pending if @newline_pending > 0
+            src << text.gsub(/['\\]/, '\\\\\&') << @text_end
+          end
           @newline_pending = 0
         end
       end
 
-      BLOCK_EXPR = /\s*((\s+|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/
+      BLOCK_EXPR = /((\s|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/
 
       # @override
       #: (untyped indicator, untyped code) -> void
       def add_expression(indicator, code)
         flush_newline_if_pending(src)
 
-        src << bufvar << if (indicator == "==") || @escape
-          ".safe_expr_append="
-        else
-          ".append="
-        end
+        with_buffer do
+          src << if (indicator == "==") || @escape
+            ".safe_expr_append="
+          else
+            ".append="
+          end
 
-        if BLOCK_EXPR.match?(code)
-          src << " " << code
-        else
-          src << "(" << code << ");"
+          if BLOCK_EXPR.match?(code)
+            src << " " << code
+          else
+            src << "(" << code << ")"
+          end
         end
       end
 
@@ -96,7 +107,7 @@ module Spoom
       #: (untyped src) -> void
       def flush_newline_if_pending(src)
         if @newline_pending > 0
-          src << bufvar << ".safe_append='#{"\n" * @newline_pending}'.freeze;"
+          with_buffer { src << ".safe_append='#{"\n" * @newline_pending}" << @text_end }
           @newline_pending = 0
         end
       end

data/lib/spoom/deadcode/index.rb

@@ -44,7 +44,7 @@ module Spoom
 
       #: (String erb, file: String, ?plugins: Array[Plugins::Base]) -> void
       def index_erb(erb, file:, plugins: [])
-        index_ruby(Deadcode::ERB.new(erb).src, file: file, plugins: plugins)
+        index_ruby(Deadcode::ERB.new(erb).wrapped_src, file: file, plugins: plugins)
       end
 
       #: (String rb, file: String, ?plugins: Array[Plugins::Base]) -> void
@@ -55,6 +55,11 @@ module Spoom
         model_builder = Model::Builder.new(@model, file)
         model_builder.visit(node)
 
+        # Ignore the special synthetic method generated by the ERB engine
+        if (spoom_erb_wrapper = @model.symbols["__spoom_deadcode_erb_template__"])
+          @ignored.merge(spoom_erb_wrapper.definitions)
+        end
+
         # Index references
         refs_visitor = Model::ReferencesVisitor.new(file)
         refs_visitor.visit(node)

data/lib/spoom/deadcode/remover.rb

@@ -117,6 +117,7 @@ module Spoom
                Prism::ConstantPathAndWriteNode, Prism::ConstantPathOrWriteNode
             # Nesting node is an assign, it means only one constant is assigned on the line
             # so we can remove the whole assign
+            remove_constant_visibility_call(context)
             delete_node_and_comments_and_sigs(context)
             return
           end
@@ -127,6 +128,7 @@ module Spoom
           if parent_node.is_a?(Prism::ConstantWriteNode)
             # Nesting node is an assign, it means only one constant is assigned on the line
             # so we can remove the whole assign
+            remove_constant_visibility_call(parent_context)
             delete_node_and_comments_and_sigs(parent_context)
             return
           elsif parent_node.is_a?(Prism::MultiWriteNode) && parent_node.lefts.size == 1
@@ -190,6 +192,64 @@ module Spoom
           end
         end
 
+        # A dead constant is often followed by a `private_constant`/`public_constant` call naming it.
+        # That call references the now-removed constant (a load-time `NameError` if left behind), so
+        # remove the reference too: delete the whole call when the constant is its only argument, or
+        # drop just that symbol when the call lists several constants.
+        #: (NodeContext context) -> void
+        def remove_constant_visibility_call(context)
+          node = context.node
+          return unless node.is_a?(Prism::ConstantWriteNode)
+
+          name = node.name
+          call = context.next_nodes.find { |sibling| constant_visibility_call?(sibling, name) }
+          return unless call.is_a?(Prism::CallNode)
+
+          call_context = NodeContext.new(@old_source, @node_context.comments, call, context.nesting)
+          arguments = call.arguments&.arguments #: Array[Prism::Node]?
+          if arguments && arguments.size > 1
+            delete_symbol_argument(call_context, name)
+          else
+            delete_node_and_comments_and_sigs(call_context)
+          end
+        end
+
+        # Whether `node` is a bare `private_constant`/`public_constant` call listing `name`.
+        #: (Prism::Node node, Symbol name) -> bool
+        def constant_visibility_call?(node, name)
+          return false unless node.is_a?(Prism::CallNode)
+          return false unless node.receiver.nil?
+          return false unless node.name == :private_constant || node.name == :public_constant
+
+          arguments = node.arguments&.arguments
+          return false unless arguments
+
+          arguments.any? { |argument| argument.is_a?(Prism::SymbolNode) && argument.value == name.to_s }
+        end
+
+        # Drop the `:name` symbol from a `private_constant`/`public_constant` call that lists several
+        # constants, keeping the call and the other names intact.
+        #: (NodeContext context, Symbol name) -> void
+        def delete_symbol_argument(context, name)
+          arguments = T.cast(context.node, Prism::CallNode).arguments&.arguments
+          return unless arguments
+
+          index = arguments.index { |argument| argument.is_a?(Prism::SymbolNode) && argument.value == name.to_s }
+          return unless index
+
+          argument = arguments.fetch(index)
+          prev_argument = arguments[index - 1] if index.positive?
+          next_argument = arguments[index + 1]
+
+          if prev_argument && next_argument
+            replace_chars(prev_argument.location.end_offset, next_argument.location.start_offset, ", ")
+          elsif prev_argument
+            delete_chars(prev_argument.location.end_offset, argument.location.end_offset)
+          elsif next_argument
+            delete_chars(argument.location.start_offset, next_argument.location.start_offset)
+          end
+        end
+
         #: (NodeContext context) -> void
         def delete_attr_accessor(context)
           args_context = context.parent_context

data/lib/spoom/sorbet/translate/rbs_comments_to_sorbet_sigs/base_translator.rb

@@ -26,7 +26,8 @@ module Spoom
 
             @overloads_strategy = options.overloads_strategy #: Symbol
             @translate_abstract_methods = options.translate_abstract_methods #: bool
-            @type_translator = RBI::RBS::TypeTranslator.new #: RBI::RBS::TypeTranslator
+            @options = options #: Options
+            @type_translator = RBI::RBS::TypeTranslator.new(options: options.rbi_options) #: RBI::RBS::TypeTranslator
           end
 
           # @override
@@ -163,7 +164,7 @@ module Spoom
                 next
               end
 
-              translator = RBI::RBS::MethodTypeTranslator.new(rbi_node)
+              translator = RBI::RBS::MethodTypeTranslator.new(rbi_node, options: @options.rbi_options)
 
               begin
                 translator.visit(method_type)
@@ -273,6 +274,18 @@ module Spoom
                 rewrite_type_params_signature(signature, type_params:)
                 next if type_params.empty?
 
+                if @options.erase_generic_types
+                  type_params.each do |type_param|
+                    insert_type_member(
+                      "#{type_param.name} = ::T.type_alias { ::T.anything }",
+                      parent_node: node,
+                      insert_pos:,
+                    )
+                  end
+
+                  next
+                end
+
                 unless already_extends?(node, /^(::)?T::Generic$/)
                   extend_with("T::Generic", into: node, at: insert_pos)
                 end
@@ -462,7 +475,7 @@ module Spoom
               )
 
               @rewriter << Source::Delete.new(from, to)
-              content = "#{indent}#{alias_name} = T.type_alias { #{sorbet_type.to_rbi} }\n"
+              content = "#{indent}#{alias_name} = ::T.type_alias { #{sorbet_type.to_rbi} }\n"
               content = pad_out_line_count(of: content, to_height_of: type_alias)
               @rewriter << Source::Insert.new(insert_pos, content)
             rescue ::RBS::ParsingError, ::RBI::Error

data/lib/spoom/sorbet/translate/rbs_comments_to_sorbet_sigs/options.rb

@@ -44,6 +44,12 @@ module Spoom
 
           ALLOWED_OVERLOAD_STRATEGIES = [:translate_all, :translate_last, :raise].freeze
 
+          #: bool
+          attr_reader :erase_generic_types
+
+          #: RBI::RBS::MethodTypeTranslator::Options
+          attr_reader :rbi_options
+
           #: BaseRBIFormat
           attr_reader :output_format
 
@@ -52,11 +58,13 @@ module Spoom
 
           #: (
           #|   ?overloads_strategy: Symbol,
+          #|   ?erase_generic_types: bool,
           #|   ?output_format: BaseRBIFormat,
           #|   ?translate_abstract_methods: bool,
           #| ) -> void
           def initialize(
             overloads_strategy: :translate_all,
+            erase_generic_types: false,
             output_format: HumanReadableRBIFormat.default,
             translate_abstract_methods: true
           )
@@ -66,6 +74,8 @@ module Spoom
             end
 
             @overloads_strategy = overloads_strategy
+            @erase_generic_types = erase_generic_types
+            @rbi_options = RBI::RBS::MethodTypeTranslator::Options.new(erase_generic_types:) #: RBI::RBS::MethodTypeTranslator::Options
             @output_format = output_format
             @translate_abstract_methods = translate_abstract_methods
 

data/lib/spoom/sorbet/translate/rbs_comments_to_sorbet_sigs.rb

@@ -28,17 +28,20 @@ module Spoom
           #|   String ruby_contents,
           #|   file: String,
           #|   ?max_line_length: Integer?,
-          #|   ?overloads_strategy: Symbol) -> String
+          #|   ?overloads_strategy: Symbol,
+          #|   ?erase_generic_types: bool) -> String
           def rewrite_if_needed(
             ruby_contents,
             file:,
             max_line_length: nil,
-            overloads_strategy: :translate_all
+            overloads_strategy: :translate_all,
+            erase_generic_types: false
           )
             return ruby_contents unless contains_rbs_syntax?(ruby_contents)
 
             options = Options.new(
               overloads_strategy:,
+              erase_generic_types:,
               output_format: HumanReadableRBIFormat.new(
                 max_line_length:,
               ),

data/lib/spoom/sorbet/translate.rb

@@ -59,13 +59,16 @@ module Spoom
 
         # Converts all the RBS comments in the given Ruby code to `sig` nodes.
         # It also handles type members and class annotations.
-        #: (String ruby_contents, file: String, ?max_line_length: Integer?, ?overloads_strategy: Symbol) -> String
-        def rbs_comments_to_sorbet_sigs(ruby_contents, file:, max_line_length: nil, overloads_strategy: :translate_all)
+        #: (String ruby_contents, file: String, ?max_line_length: Integer?,
+        #| ?overloads_strategy: Symbol, ?erase_generic_types: bool) -> String
+        def rbs_comments_to_sorbet_sigs(ruby_contents, file:, max_line_length: nil, overloads_strategy: :translate_all,
+          erase_generic_types: false)
           RBSCommentsToSorbetSigs.rewrite_if_needed(
             ruby_contents,
             file: file,
             max_line_length: max_line_length,
             overloads_strategy: overloads_strategy,
+            erase_generic_types: erase_generic_types,
           )
         end
 

data/lib/spoom/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Spoom
-  VERSION = "1.8.4"
+  VERSION = "1.8.5"
 end

data/rbi/spoom.rbi

@@ -1024,6 +1024,9 @@ class Spoom::Deadcode::ERB < ::Erubi::Engine
   sig { params(input: T.untyped, properties: T.untyped).void }
   def initialize(input, properties = T.unsafe(nil)); end
 
+  sig { returns(::String) }
+  def wrapped_src; end
+
   private
 
   sig { override.params(code: T.untyped).void }
@@ -1497,6 +1500,9 @@ class Spoom::Deadcode::Remover::NodeRemover
 
   private
 
+  sig { params(node: ::Prism::Node, name: ::Symbol).returns(T::Boolean) }
+  def constant_visibility_call?(node, name); end
+
   sig { params(context: ::Spoom::Deadcode::Remover::NodeContext).void }
   def delete_attr_accessor(context); end
 
@@ -1512,6 +1518,9 @@ class Spoom::Deadcode::Remover::NodeRemover
   sig { params(context: ::Spoom::Deadcode::Remover::NodeContext).void }
   def delete_node_and_comments_and_sigs(context); end
 
+  sig { params(context: ::Spoom::Deadcode::Remover::NodeContext, name: ::Symbol).void }
+  def delete_symbol_argument(context, name); end
+
   sig do
     params(
       node: ::Prism::Node,
@@ -1524,6 +1533,9 @@ class Spoom::Deadcode::Remover::NodeRemover
   sig { params(def_node: ::Prism::DefNode).returns(T.nilable(::Spoom::Deadcode::Remover::NodeContext)) }
   def modifier_call_context(def_node); end
 
+  sig { params(context: ::Spoom::Deadcode::Remover::NodeContext).void }
+  def remove_constant_visibility_call(context); end
+
   sig { params(start_char: ::Integer, end_char: ::Integer, replacement: ::String).void }
   def replace_chars(start_char, end_char, replacement); end
 
@@ -2926,10 +2938,11 @@ module Spoom::Sorbet::Translate
         ruby_contents: ::String,
         file: ::String,
         max_line_length: T.nilable(::Integer),
-        overloads_strategy: ::Symbol
+        overloads_strategy: ::Symbol,
+        erase_generic_types: T::Boolean
       ).returns(::String)
     end
-    def rbs_comments_to_sorbet_sigs(ruby_contents, file:, max_line_length: T.unsafe(nil), overloads_strategy: T.unsafe(nil)); end
+    def rbs_comments_to_sorbet_sigs(ruby_contents, file:, max_line_length: T.unsafe(nil), overloads_strategy: T.unsafe(nil), erase_generic_types: T.unsafe(nil)); end
 
     sig do
       params(
@@ -3008,10 +3021,11 @@ module Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs
         ruby_contents: ::String,
         file: ::String,
         max_line_length: T.nilable(::Integer),
-        overloads_strategy: ::Symbol
+        overloads_strategy: ::Symbol,
+        erase_generic_types: T::Boolean
       ).returns(::String)
     end
-    def rewrite_if_needed(ruby_contents, file:, max_line_length: T.unsafe(nil), overloads_strategy: T.unsafe(nil)); end
+    def rewrite_if_needed(ruby_contents, file:, max_line_length: T.unsafe(nil), overloads_strategy: T.unsafe(nil), erase_generic_types: T.unsafe(nil)); end
   end
 end
 
@@ -3238,11 +3252,15 @@ class Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs::Options
   sig do
     params(
       overloads_strategy: ::Symbol,
+      erase_generic_types: T::Boolean,
       output_format: ::Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs::BaseRBIFormat,
       translate_abstract_methods: T::Boolean
     ).void
   end
-  def initialize(overloads_strategy: T.unsafe(nil), output_format: T.unsafe(nil), translate_abstract_methods: T.unsafe(nil)); end
+  def initialize(overloads_strategy: T.unsafe(nil), erase_generic_types: T.unsafe(nil), output_format: T.unsafe(nil), translate_abstract_methods: T.unsafe(nil)); end
+
+  sig { returns(T::Boolean) }
+  def erase_generic_types; end
 
   sig { returns(::Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs::BaseRBIFormat) }
   def output_format; end
@@ -3250,6 +3268,9 @@ class Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs::Options
   sig { returns(::Symbol) }
   def overloads_strategy; end
 
+  sig { returns(::RBI::RBS::MethodTypeTranslator::Options) }
+  def rbi_options; end
+
   sig { returns(T::Boolean) }
   def translate_abstract_methods; end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spoom
 version: !ruby/object:Gem::Version
-  version: 1.8.4
+  version: 1.8.5
 platform: ruby
 authors:
 - Alexandre Terrasa
@@ -85,14 +85,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.15
+        version: 0.4.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.15
+        version: 0.4.1
 - !ruby/object:Gem::Dependency
   name: rbs
   requirement: !ruby/object:Gem::Requirement