spoom 1.0.4 → 1.0.9

data/lib/spoom/cli/bump.rb

@@ -0,0 +1,138 @@
+# 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)"
+      option :suggest_bump_command, type: :string,
+        desc: "Command to suggest if files can be bumped"
+      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]
+        cmd = options[:suggest_bump_command]
+        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
+
+        say("Checking files...")
+
+        directory = File.expand_path(directory)
+        files_to_bump = Sorbet::Sigils.files_with_sigil_strictness(directory, from)
+
+        files_from_config = config_files(path: exec_path)
+        files_to_bump.select! { |file| files_from_config.include?(file) }
+
+        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 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, 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
+
+        output, no_errors = Sorbet.srb_tc(path: exec_path, capture_err: true, sorbet_bin: options[:sorbet])
+
+        if no_errors
+          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
+
+        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, 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("."))
+          if files.empty?
+            say("No file to bump from `#{from}` to `#{to}`")
+            return
+          end
+          message = StringIO.new
+          message << (dry ? "Can bump" : "Bumped")
+          message << " `#{files.size}` file#{'s' if files.size > 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 them")
+          elsif dry
+            say("\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
+
+        def config_files(path: ".")
+          config = sorbet_config
+          files = Sorbet.srb_files(config, path: path)
+          files.map { |file| File.expand_path(file) }
+        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 = sorbet_config
+
+        say("Found Sorbet config at `#{sorbet_config_file}`.")
+
+        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,206 @@
+# 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)
+        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
+        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")
+          say_error("\nSpoom needs to checkout into your previous commits to build the timeline.", status: nil)
+          exit(1)
+        end
+
+        unless Spoom::Git.workdir_clean?(path: path)
+          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_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)
+          say("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)
+          say("\n")
+
+          next unless save_dir
+          file = "#{save_dir}/#{sha}.json"
+          File.write(file, snapshot.to_json)
+          say("  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)
+        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 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")
+            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-dir spoom_data')}.
+          ERR
+        end
+      end
+    end
+  end
+end

data/lib/spoom/cli/helper.rb

@@ -0,0 +1,149 @@
+# 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 `$stdout`
+      sig { params(message: String).void }
+      def say(message)
+        buffer = StringIO.new
+        buffer << highlight(message)
+        buffer << "\n" unless message.end_with?("\n")
+
+        $stdout.print(buffer.string)
+        $stdout.flush
+      end
+
+      # Print `message` on `$stderr`
+      #
+      # The message is prefixed by a status (default: `Error`).
+      sig do
+        params(
+          message: String,
+          status: T.nilable(String),
+          nl: T::Boolean
+        ).void
+      end
+      def say_error(message, status: "Error", nl: true)
+        buffer = StringIO.new
+        buffer << "#{red(status)}: " if status
+        buffer << highlight(message)
+        buffer << "\n" if nl && !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_file)
+      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 (`#{sorbet_config_file}` not found)\n\n" \
+            "When running spoom from another path than the project's root, " \
+            "use `--path PATH` 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_file
+        Pathname.new("#{exec_path}/#{Spoom::Sorbet::CONFIG_PATH}").cleanpath.to_s
+      end
+
+      sig { returns(Sorbet::Config) }
+      def sorbet_config
+        Sorbet::Config.parse_file(sorbet_config_file)
+      end
+
+      # Colors
+
+      # Color used to highlight expressions in backticks
+      HIGHLIGHT_COLOR = :blue
+
+      # Is the `--color` option true?
+      sig { returns(T::Boolean) }
+      def color?
+        T.unsafe(self).options[:color] # TODO: requires_ancestor
+      end
+
+      sig { params(string: String).returns(String) }
+      def highlight(string)
+        return string unless color?
+
+        res = StringIO.new
+        word = StringIO.new
+        in_ticks = T.let(false, T::Boolean)
+        string.chars.each do |c|
+          if c == '`' && !in_ticks
+            in_ticks = true
+          elsif c == '`' && in_ticks
+            in_ticks = false
+            res << colorize(word.string, HIGHLIGHT_COLOR)
+            word = StringIO.new
+          elsif in_ticks
+            word << c
+          else
+            res << c
+          end
+        end
+        res.string
+      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
+
+      sig { params(string: String).returns(String) }
+      def blue(string)
+        colorize(string, :blue)
+      end
+
+      sig { params(string: String).returns(String) }
+      def gray(string)
+        colorize(string, :light_black)
+      end
+
+      sig { params(string: String).returns(String) }
+      def green(string)
+        colorize(string, :green)
+      end
+
+      sig { params(string: String).returns(String) }
+      def red(string)
+        colorize(string, :red)
+      end
+
+      sig { params(string: String).returns(String) }
+      def yellow(string)
+        colorize(string, :yellow)
+      end
+    end
+  end
+end