spoom 1.2.4 → 1.3.0

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

@@ -0,0 +1,150 @@
+# typed: true
+# frozen_string_literal: true
+
+module Spoom
+  module Cli
+    module Srb
+      class Tc < Thor
+        include Helper
+
+        default_task :tc
+
+        SORT_CODE = "code"
+        SORT_LOC = "loc"
+        SORT_ENUM = [SORT_CODE, SORT_LOC]
+
+        DEFAULT_FORMAT = "%C - %F:%L: %M"
+
+        desc "tc", "Run `srb tc`"
+        option :limit, type: :numeric, aliases: :l, desc: "Limit displayed errors"
+        option :code, type: :numeric, aliases: :c, desc: "Filter displayed errors by code"
+        option :sort, type: :string, aliases: :s, desc: "Sort errors", enum: SORT_ENUM, default: SORT_LOC
+        option :format, type: :string, aliases: :f, desc: "Format line output"
+        option :uniq, type: :boolean, aliases: :u, desc: "Remove duplicated lines"
+        option :count, type: :boolean, default: true, desc: "Show errors count"
+        option :sorbet, type: :string, desc: "Path to custom Sorbet bin"
+        option :sorbet_options, type: :string, default: "", desc: "Pass options to Sorbet"
+        def tc(*paths_to_select)
+          context = context_requiring_sorbet!
+          limit = options[:limit]
+          sort = options[:sort]
+          code = options[:code]
+          uniq = options[:uniq]
+          format = options[:format]
+          count = options[:count]
+          sorbet = options[:sorbet]
+
+          unless limit || code || sort
+            result = T.unsafe(context).srb_tc(
+              *options[:sorbet_options].split(" "),
+              capture_err: false,
+              sorbet_bin: sorbet,
+            )
+
+            say_error(result.err, status: nil, nl: false)
+            exit(result.status)
+          end
+
+          error_url_base = Spoom::Sorbet::Errors::DEFAULT_ERROR_URL_BASE
+          result = T.unsafe(context).srb_tc(
+            *options[:sorbet_options].split(" "),
+            "--error-url-base=#{error_url_base}",
+            capture_err: true,
+            sorbet_bin: sorbet,
+          )
+
+          if result.status
+            say_error(result.err, status: nil, nl: false)
+            exit(0)
+          end
+
+          unless result.exit_code == 100
+            # Sorbet will return exit code 100 if there are type checking errors.
+            # If Sorbet returned something else, it means it didn't terminate normally.
+            say_error(result.err, status: nil, nl: false)
+            exit(1)
+          end
+
+          errors = Spoom::Sorbet::Errors::Parser.parse_string(result.err, error_url_base: error_url_base)
+          errors_count = errors.size
+
+          errors = errors.select { |e| e.code == code } if code
+
+          unless paths_to_select.empty?
+            errors.select! do |error|
+              paths_to_select.any? { |path_to_select| error.file&.start_with?(path_to_select) }
+            end
+          end
+
+          errors = case sort
+          when SORT_CODE
+            Spoom::Sorbet::Errors.sort_errors_by_code(errors)
+          when SORT_LOC
+            errors.sort
+          else
+            errors # preserve natural sort
+          end
+
+          errors = T.must(errors.slice(0, limit)) if limit
+
+          lines = errors.map { |e| format_error(e, format || DEFAULT_FORMAT) }
+          lines = lines.uniq if uniq
+
+          lines.each do |line|
+            say_error(line, status: nil)
+          end
+
+          if count
+            if errors_count == errors.size
+              say_error("Errors: #{errors_count}", status: nil)
+            else
+              say_error("Errors: #{errors.size} shown, #{errors_count} total", status: nil)
+            end
+          end
+
+          exit(1)
+        rescue Spoom::Sorbet::Error::Segfault => error
+          say_error(<<~ERR, status: nil)
+            #{red("!!! Sorbet exited with code #{error.result.exit_code} - SEGFAULT !!!")}
+
+            This is most likely related to a bug in Sorbet.
+          ERR
+
+          exit(error.result.exit_code)
+        rescue Spoom::Sorbet::Error::Killed => error
+          say_error(<<~ERR, status: nil)
+            #{red("!!! Sorbet exited with code #{error.result.exit_code} - KILLED !!!")}
+          ERR
+
+          exit(error.result.exit_code)
+        end
+
+        no_commands do
+          def format_error(error, format)
+            line = format
+            line = line.gsub("%C", yellow(error.code.to_s))
+            line = line.gsub("%F", error.file)
+            line = line.gsub("%L", error.line.to_s)
+            line = line.gsub("%M", colorize_message(error.message))
+            line
+          end
+
+          def colorize_message(message)
+            return message unless color?
+
+            cyan = T.let(false, T::Boolean)
+            word = StringIO.new
+            message.chars.each do |c|
+              if c == "`"
+                cyan = !cyan
+                next
+              end
+              word << (cyan ? cyan(c) : red(c))
+            end
+            word.string
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spoom/cli/srb.rb

