spoom 1.0.4 → 1.0.5

data/lib/spoom/cli/coverage.rb

@@ -0,0 +1,191 @@
+# 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, desc: "Save snapshot data as json", lazy_default: DATA_DIR
+      def snapshot
+        in_sorbet_project!
+
+        path = exec_path
+        snapshot = Spoom::Coverage.snapshot(path: path)
+        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)
+        puts "\nSnapshot data saved under #{file}"
+      end
+
+      desc "timeline", "replay a project and collect metrics"
+      option :from, type: :string
+      option :to, type: :string, default: Time.now.strftime("%F")
+      option :save, type: :string, desc: "Save snapshot data as json", lazy_default: DATA_DIR
+      option :bundle_install, type: :boolean, desc: "Execute `bundle install` before collecting metrics"
+      def timeline
+        in_sorbet_project!
+        path = exec_path
+
+        sha_before = Spoom::Git.last_commit(path: path)
+        unless sha_before
+          say_error("Not in a git repository")
+          $stderr.puts "\nSpoom needs to checkout into your previous commits to build the timeline."
+          exit(1)
+        end
+
+        unless Spoom::Git.workdir_clean?(path: path)
+          say_error("Uncommited changes")
+          $stderr.puts "\nSpoom needs to checkout into your previous commits to build the timeline."
+          $stderr.puts "\nPlease git commit or git stash your changes then try again."
+          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_sha = Spoom::Git.sorbet_intro_commit(path: path)
+          intro_sha = T.must(intro_sha) # we know it's in there since in_sorbet_project!
+          from = Spoom::Git.commit_time(intro_sha, path: path)
+        end
+
+        timeline = Spoom::Timeline.new(from, to, path: path)
+        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 |sha, i|
+          date = Spoom::Git.commit_time(sha, path: path)
+          puts "Analyzing commit #{sha} - #{date&.strftime('%F')} (#{i + 1} / #{ticks.size})"
+
+          Spoom::Git.checkout(sha, path: path)
+
+          snapshot = T.let(nil, T.nilable(Spoom::Coverage::Snapshot))
+          if options[:bundle_install]
+            Bundler.with_clean_env do
+              next unless bundle_install(path, sha)
+              snapshot = Spoom::Coverage.snapshot(path: path)
+            end
+          else
+            snapshot = Spoom::Coverage.snapshot(path: path)
+          end
+          next unless snapshot
+
+          snapshot.print(indent_level: 2)
+          puts "\n"
+
+          next unless save_dir
+          file = "#{save_dir}/#{sha}.json"
+          File.write(file, snapshot.to_json)
+          puts "  Snapshot data saved under #{file}\n\n"
+        end
+        Spoom::Git.checkout(sha_before, path: path)
+      end
+
+      desc "report", "produce a typing coverage report"
+      option :data, type: :string, desc: "Snapshots JSON data", default: DATA_DIR
+      option :file, type: :string, default: "spoom_report.html", aliases: :f
+      option :color_ignore, type: :string, default: Spoom::Coverage::D3::COLOR_IGNORE
+      option :color_false, type: :string, default: Spoom::Coverage::D3::COLOR_FALSE
+      option :color_true, type: :string, default: Spoom::Coverage::D3::COLOR_TRUE
+      option :color_strict, type: :string, default: Spoom::Coverage::D3::COLOR_STRICT
+      option :color_strong, type: :string, default: Spoom::Coverage::D3::COLOR_STRONG
+      def report
+        in_sorbet_project!
+
+        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(snapshots, palette: palette, path: exec_path)
+        file = options[:file]
+        File.write(file, report.html)
+        puts "Report generated under #{file}"
+        puts "\nUse #{colorize('spoom coverage open', :blue)} 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 #{colorize(file, :blue)}")
+          $stderr.puts <<~OUT
+
+            If you already generated a report under another name use #{colorize('spoom coverage open PATH', :blue)}.
+
+            To generate a report run #{colorize('spoom coverage report', :blue)}.
+          OUT
+          exit(1)
+        end
+
+        exec("open #{file}")
+      end
+
+      no_commands do
+        def parse_time(string, option)
+          return nil 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")
+            $stderr.puts(out)
+            return false
+          end
+          true
+        end
+
+        def message_no_data(file)
+          say_error("No snapshot files found in #{colorize(file, :blue)}")
+          $stderr.puts <<~OUT
+
+            If you already generated snapshot files under another directory use #{colorize('spoom coverage report PATH', :blue)}.
+
+            To generate snapshot files run #{colorize('spoom coverage timeline --save-dir spoom_data', :blue)}.
+          OUT
+        end
+      end
+    end
+  end
+end

