spoom 1.0.3 → 1.0.8

data/lib/spoom/cli/bump.rb

@@ -0,0 +1,118 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'find'
+require 'open3'
+
+module Spoom
+  module Cli
+    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)"
+      sig { params(directory: String).void }
+      def bump(directory = ".")
+        in_sorbet_project!
+
+        from = options[:from]
+        to = options[:to]
+        force = options[:force]
+        dry = options[:dry]
+        only = options[:only]
+        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
+
+        directory = File.expand_path(directory)
+        files_to_bump = Sorbet::Sigils.files_with_sigil_strictness(directory, from)
+
+        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
+
+        if files_to_bump.empty?
+          $stderr.puts("No file 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, from: from, to: to, dry: dry, path: exec_path)
+          undo_changes(files_to_bump, from) if dry
+          exit(files_to_bump.empty?)
+        end
+
+        output, no_errors = Sorbet.srb_tc(path: exec_path, capture_err: true, sorbet_bin: options[:sorbet])
+
+        if no_errors
+          print_changes(files_to_bump, from: from, to: to, dry: dry, path: exec_path)
+          undo_changes(files_to_bump, from) if dry
+          exit(files_to_bump.empty?)
+        end
+
+        errors = Sorbet::Errors::Parser.parse_string(output)
+
+        files_with_errors = errors.map do |err|
+          path = File.expand_path(err.file)
+          next unless path.start_with?(directory)
+          next unless File.file?(path)
+          path
+        end.compact.uniq
+
+        undo_changes(files_with_errors, from)
+
+        files_changed = files_to_bump - files_with_errors
+        print_changes(files_changed, 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, from: "false", to: "true", dry: false, path: File.expand_path("."))
+          if files.empty?
+            $stderr.puts("No file to bump from #{from} to #{to}")
+            return
+          end
+          $stderr.write(dry ? "Can bump" : "Bumped")
+          $stderr.write(" #{files.size} file#{'s' if files.size > 1}")
+          $stderr.puts(" from #{from} to #{to}:")
+          files.each do |file|
+            file_path = Pathname.new(file).relative_path_from(path)
+            $stderr.puts(" + #{file_path}")
+          end
+          if dry
+            $stderr.puts("\nRun `spoom bump --from #{from} --to #{to}` to bump them")
+          end
+        end
+
+        def undo_changes(files, from_strictness)
+          Sorbet::Sigils.change_sigil_in_files(files, from_strictness)
+        end
+      end
+    end
+  end
+end

data/lib/spoom/cli/config.rb

@@ -0,0 +1,51 @@
+# typed: true
+# frozen_string_literal: true
+
+require_relative "../file_tree"
+require_relative "../sorbet/config"
+
+module Spoom
+  module Cli
+    class Config < Thor
+      include Helper
+
+      default_task :show
+
+      desc "show", "Show Sorbet config"
+      def show
+        in_sorbet_project!
+        config = Spoom::Sorbet::Config.parse_file(sorbet_config)
+
+        say("Found Sorbet config at `#{sorbet_config}`.")
+
+        say("\nPaths typechecked:")
+        if config.paths.empty?
+          say(" * (default: .)")
+        else
+          config.paths.each do |path|
+            say(" * #{path}")
+          end
+        end
+
+        say("\nPaths ignored:")
+        if config.ignore.empty?
+          say(" * (default: none)")
+        else
+          config.ignore.each do |path|
+            say(" * #{path}")
+          end
+        end
+
+        say("\nAllowed extensions:")
+        if config.allowed_extensions.empty?
+          say(" * .rb (default)")
+          say(" * .rbi (default)")
+        else
+          config.allowed_extensions.each do |ext|
+            say(" * #{ext}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spoom/cli/coverage.rb

@@ -0,0 +1,202 @@
+# 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: "Exclude RBI files from metrics"
+      option :sorbet, type: :string, desc: "Path to custom Sorbet bin"
+      def snapshot
+        in_sorbet_project!
+        path = exec_path
+        sorbet = options[:sorbet]
+
+        snapshot = Spoom::Coverage.snapshot(path: path, 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)
+        puts "\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
+        in_sorbet_project!
+        path = exec_path
+        sorbet = options[:sorbet]
+
+        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, sorbet_bin: sorbet)
+            end
+          else
+            snapshot = Spoom::Coverage.snapshot(path: path, sorbet_bin: sorbet)
+          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, 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
+        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,75 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "fileutils"
+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 (#{colorize(sorbet_config, :yellow)} not found)\n\n" \
+            "When running spoom from another path than the project's root, " \
+            "use #{colorize('--path PATH', :blue)} to specify the path to the root."
+          )
+          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::Sorbet::CONFIG_PATH}").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::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})", "  #{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