@@ -0,0 +1,27 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "srb/bump"
+require_relative "srb/coverage"
+require_relative "srb/lsp"
+require_relative "srb/tc"
+
+module Spoom
+  module Cli
+    module Srb
+      class Main < Thor
+        desc "lsp", "Send LSP requests to Sorbet"
+        subcommand "lsp", Spoom::Cli::Srb::LSP
+
+        desc "coverage", "Collect metrics related to Sorbet coverage"
+        subcommand "coverage", Spoom::Cli::Srb::Coverage
+
+        desc "bump", "Change Sorbet sigils from one strictness to another when no errors"
+        subcommand "bump", Spoom::Cli::Srb::Bump
+
+        desc "tc", "Run typechecking with advanced options"
+        subcommand "tc", Spoom::Cli::Srb::Tc
+      end
+    end
+  end
+end

data/lib/spoom/cli.rb

@@ -4,12 +4,8 @@
 require "thor"
 
 require_relative "cli/helper"
-
-require_relative "cli/bump"
-require_relative "cli/config"
-require_relative "cli/lsp"
-require_relative "cli/coverage"
-require_relative "cli/run"
+require_relative "cli/deadcode"
+require_relative "cli/srb"
 
 module Spoom
   module Cli
@@ -22,39 +18,83 @@ module Spoom
 
       map T.unsafe(["--version", "-v"] => :__print_version)
 
-      desc "bump", "Bump Sorbet sigils from `false` to `true` when no errors"
-      subcommand "bump", Spoom::Cli::Bump
+      desc "srb", "Sorbet related commands"
+      subcommand "srb", Spoom::Cli::Srb::Main
 
-      desc "config", "Manage Sorbet config"
-      subcommand "config", Spoom::Cli::Config
+      desc "bump", "Bump Sorbet sigils from `false` to `true` when no errors"
+      option :from,
+        type: :string,
+        default: Spoom::Sorbet::Sigils::STRICTNESS_FALSE,
+        desc: "Change only files from this strictness"
+      option :to,
+        type: :string,
+        default: Spoom::Sorbet::Sigils::STRICTNESS_TRUE,
+        desc: "Change files to this strictness"
+      option :force,
+        type: :boolean,
+        default: false,
+        aliases: :f,
+        desc: "Change strictness without type checking"
+      option :sorbet, type: :string, desc: "Path to custom Sorbet bin"
+      option :dry,
+        type: :boolean,
+        default: false,
+        aliases: :d,
+        desc: "Only display what would happen, do not actually change sigils"
+      option :only,
+        type: :string,
+        default: nil,
+        aliases: :o,
+        desc: "Only change specified list (one file by line)"
+      option :suggest_bump_command,
+        type: :string,
+        desc: "Command to suggest if files can be bumped"
+      option :count_errors,
+        type: :boolean,
+        default: false,
+        desc: "Count the number of errors if all files were bumped"
+      option :sorbet_options, type: :string, default: "", desc: "Pass options to Sorbet"
+      sig { params(directory: String).void }
+      def bump(directory = ".")
+        say_warning("This command is deprecated. Please use `spoom srb bump` instead.")
+
+        invoke(Cli::Srb::Bump, :bump, [directory], options)
+      end
 
       desc "coverage", "Collect metrics related to Sorbet coverage"
-      subcommand "coverage", Spoom::Cli::Coverage
+      def coverage(*args)
+        say_warning("This command is deprecated. Please use `spoom srb bump` instead.")
+
+        invoke(Cli::Srb::Coverage, args, options)
+      end
+
+      desc "deadcode", "Analyze code to find deadcode"
+      subcommand "deadcode", Spoom::Cli::Deadcode
 
       desc "lsp", "Send LSP requests to Sorbet"
