spoom 1.2.3 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e7ef8ebef70bc8827cdcb4b2c0e49ed6c53686e0db409908354f3762ad07c10
-  data.tar.gz: a6adb405f0379cbe040e743f177e758e2bdaadcdea13ee9c7f75d84f764434b1
+  metadata.gz: 1993e4b43cf1c9d97475b654c049e8b14a27189561471b2bfb4bb077ac2f7b9e
+  data.tar.gz: ad6a269fe90e77df95564a13e222d58e9993c7ffef389c2be3a0e2fc7a1aed9a
 SHA512:
-  metadata.gz: 86d74bc7d9554d67c1421908116bbab7615d77e9cb096d461f7885429d495f2b02f19d6024117f7083423cfe7c48165b18918c143f29574896bfbb76a4fb651f
-  data.tar.gz: 754d41e8f26425a42288388879fe1658214adea03002421495297486343a827d6dc79a395e895553ed15f67cdc766a16f4a174aab2a3671bd2455e305a8c6f13
+  metadata.gz: 8eab661cb5d9aa290bea6dba5ab3808ad4df7847213229616c4eb912faf012208da053bcb4019700e390f57ce156ff7852a9ef4b01ab48c819acc1453a62b8eb
+  data.tar.gz: 7f74c0655f781be1c9832d33dcc9a1cb088705f201998f431dae80a90dae259fe09a85cb0ffec1bd53369694b842c5bfe10a3b32ff25a9b1c61ee712fd934900

data/README.md

@@ -31,13 +31,13 @@ Spoom can create a typing coverage report from Sorbet and Git data:
 After installing the `spoom` gem, run the `timeline` command to collect the history data:
 
 ```
-$ spoom coverage timeline --save
+$ spoom srb coverage timeline --save
 ```
 
 Then create the HTML page with `report`:
 
 ```
-$ spoom coverage report
+$ spoom srb coverage report
 ```
 
 Your report will be generated under `spoom_report.html`.