data/lib/spoom/cli/helper.rb

@@ -0,0 +1,70 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "pathname"
+require "stringio"
+
+module Spoom
+  module Cli
+    module Helper
+      extend T::Sig
+      include Thor::Shell
+
+      # Print `message` on `$stderr`
+      #
+      # The message is prefixed by a status (default: `Error`).
+      sig { params(message: String, status: String).void }
+      def say_error(message, status = "Error")
+        status = set_color(status, :red)
+
+        buffer = StringIO.new
+        buffer << "#{status}: #{message}"
+        buffer << "\n" unless message.end_with?("\n")
+
+        $stderr.print(buffer.string)
+        $stderr.flush
+      end
+
+      # Is `spoom` ran inside a project with a `sorbet/config` file?
+      sig { returns(T::Boolean) }
+      def in_sorbet_project?
+        File.file?(sorbet_config)
+      end
+
+      # Enforce that `spoom` is ran inside a project with a `sorbet/config` file
+      #
+      # Display an error message and exit otherwise.
+      sig { void }
+      def in_sorbet_project!
+        unless in_sorbet_project?
+          say_error("not in a Sorbet project (no sorbet/config)")
+          Kernel.exit(1)
+        end
+      end
+
+      # Return the path specified through `--path`
+      sig { returns(String) }
+      def exec_path
+        T.unsafe(self).options[:path] # TODO: requires_ancestor
+      end
+
+      sig { returns(String) }
+      def sorbet_config
+        Pathname.new("#{exec_path}/#{Spoom::Config::SORBET_CONFIG}").cleanpath.to_s
+      end
+
+      # Is the `--color` option true?
+      sig { returns(T::Boolean) }
+      def color?
+        T.unsafe(self).options[:color] # TODO: requires_ancestor
+      end
+
+      # Colorize a string if `color?`
+      sig { params(string: String, color: Symbol).returns(String) }
+      def colorize(string, color)
+        return string unless color?
+        string.colorize(color)
+      end
+    end
+  end
+end

data/lib/spoom/cli/lsp.rb

@@ -0,0 +1,165 @@
+# 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
+        in_sorbet_project!
+        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?
+            puts "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
+            puts "<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)
+          puts "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") }
+          puts "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))
+          puts "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)
+          puts "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)
+          puts "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
+          in_sorbet_project!
+          path = exec_path
+          client = Spoom::LSP::Client.new(
+            Spoom::Config::SORBET_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})", "  #{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

@@ -0,0 +1,79 @@
+# typed: true
+# frozen_string_literal: true
+
+module Spoom
+  module Cli
+    class Run < Thor
+      include Helper
+
+      default_task :tc
+
+      desc "tc", "run srb tc"
+      option :limit, type: :numeric, aliases: :l
+      option :code, type: :numeric, aliases: :c
+      option :sort, type: :string, aliases: :s
+      def tc
+        in_sorbet_project!
+
+        path = exec_path
+        limit = options[:limit]
+        sort = options[:sort]
+        code = options[:code]
+        colors = options[:color]
+
+        unless limit || code || sort
+          return Spoom::Sorbet.srb_tc(path: path, capture_err: false).last
+        end
+
+        output, status = Spoom::Sorbet.srb_tc(path: path, capture_err: true)
+        if status
+          $stderr.print(output)
+          return 0
+        end
+
+        errors = Spoom::Sorbet::Errors::Parser.parse_string(output)
+        errors_count = errors.size
+
+        errors = sort == "code" ? errors.sort_by { |e| [e.code, e.file, e.line, e.message] } : errors.sort
+        errors = errors.select { |e| e.code == code } if code
+        errors = T.must(errors.slice(0, limit)) if limit
+
+        errors.each do |e|
+          code = colorize_code(e.code, colors)
+          message = colorize_message(e.message, colors)
+          $stderr.puts "#{code} - #{e.file}:#{e.line}: #{message}"
+        end
+
+        if errors_count == errors.size
+          $stderr.puts "Errors: #{errors_count}"
+        else
+          $stderr.puts "Errors: #{errors.size} shown, #{errors_count} total"
+        end
+
+        1
+      end
+
+      no_commands do
+        def colorize_code(code, colors = true)
+          return code.to_s unless colors
+          code.to_s.light_black
+        end
+
+        def colorize_message(message, colors = true)
+          return message unless colors
+
+          cyan = T.let(false, T::Boolean)
+          word = StringIO.new
+          message.chars.each do |c|
+            if c == '`'
+              cyan = !cyan
+              next
+            end
+            word << (cyan ? c.cyan : c.red)
+          end
+          word.string
+        end
+      end
+    end
+  end
+end