spoom 1.2.4 → 1.3.0

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

@@ -0,0 +1,200 @@
+# typed: true
+# frozen_string_literal: true
+
+require "find"
+require "open3"
+
+module Spoom
+  module Cli
+    module Srb
+      class Bump < Thor
+        extend T::Sig
+        include Helper
+
+        default_task :bump
+
+        desc "bump DIRECTORY", "Change Sorbet sigils from one strictness to another 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 = ".")
+          context = context_requiring_sorbet!
+          from = options[:from]
+          to = options[:to]
+          force = options[:force]
+          dry = options[:dry]
+          only = options[:only]
+          cmd = options[:suggest_bump_command]
+          directory = File.expand_path(directory)
+          exec_path = File.expand_path(self.exec_path)
+
+          unless Sorbet::Sigils.valid_strictness?(from)
+            say_error("Invalid strictness `#{from}` for option `--from`")
+            exit(1)
+          end
+
+          unless Sorbet::Sigils.valid_strictness?(to)
+            say_error("Invalid strictness `#{to}` for option `--to`")
+            exit(1)
+          end
+
+          if options[:count_errors] && !dry
+            say_error("`--count-errors` can only be used with `--dry`")
+            exit(1)
+          end
+
+          say("Checking files...")
+
+          files_to_bump = context.srb_files_with_strictness(from, include_rbis: false)
+            .map { |file| File.expand_path(file, context.absolute_path) }
+            .select { |file| file.start_with?(directory) }
+
+          if only
+            list = File.read(only).lines.map { |file| File.expand_path(file.strip) }
+            files_to_bump.select! { |file| list.include?(File.expand_path(file)) }
+          end
+
+          say("\n")
+
+          if files_to_bump.empty?
+            say("No files to bump from `#{from}` to `#{to}`")
+            exit(0)
+          end
+
+          Sorbet::Sigils.change_sigil_in_files(files_to_bump, to)
+
+          if force
+            print_changes(files_to_bump, command: cmd, from: from, to: to, dry: dry, path: exec_path)
+            undo_changes(files_to_bump, from) if dry
+            exit(files_to_bump.empty?)
+          end
+
+          error_url_base = Spoom::Sorbet::Errors::DEFAULT_ERROR_URL_BASE
+          result = begin
+            T.unsafe(context).srb_tc(
+              *options[:sorbet_options].split(" "),
+              "--error-url-base=#{error_url_base}",
+              capture_err: true,
+              sorbet_bin: options[:sorbet],
+            )
+          rescue Spoom::Sorbet::Error::Segfault => error
+            say_error(<<~ERR, status: nil)
+              !!! Sorbet exited with code #{Spoom::Sorbet::SEGFAULT_CODE} - SEGFAULT !!!
+
+              This is most likely related to a bug in Sorbet.
+              It means one of the file bumped to `typed: #{to}` made Sorbet crash.
+              Run `spoom bump -f` locally followed by `bundle exec srb tc` to investigate the problem.
+            ERR
+            undo_changes(files_to_bump, from)
+            exit(error.result.exit_code)
+          rescue Spoom::Sorbet::Error::Killed => error
+            say_error(<<~ERR, status: nil)
+              !!! Sorbet exited with code #{Spoom::Sorbet::KILLED_CODE} - KILLED !!!
+
+              It means Sorbet was killed while executing. Changes to files have not been applied.
+              Re-run `spoom bump` to try again.
+            ERR
+            undo_changes(files_to_bump, from)
+            exit(error.result.exit_code)
+          end
+
+          if result.status
+            print_changes(files_to_bump, command: cmd, from: from, to: to, dry: dry, path: exec_path)
+            undo_changes(files_to_bump, from) if dry
+            exit(files_to_bump.empty?)
+          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)
+            undo_changes(files_to_bump, from)
+            exit(1)
+          end
+
+          errors = Sorbet::Errors::Parser.parse_string(result.err, error_url_base: error_url_base)
+
+          all_files = errors.flat_map do |err|
+            [err.file, *err.files_from_error_sections]
+          end
+
+          files_with_errors = all_files.map do |file|
+            path = File.expand_path(file)
+            next unless path.start_with?(directory)
+            next unless File.file?(path)
+            next unless files_to_bump.include?(path)
+
+            path
+          end.compact.uniq
+
+          undo_changes(files_with_errors, from)
+
+          say("Found #{errors.length} type checking error#{"s" if errors.length > 1}") if options[:count_errors]
+
+          files_changed = files_to_bump - files_with_errors
+          print_changes(files_changed, command: cmd, from: from, to: to, dry: dry, path: exec_path)
+          undo_changes(files_to_bump, from) if dry
+          exit(files_changed.empty?)
+        end
+
+        no_commands do
+          def print_changes(files, command:, from: "false", to: "true", dry: false, path: File.expand_path("."))
+            files_count = files.size
+            if files_count.zero?
+              say("No files to bump from `#{from}` to `#{to}`")
+              return
+            end
+            message = StringIO.new
+            message << (dry ? "Can bump" : "Bumped")
+            message << " `#{files_count}` file#{"s" if files_count > 1}"
+            message << " from `#{from}` to `#{to}`:"
+            say(message.string)
+            files.each do |file|
+              file_path = Pathname.new(file).relative_path_from(path)
+              say(" + #{file_path}")
+            end
+            if dry && command
+              say("\nRun `#{command}` to bump #{files_count > 1 ? "them" : "it"}")
+            elsif dry
+              say("\nRun `spoom bump --from #{from} --to #{to}` locally then `commit the changes` and `push them`")
+            end
+          end
+
+          def undo_changes(files, from_strictness)
+            Sorbet::Sigils.change_sigil_in_files(files, from_strictness)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,224 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative "../../coverage"
+require_relative "../../timeline"
+
+module Spoom
+  module Cli
+    module Srb
+      class Coverage < Thor
+        include Helper
+
+        DATA_DIR = "spoom_data"
+
+        default_task :snapshot
+
+        desc "snapshot", "Run srb tc and display metrics"
+        option :save, type: :string, lazy_default: DATA_DIR, desc: "Save snapshot data as json"
+        option :rbi, type: :boolean, default: true, desc: "Include RBI files in metrics"
+        option :sorbet, type: :string, desc: "Path to custom Sorbet bin"
+        def snapshot
+          context = context_requiring_sorbet!
+          sorbet = options[:sorbet]
+
+          snapshot = Spoom::Coverage.snapshot(context, rbi: options[:rbi], sorbet_bin: sorbet)
+          snapshot.print
+
+          save_dir = options[:save]
+          return unless save_dir
+
+          FileUtils.mkdir_p(save_dir)
+          file = "#{save_dir}/#{snapshot.commit_sha || snapshot.timestamp}.json"
+          File.write(file, snapshot.to_json)
+          say("\nSnapshot data saved under `#{file}`")
+        end
+
+        desc "timeline", "Replay a project and collect metrics"
+        option :from, type: :string, desc: "From commit date"
+        option :to, type: :string, default: Time.now.strftime("%F"), desc: "To commit date"
+        option :save, type: :string, lazy_default: DATA_DIR, desc: "Save snapshot data as json"
+        option :bundle_install, type: :boolean, desc: "Execute `bundle install` before collecting metrics"
+        option :sorbet, type: :string, desc: "Path to custom Sorbet bin"
+        def timeline
+          context = context_requiring_sorbet!
+          path = exec_path
+          sorbet = options[:sorbet]
+
+          ref_before = context.git_current_branch
+          ref_before = context.git_last_commit&.sha unless ref_before
+          unless ref_before
+            say_error("Not in a git repository")
+            say_error("\nSpoom needs to checkout into your previous commits to build the timeline.", status: nil)
+            exit(1)
+          end
+
+          unless context.git_workdir_clean?
+            say_error("Uncommitted changes")
+            say_error(<<~ERR, status: nil)
+
+              Spoom needs to checkout into your previous commits to build the timeline."
+
+              Please `git commit` or `git stash` your changes then try again
+            ERR
+            exit(1)
+          end
+
+          save_dir = options[:save]
+          FileUtils.mkdir_p(save_dir) if save_dir
+
+          from = parse_time(options[:from], "--from")
+          to = parse_time(options[:to], "--to")
+
+          unless from
+            intro_commit = context.sorbet_intro_commit
+            intro_commit = T.must(intro_commit) # we know it's in there since in_sorbet_project!
+            from = intro_commit.time
+          end
+
+          timeline = Spoom::Timeline.new(context, from, to)
+          ticks = timeline.ticks
+
+          if ticks.empty?
+            say_error("No commits to replay, try different `--from` and `--to` options")
+            exit(1)
+          end
+
+          ticks.each_with_index do |commit, i|
+            say("Analyzing commit `#{commit.sha}` - #{commit.time.strftime("%F")} (#{i + 1} / #{ticks.size})")
+
+            context.git_checkout!(ref: commit.sha)
+
+            snapshot = T.let(nil, T.nilable(Spoom::Coverage::Snapshot))
+            if options[:bundle_install]
+              Bundler.with_unbundled_env do
+                next unless bundle_install(path, commit.sha)
+
+                snapshot = Spoom::Coverage.snapshot(context, sorbet_bin: sorbet)
+              end
+            else
+              snapshot = Spoom::Coverage.snapshot(context, sorbet_bin: sorbet)
+            end
+            next unless snapshot
+
+            snapshot.print(indent_level: 2)
+            say("\n")
+
+            next unless save_dir
+
+            file = "#{save_dir}/#{commit.sha}.json"
+            File.write(file, snapshot.to_json)
+            say("  Snapshot data saved under `#{file}`\n\n")
+          end
+          context.git_checkout!(ref: ref_before)
+        end
+
+        desc "report", "Produce a typing coverage report"
+        option :data, type: :string, default: DATA_DIR, desc: "Snapshots JSON data"
+        option :file,
+          type: :string,
+          default: "spoom_report.html",
+          aliases: :f,
+          desc: "Save report to file"
+        option :color_ignore,
+          type: :string,
+          default: Spoom::Coverage::D3::COLOR_IGNORE,
+          desc: "Color used for typed: ignore"
+        option :color_false,
+          type: :string,
+          default: Spoom::Coverage::D3::COLOR_FALSE,
+          desc: "Color used for typed: false"
+        option :color_true,
+          type: :string,
+          default: Spoom::Coverage::D3::COLOR_TRUE,
+          desc: "Color used for typed: true"
+        option :color_strict,
+          type: :string,
+          default: Spoom::Coverage::D3::COLOR_STRICT,
+          desc: "Color used for typed: strict"
+        option :color_strong,
+          type: :string,
+          default: Spoom::Coverage::D3::COLOR_STRONG,
+          desc: "Color used for typed: strong"
+        def report
+          context = context_requiring_sorbet!
+
+          data_dir = options[:data]
+          files = Dir.glob("#{data_dir}/*.json")
+          if files.empty?
+            message_no_data(data_dir)
+            exit(1)
+          end
+
+          snapshots = files.sort.map do |file|
+            json = File.read(file)
+            Spoom::Coverage::Snapshot.from_json(json)
+          end.filter(&:commit_timestamp).sort_by!(&:commit_timestamp)
+
+          palette = Spoom::Coverage::D3::ColorPalette.new(
+            ignore: options[:color_ignore],
+            false: options[:color_false],
+            true: options[:color_true],
+            strict: options[:color_strict],
+            strong: options[:color_strong],
+          )
+
+          report = Spoom::Coverage.report(context, snapshots, palette: palette)
+          file = options[:file]
+          File.write(file, report.html)
+          say("Report generated under `#{file}`")
+          say("\nUse `spoom coverage open` to open it.")
+        end
+
+        desc "open", "Open the typing coverage report"
+        def open(file = "spoom_report.html")
+          unless File.exist?(file)
+            say_error("No report file to open `#{file}`")
+            say_error(<<~ERR, status: nil)
+
+              If you already generated a report under another name use #{blue("spoom coverage open PATH")}.
+
+              To generate a report run #{blue("spoom coverage report")}.
+            ERR
+            exit(1)
+          end
+
+          exec("open #{file}")
+        end
+
+        no_commands do
+          def parse_time(string, option)
+            return unless string
+
+            Time.parse(string)
+          rescue ArgumentError
+            say_error("Invalid date `#{string}` for option `#{option}` (expected format `YYYY-MM-DD`)")
+            exit(1)
+          end
+
+          def bundle_install(path, sha)
+            opts = {}
+            opts[:chdir] = path
+            out, status = Open3.capture2e("bundle install", opts)
+            unless status.success?
+              say_error("Can't run `bundle install` for commit `#{sha}`. Skipping snapshot")
+              say_error(out, status: nil)
+              return false
+            end
+            true
+          end
+
+          def message_no_data(file)
+            say_error("No snapshot files found in `#{file}`")
+            say_error(<<~ERR, status: nil)
+
+              If you already generated snapshot files under another directory use #{blue("spoom coverage report PATH")}.
+
+              To generate snapshot files run #{blue("spoom coverage timeline --save")}.
+            ERR
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,159 @@
+# typed: true
+# frozen_string_literal: true
+
+require "shellwords"
+
+require_relative "../../sorbet/lsp"
+
+module Spoom
+  module Cli
+    module Srb
+      class LSP < Thor
+        include Helper
+
+        desc "list", "List all known symbols"
+        # TODO: options, filter, limit, kind etc.. filter rbi
+        def list
+          run do |client|
+            printer = symbol_printer
+            Dir["**/*.rb"].each do |file|
+              res = client.document_symbols(to_uri(file))
+              next if res.empty?
+
+              say("Symbols from `#{file}`:")
+              printer.print_objects(res)
+            end
+          end
+        end
+
+        desc "hover", "Request hover information"
+        # TODO: options, filter, limit, kind etc.. filter rbi
+        def hover(file, line, col)
+          run do |client|
+            res = client.hover(to_uri(file), line.to_i, col.to_i)
+            say("Hovering `#{file}:#{line}:#{col}`:")
+            if res
+              symbol_printer.print_object(res)
+            else
+              say("<no data>")
+            end
+          end
+        end
+
+        desc "defs", "List definitions of a symbol"
+        # TODO: options, filter, limit, kind etc.. filter rbi
+        def defs(file, line, col)
+          run do |client|
+            res = client.definitions(to_uri(file), line.to_i, col.to_i)
+            say("Definitions for `#{file}:#{line}:#{col}`:")
+            symbol_printer.print_list(res)
+          end
+        end
+
+        desc "find", "Find symbols matching a query"
+        # TODO: options, filter, limit, kind etc.. filter rbi
+        def find(query)
+          run do |client|
+            res = client.symbols(query).reject { |symbol| symbol.location.uri.start_with?("https") }
+            say("Symbols matching `#{query}`:")
+            symbol_printer.print_objects(res)
+          end
+        end
+
+        desc "symbols", "List symbols from a file"
+        # TODO: options, filter, limit, kind etc.. filter rbi
+        def symbols(file)
+          run do |client|
+            res = client.document_symbols(to_uri(file))
+            say("Symbols from `#{file}`:")
+            symbol_printer.print_objects(res)
+          end
+        end
+
+        desc "refs", "List references to a symbol"
+        # TODO: options, filter, limit, kind etc.. filter rbi
+        def refs(file, line, col)
+          run do |client|
+            res = client.references(to_uri(file), line.to_i, col.to_i)
+            say("References to `#{file}:#{line}:#{col}`:")
+            symbol_printer.print_list(res)
+          end
+        end
+
+        desc "sigs", "List signatures for a symbol"
+        # TODO: options, filter, limit, kind etc.. filter rbi
+        def sigs(file, line, col)
+          run do |client|
+            res = client.signatures(to_uri(file), line.to_i, col.to_i)
+            say("Signature for `#{file}:#{line}:#{col}`:")
+            symbol_printer.print_list(res)
+          end
+        end
+
+        desc "types", "Display type of a symbol"
+        # TODO: options, filter, limit, kind etc.. filter rbi
+        def types(file, line, col)
+          run do |client|
+            res = client.type_definitions(to_uri(file), line.to_i, col.to_i)
+            say("Type for `#{file}:#{line}:#{col}`:")
+            symbol_printer.print_list(res)
+          end
+        end
+
+        no_commands do
+          def lsp_client
+            context_requiring_sorbet!
+
+            path = exec_path
+            client = Spoom::LSP::Client.new(
+              Spoom::Sorbet::BIN_PATH,
+              "--lsp",
+              "--enable-all-experimental-lsp-features",
+              "--disable-watchman",
+              path: path,
+            )
+            client.open(File.expand_path(path))
+            client
+          end
+
+          def symbol_printer
+            Spoom::LSP::SymbolPrinter.new(
+              indent_level: 2,
+              colors: options[:color],
+              prefix: "file://#{File.expand_path(exec_path)}",
+            )
+          end
+
+          def run(&block)
+            client = lsp_client
+            block.call(client)
+          rescue Spoom::LSP::Error::Diagnostics => err
+            say_error("Sorbet returned typechecking errors for `#{symbol_printer.clean_uri(err.uri)}`")
+            err.diagnostics.each do |d|
+              say_error("#{d.message} (#{d.code})", status: "  #{d.range}")
+            end
+            exit(1)
+          rescue Spoom::LSP::Error::BadHeaders => err
+            say_error("Sorbet didn't answer correctly (#{err.message})")
+            exit(1)
+          rescue Spoom::LSP::Error => err
+            say_error(err.message)
+            exit(1)
+          ensure
+            begin
+              client&.close
+            rescue
+              # We can't do much if Sorbet refuse to close.
+              # We kill the parent process and let the child be killed.
+              exit(1)
+            end
+          end
+
+          def to_uri(path)
+            "file://" + File.join(File.expand_path(exec_path), path)
+          end
+        end
+      end
+    end
+  end
+end