spoom 1.2.3 → 1.3.0

data/lib/spoom/cli/coverage.rb

@@ -1,222 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require_relative "../coverage"
-require_relative "../timeline"
-
-module Spoom
-  module Cli
-    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("Uncommited 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

data/lib/spoom/cli/lsp.rb

@@ -1,168 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require "shellwords"
-
-require_relative "../sorbet/lsp"
-
-module Spoom
-  module Cli
-    class LSP < Thor
-      include Helper
-
-      default_task :show
-
-      desc "interactive", "Interactive LSP mode"
-      def show
-        context_requiring_sorbet!
-
-        lsp = lsp_client
-        # TODO: run interactive mode
-        puts lsp
-      end
-
-      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 informations"
-      # 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

data/lib/spoom/cli/run.rb

@@ -1,148 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-module Spoom
-  module Cli
-    class Run < 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