-      subcommand "lsp", Spoom::Cli::LSP
+      def lsp(*args)
+        say_warning("This command is deprecated. Please use `spoom srb bump` instead.")
 
-      desc "tc", "Run Sorbet and parses its output"
-      subcommand "tc", Spoom::Cli::Run
-
-      desc "files", "List all the files typechecked by Sorbet"
-      option :tree, type: :boolean, default: true, desc: "Display list as an indented tree"
-      option :rbi, type: :boolean, default: false, desc: "Show RBI files"
-      def files
-        context = context_requiring_sorbet!
-
-        files = context.srb_files(include_rbis: options[:rbi])
-        if files.empty?
-          say_error("No file matching `#{Sorbet::CONFIG_PATH}`")
-          exit(1)
-        end
+        invoke(Cli::Srb::LSP, args, options)
+      end
 
-        if options[:tree]
-          tree = FileTree.new(files)
-          tree.print_with_strictnesses(context, colors: options[:color])
-        else
-          puts files
-        end
+      SORT_CODE = "code"
+      SORT_LOC = "loc"
+      SORT_ENUM = [SORT_CODE, SORT_LOC]
+
+      desc "tc", "Run Sorbet and parses its output"
+      option :limit, type: :numeric, aliases: :l, desc: "Limit displayed errors"
+      option :code, type: :numeric, aliases: :c, desc: "Filter displayed errors by code"
+      option :sort, type: :string, aliases: :s, desc: "Sort errors", enum: SORT_ENUM, default: SORT_LOC
+      option :format, type: :string, aliases: :f, desc: "Format line output"
+      option :uniq, type: :boolean, aliases: :u, desc: "Remove duplicated lines"
+      option :count, type: :boolean, default: true, desc: "Show errors count"
+      option :sorbet, type: :string, desc: "Path to custom Sorbet bin"
+      option :sorbet_options, type: :string, default: "", desc: "Pass options to Sorbet"
+      def tc(*paths_to_select)
+        say_warning("This command is deprecated. Please use `spoom srb tc` instead.")
+
+        invoke(Cli::Srb::Tc, :tc, paths_to_select, options)
       end
 
       desc "--version", "Show version"

data/lib/spoom/context/git.rb

@@ -9,7 +9,7 @@ module Spoom
       class << self
         extend T::Sig
 
-        # Parse a line formated as `%h %at` into a `Commit`
+        # Parse a line formatted as `%h %at` into a `Commit`
         sig { params(string: String).returns(T.nilable(Commit)) }
         def parse_line(string)
           sha, epoch = string.split(" ", 2)
@@ -127,7 +127,7 @@ module Spoom
         git("show #{arg.join(" ")}")
       end
 
-      # Is there uncommited changes in this context directory?
+      # Is there uncommitted changes in this context directory?
       sig { params(path: String).returns(T::Boolean) }
       def git_workdir_clean?(path: ".")
         git_diff("HEAD").out.empty?

data/lib/spoom/context/sorbet.rb

@@ -75,13 +75,13 @@ module Spoom
           # From Sorbet docs on `--ignore`:
           # > Ignores input files that contain the given string in their paths (relative to the input path passed to
           # > Sorbet). Strings beginning with / match against the prefix of these relative paths; others are substring
-          # > matchs. Matches must be against whole folder and file names, so `foo` matches `/foo/bar.rb` and
+          # > matches. Matches must be against whole folder and file names, so `foo` matches `/foo/bar.rb` and
           # > `/bar/foo/baz.rb` but not `/foo.rb` or `/foo2/bar.rb`.
           string = if string.start_with?("/")
             # Strings beginning with / match against the prefix of these relative paths
             File.join(absolute_path, string)
           else
-            # Others are substring matchs
+            # Others are substring matches
             File.join(absolute_path, "**", string)
           end
           # Matches must be against whole folder and file names

data/lib/spoom/deadcode/definition.rb

@@ -93,6 +93,17 @@ module Spoom
       def ignored!
         @status = Status::IGNORED
       end
+
+      # Utils
+
+      sig { params(args: T.untyped).returns(String) }
+      def to_json(*args)
+        {
+          kind: kind,
+          name: name,
+          location: location.to_s,
+        }.to_json
+      end
     end
   end
 end