@@ -46,66 +46,48 @@ See all the [Typing Coverage](#typing-coverage) CLI commands for more details.
 
 ### Command Line Interface
 
-#### Sorbet configuration commands
-
-Spoom works with your `sorbet/config` file. No additional configuration is needed.
-
-Show Sorbet config options:
-
-```
-$ spoom config
-```
-
-#### Listing files
-
-List the files (and related strictness) that will be typchecked with the current Sorbet config options:
-
-```
-$ spoom files
-```
-
 #### Errors sorting and filtering
 
 List all typechecking errors sorted by location:
 
 ```
-$ spoom tc -s loc
+$ spoom srb tc -s loc
 ```
 
 List all typechecking errors sorted by error code first:
 
 ```
-$ spoom tc -s code
+$ spoom srb tc -s code
 ```
 
 List only typechecking errors from a specific error code:
 
 ```
-$ spoom tc -c 7004
+$ spoom srb tc -c 7004
 ```
 
 List only the first 10 typechecking errors
 
 ```
-$ spoom tc -l 10
+$ spoom srb tc -l 10
 ```
 
 These options can be combined:
 
 ```
-$ spoom tc -s -c 7004 -l 10
+$ spoom srb tc -s -c 7004 -l 10
 ```
 
 Remove duplicated error lines:
 
 ```
-$ spoom tc -u
+$ spoom srb tc -u
 ```
 
 Format each error line:
 
 ```
-$ spoom tc -f '%C - %F:%L: %M'
+$ spoom srb tc -f '%C - %F:%L: %M'
 ```
 
 Where:
@@ -118,13 +100,13 @@ Where:
 Hide the `Errors: X` at the end of the list:
 
 ```
-$ spoom tc --no-count
+$ spoom srb tc --no-count
 ```
 
-List only the errors comming from specific directories or files:
+List only the errors coming from specific directories or files:
 
 ```
-$ spoom tc file1.rb path1/ path2/
+$ spoom srb tc file1.rb path1/ path2/
 ```
 
 #### Typing coverage
@@ -132,61 +114,61 @@ $ spoom tc file1.rb path1/ path2/
 Show metrics about the project contents and the typing coverage:
 
 ```
-$ spoom coverage
+$ spoom srb coverage
 ```
 
 Save coverage data under `spoom_data/`:
 
 ```
-$ spoom coverage --save
+$ spoom srb coverage --save
 ```
 
 Save coverage data under a specific directory:
 
 ```
-$ spoom coverage --save my_data/
+$ spoom srb coverage --save my_data/
 ```
 
 Show typing coverage evolution based on the commits history:
 
 ```
-$ spoom coverage timeline
+$ spoom srb coverage timeline
 ```
 
 Show typing coverage evolution based on the commits history between specific dates:
 
 ```
-$ spoom coverage timeline --from YYYY-MM-DD --to YYYY-MM-DD
+$ spoom srb coverage timeline --from YYYY-MM-DD --to YYYY-MM-DD
 ```
 
 Save the typing coverage evolution as JSON under `spoom_data/`:
 
 ```
-$ spoom coverage timeline --save
+$ spoom srb coverage timeline --save
 ```
 
 Save the typing coverage evolution as JSON in a specific directory:
 
 ```
-$ spoom coverage timeline --save my_data/
+$ spoom srb coverage timeline --save my_data/
 ```
 
 Run `bundle install` for each commit of the timeline (may solve errors due to different Sorbet versions):
 
 ```
-$ spoom coverage timeline --bundle-install
+$ spoom srb coverage timeline --bundle-install
 ```
 
 Generate an HTML typing coverage report:
 
 ```
-$ spoom coverage report
+$ spoom srb coverage report
 ```
 
 Change the colors used for strictnesses (useful for colorblind folks):
 
 ```
-$ spoom coverage report \
+$ spoom srb coverage report \
   --color-true "#648ffe" \
   --color-false "#fe6002" \
   --color-ignore "#feb000" \
@@ -197,7 +179,7 @@ $ spoom coverage report \
 Open the HTML typing coverage report:
 
 ```
-$ spoom coverage open
+$ spoom srb coverage open
 ```
 
 #### Change the sigil used in files
@@ -205,37 +187,38 @@ $ spoom coverage open
 Bump the strictness from all files currently at `typed: false` to `typed: true` where it does not create typechecking errors:
 
 ```
-$ spoom bump --from false --to true
+$ 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:
 
 ```
-$ spoom bump --from false --to true -f
+$ spoom srb bump --from false --to true -f
 ```
 
 Bump the strictness from a list of files (one file by line):
 
 ```
-$ spoom bump --from false --to true -o list.txt
+$ spoom srb bump --from false --to true -o list.txt
 ```
 
-Check if files can be bumped without applying any change:
+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):
 
 ```
-$ spoom bump --from false --to true --dry
+$ spoom srb bump --from false --to true --dry
 ```
 
 Bump files using a custom instance of Sorbet:
 
 ```
-$ spoom bump --from false --to true --sorbet /path/to/sorbet/bin
+$ 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:
 
 ```
-$ spoom bump --count-errors --dry
+$ spoom srb bump --count-errors --dry
 ```
 
 #### Interact with Sorbet LSP mode
@@ -245,43 +228,43 @@ $ spoom bump --count-errors --dry
 Find all definitions for `Foo`:
 
 ```
-$ spoom lsp find Foo
+$ spoom srb lsp find Foo
 ```
 
 List all symbols in a file:
 
 ```
-$ spoom lsp symbols <file.rb>
+$ spoom srb lsp symbols <file.rb>
 ```
 
 List all definitions for a specific code location:
 
 ```
-$ spoom lsp defs <file.rb> <line> <column>
+$ spoom srb lsp defs <file.rb> <line> <column>
 ```
 
 List all references for a specific code location:
 
 ```
-$ spoom lsp refs <file.rb> <line> <column>
+$ spoom srb lsp refs <file.rb> <line> <column>
 ```
 
 Show hover information for a specific code location:
 
 ```
-$ spoom lsp hover <file.rb> <line> <column>
+$ spoom srb lsp hover <file.rb> <line> <column>
 ```
 
 Show signature information for a specific code location:
 
 ```
-$ spoom lsp sig <file.rb> <line> <column>
+$ spoom srb lsp sig <file.rb> <line> <column>
 ```
 
 Show type information for a specific code location:
 
 ```
-$ spoom lsp sig <file.rb> <line> <column>
+$ spoom srb lsp sig <file.rb> <line> <column>
 ```
 
 ### API
@@ -348,6 +331,32 @@ Find all the symbols for a file:
 puts client.document_symbols("file://path/to/my/file.rb")
 ```
 
+### Backtrace Filtering
+
+Spoom provides a backtrace filter for Minitest to remove the Sorbet frames from test failures, giving a more readable output. To enable it:
+
+```ruby
+# test/test_helper.rb
+require "spoom/backtrace_filter/minitest"
+Minitest.backtrace_filter = Spoom::BacktraceFilter::Minitest.new
+```
+
+### Dead code removal
+
+Run dead code detection in your project with:
+
+```
+$ 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:
+
+```
+$ spoom deadcode remove path/to/file.rb:42:18-47:23
+```
+
 ## Development
 
 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.

data/lib/spoom/backtrace_filter/minitest.rb

@@ -0,0 +1,21 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "minitest"
+
+module Spoom
+  module BacktraceFilter
+    class Minitest < ::Minitest::BacktraceFilter
+      extend T::Sig
+
+      SORBET_PATHS = T.let(Gem.loaded_specs["sorbet-runtime"].full_require_paths.freeze, T::Array[String])
+
+      sig { override.params(bt: T.nilable(T::Array[String])).returns(T::Array[String]) }
+      def filter(bt)
+        super.select do |line|
+          SORBET_PATHS.none? { |path| line.include?(path) }
+        end
+      end
+    end
+  end
+end

data/lib/spoom/cli/deadcode.rb

@@ -0,0 +1,172 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative "../deadcode"
+
+module Spoom
+  module Cli
+    class Deadcode < Thor
+      extend T::Sig
+      include Helper
+
+      default_task :deadcode
+
+      desc "deadcode PATH...", "Analyze PATHS to find dead code"
+      option :allowed_extensions,
+        type: :array,
+        default: [".rb", ".erb", ".gemspec"],
+        aliases: :e,
+        desc: "Allowed extensions"
+      option :allowed_mime_types,
+        type: :array,
+        default: ["text/x-ruby", "text/x-ruby-script"],
+        aliases: :m,
+        desc: "Allowed mime types"
+      option :exclude,
+        type: :array,
+        default: ["vendor/", "sorbet/"],
+        aliases: :x,
+        desc: "Exclude paths"
+      option :show_files,
+        type: :boolean,
+        default: false,
+        desc: "Show the files that will be analyzed"
+      option :show_plugins,
+        type: :boolean,
+        default: false,
+        desc: "Show the loaded plugins"
+      option :show_defs,
+        type: :boolean,
+        default: false,
+        desc: "Show the indexed definitions"
+      option :show_refs,
+        type: :boolean,
+        default: false,
+        desc: "Show the indexed references"
+      option :sort,
+        type: :string,
+        default: "name",
+        enum: ["name", "location"],
+        desc: "Sort the output by name or location"
+      sig { params(paths: String).void }
+      def deadcode(*paths)
+        context = self.context
+
+        paths << exec_path if paths.empty?
+
+        $stderr.puts "Collecting files..."
+        collector = FileCollector.new(
+          allow_extensions: options[:allowed_extensions],
+          allow_mime_types: options[:allowed_mime_types],
+          exclude_patterns: options[:exclude].map { |p| Pathname.new(File.join(exec_path, p, "**")).cleanpath.to_s },
+        )
+        collector.visit_paths(paths)
+        files = collector.files.sort
+
+        if options[:show_files]
+          $stderr.puts "\nCollected #{blue(files.size.to_s)} files for analysis\n"
+          files.each do |file|
+            $stderr.puts "  #{gray(file)}"
+          end
+          $stderr.puts
+        end
+
+        plugins = Spoom::Deadcode.plugins_from_gemfile_lock(context)
+        if options[:show_plugins]
+          $stderr.puts "\nLoaded #{blue(plugins.size.to_s)} plugins\n"
+          plugins.each do |plugin|
+            $stderr.puts "  #{gray(plugin.class.to_s)}"
+          end
+          $stderr.puts
+        end
+
+        index = Spoom::Deadcode::Index.new
+
+        $stderr.puts "Indexing #{blue(files.size.to_s)} files..."
+        files.each do |file|
+          content = File.read(file)
+          content = ERB.new(content).src if file.end_with?(".erb")
+
+          tree = Spoom::Deadcode.parse_ruby(content, file: file)
+          Spoom::Deadcode.index_node(index, tree, content, file: file, plugins: plugins)
+        rescue Spoom::Deadcode::ParserError => e
+          say_error("Error parsing #{file}: #{e.message}")
+          next
+        rescue Spoom::Deadcode::IndexerError => e
+          say_error("Error indexing #{file}: #{e.message}")
+          next
+        end
+
+        if options[:show_defs]
+          $stderr.puts "\nDefinitions:"
+          index.definitions.each do |name, definitions|
+            $stderr.puts "  #{blue(name)}"
+            definitions.each do |definition|
+              $stderr.puts "    #{yellow(definition.kind.serialize)} #{gray(definition.location.to_s)}"
+            end
+          end
+          $stderr.puts
+        end
+
+        if options[:show_refs]
+          $stderr.puts "\nReferences:"
+          index.references.values.flatten.sort_by(&:name).each do |references|
+            name = references.name
+            kind = references.kind.serialize
+            loc = references.location.to_s
+            $stderr.puts "  #{blue(name)} #{yellow(kind)} #{gray(loc)}"
+          end
+          $stderr.puts
+        end
+
+        definitions_count = index.definitions.size.to_s
+        references_count = index.references.size.to_s
+        $stderr.puts "Analyzing #{blue(definitions_count)} definitions against #{blue(references_count)} references..."
+
+        index.finalize!
+        dead = index.definitions.values.flatten.select(&:dead?)
+
+        if options[:sort] == "name"
+          dead.sort_by!(&:name)
+        else
+          dead.sort_by!(&:location)
+        end
+
+        if dead.empty?
+          $stderr.puts "\n#{green("No dead code found!")}"
+        else
+          $stderr.puts "\nCandidates:"
+          dead.each do |definition|
+            $stderr.puts "  #{red(definition.full_name)} #{gray(definition.location.to_s)}"
+          end
+          $stderr.puts "\n"
+          $stderr.puts red("  Found #{dead.size} dead candidates")
+
+          exit(1)
+        end
+      end
+
+      desc "remove LOCATION", "Remove dead code at LOCATION"
+      def remove(location_string)
+        location = Spoom::Deadcode::Location.from_string(location_string)
+        context = self.context
+        remover = Spoom::Deadcode::Remover.new(context)
+
+        new_source = remover.remove_location(nil, location)
+        context.write!("PATCH", new_source)
+
+        diff = context.exec("diff -u #{location.file} PATCH")
+        $stderr.puts T.must(diff.out.lines[2..-1]).join
+        context.remove!("PATCH")
+
+        context.write!(location.file, new_source)
+      rescue Spoom::Deadcode::Remover::Error => e
+        say_error("Can't remove code at #{location_string}: #{e.message}")
+        exit(1)
+      rescue Spoom::Deadcode::Location::LocationError => e
+        say_error(e.message)
+        exit(1)
+      end
+    end
+  end
+end

data/lib/spoom/cli/helper.rb

@@ -46,6 +46,26 @@ module Spoom
         $stderr.flush
       end
 
+      # Print `message` on `$stderr`
+      #
+      # The message is prefixed by a status (default: `Warning`).
+      sig do
+        params(
+          message: String,
+          status: T.nilable(String),
+          nl: T::Boolean,
+        ).void
+      end
+      def say_warning(message, status: "Warning", nl: true)
+        buffer = StringIO.new
+        buffer << "#{yellow(status)}: " if status
+        buffer << highlight(message)
+        buffer << "\n" if nl && !message.end_with?("\n")
+
+        $stderr.print(buffer.string)
+        $stderr.flush
+      end
+
       # Returns the context at `--path` (by default the current working directory)
       sig { returns(Context) }
       def context