spoom 1.1.15 → 1.2.0

data/lib/spoom/sorbet/lsp/structures.rb

@@ -273,34 +273,37 @@ module Spoom
         SYMBOL_KINDS[kind] || "<unknown:#{kind}>"
       end
 
-      SYMBOL_KINDS = T.let({
-        1 => "file",
-        2 => "module",
-        3 => "namespace",
-        4 => "package",
-        5 => "class",
-        6 => "def",
-        7 => "property",
-        8 => "field",
-        9 => "constructor",
-        10 => "enum",
-        11 => "interface",
-        12 => "function",
-        13 => "variable",
-        14 => "const",
-        15 => "string",
-        16 => "number",
-        17 => "boolean",
-        18 => "array",
-        19 => "object",
-        20 => "key",
-        21 => "null",
-        22 => "enum_member",
-        23 => "struct",
-        24 => "event",
-        25 => "operator",
-        26 => "type_parameter",
-      }, T::Hash[Integer, String])
+      SYMBOL_KINDS = T.let(
+        {
+          1 => "file",
+          2 => "module",
+          3 => "namespace",
+          4 => "package",
+          5 => "class",
+          6 => "def",
+          7 => "property",
+          8 => "field",
+          9 => "constructor",
+          10 => "enum",
+          11 => "interface",
+          12 => "function",
+          13 => "variable",
+          14 => "const",
+          15 => "string",
+          16 => "number",
+          17 => "boolean",
+          18 => "array",
+          19 => "object",
+          20 => "key",
+          21 => "null",
+          22 => "enum_member",
+          23 => "struct",
+          24 => "event",
+          25 => "operator",
+          26 => "type_parameter",
+        },
+        T::Hash[Integer, String],
+      )
     end
 
     class SymbolPrinter < Printer

data/lib/spoom/sorbet/sigils.rb

@@ -16,14 +16,17 @@ module Spoom
       STRICTNESS_STRONG = "strong"
       STRICTNESS_INTERNAL = "__STDLIB_INTERNAL"
 
-      VALID_STRICTNESS = T.let([
-        STRICTNESS_IGNORE,
-        STRICTNESS_FALSE,
-        STRICTNESS_TRUE,
-        STRICTNESS_STRICT,
-        STRICTNESS_STRONG,
-        STRICTNESS_INTERNAL,
-      ].freeze, T::Array[String])
+      VALID_STRICTNESS = T.let(
+        [
+          STRICTNESS_IGNORE,
+          STRICTNESS_FALSE,
+          STRICTNESS_TRUE,
+          STRICTNESS_STRICT,
+          STRICTNESS_STRONG,
+          STRICTNESS_INTERNAL,
+        ].freeze,
+        T::Array[String],
+      )
 
       SIGIL_REGEXP = T.let(/^#[\ t]*typed[\ t]*:[ \t]*(\w*)[ \t]*/.freeze, Regexp)
 

data/lib/spoom/sorbet.rb

@@ -11,117 +11,33 @@ require "open3"
 
 module Spoom
   module Sorbet
-    CONFIG_PATH = "sorbet/config"
-    GEM_PATH = T.let(Gem::Specification.find_by_name("sorbet-static").full_gem_path, String)
-    BIN_PATH = T.let((Pathname.new(GEM_PATH) / "libexec" / "sorbet").to_s, String)
-
-    SEGFAULT_CODE = 139
-
-    class << self
+    class Error < StandardError
       extend T::Sig
 
-      sig do
-        params(
-          arg: String,
-          path: String,
-          capture_err: T::Boolean,
-          sorbet_bin: T.nilable(String),
-        ).returns(ExecResult)
-      end
-      def srb(*arg, path: ".", capture_err: false, sorbet_bin: nil)
-        if sorbet_bin
-          arg.prepend(sorbet_bin)
-        else
-          arg.prepend("bundle", "exec", "srb")
-        end
-        Spoom.exec(*T.unsafe(arg), path: path, capture_err: capture_err)
-      end
+      class Killed < Error; end
+      class Segfault < Error; end
 
-      sig do
-        params(
-          arg: String,
-          path: String,
-          capture_err: T::Boolean,
-          sorbet_bin: T.nilable(String),
-        ).returns(ExecResult)
-      end
-      def srb_tc(*arg, path: ".", capture_err: false, sorbet_bin: nil)
-        arg.prepend("tc") unless sorbet_bin
-        srb(*T.unsafe(arg), path: path, capture_err: capture_err, sorbet_bin: sorbet_bin)
-      end
-
-      # List all files typechecked by Sorbet from its `config`
-      sig { params(config: Config, path: String).returns(T::Array[String]) }
-      def srb_files(config, path: ".")
-        regs = config.ignore.map { |string| Regexp.new(Regexp.escape(string)) }
-        exts = config.allowed_extensions.empty? ? [".rb", ".rbi"] : config.allowed_extensions
-        Dir.glob((Pathname.new(path) / "**/*{#{exts.join(",")}}").to_s).reject do |f|
-          regs.any? { |re| re.match?(f) }
-        end.sort
-      end
+      sig { returns(ExecResult) }
+      attr_reader :result
 
       sig do
         params(
-          arg: String,
-          path: String,
-          capture_err: T::Boolean,
-          sorbet_bin: T.nilable(String),
-        ).returns(T.nilable(String))
+          message: String,
+          result: ExecResult,
+        ).void
       end
-      def srb_version(*arg, path: ".", capture_err: false, sorbet_bin: nil)
-        result = T.let(T.unsafe(self).srb_tc(
-          "--no-config",
-          "--version",
-          *arg,
-          path: path,
-          capture_err: capture_err,
-          sorbet_bin: sorbet_bin,
-        ), ExecResult)
-        return nil unless result.status
+      def initialize(message, result)
+        super(message)
 
-        result.out.split(" ")[2]
+        @result = result
       end
+    end
 
-      sig do
-        params(
-          arg: String,
-          path: String,
-          capture_err: T::Boolean,
-          sorbet_bin: T.nilable(String),
-        ).returns(T.nilable(T::Hash[String, Integer]))
-      end
-      def srb_metrics(*arg, path: ".", capture_err: false, sorbet_bin: nil)
-        metrics_file = "metrics.tmp"
-        metrics_path = "#{path}/#{metrics_file}"
-        T.unsafe(self).srb_tc(
-          "--metrics-file",
-          metrics_file,
-          *arg,
-          path: path,
-          capture_err: capture_err,
-          sorbet_bin: sorbet_bin,
-        )
-        if File.exist?(metrics_path)
-          metrics = Spoom::Sorbet::MetricsParser.parse_file(metrics_path)
-          File.delete(metrics_path)
-          return metrics
-        end
-        nil
-      end
-
-      # Get `gem` version from the `Gemfile.lock` content
-      #
-      # Returns `nil` if `gem` cannot be found in the Gemfile.
-      sig { params(gem: String, path: String).returns(T.nilable(String)) }
-      def version_from_gemfile_lock(gem: "sorbet", path: ".")
-        gemfile_path = "#{path}/Gemfile.lock"
-        return nil unless File.exist?(gemfile_path)
-
-        content = File.read(gemfile_path).match(/^    #{gem} \(.*(\d+\.\d+\.\d+).*\)/)
-        return nil unless content
+    CONFIG_PATH = "sorbet/config"
+    GEM_PATH = T.let(Gem::Specification.find_by_name("sorbet-static").full_gem_path, String)
+    BIN_PATH = T.let((Pathname.new(GEM_PATH) / "libexec" / "sorbet").to_s, String)
 
-        content[1]
-      end
-    end
+    KILLED_CODE = 137
+    SEGFAULT_CODE = 139
   end
 end

data/lib/spoom/timeline.rb

@@ -1,17 +1,15 @@
 # typed: strict
 # frozen_string_literal: true
 
-require_relative "git"
-
 module Spoom
   class Timeline
     extend T::Sig
 
-    sig { params(from: Time, to: Time, path: String).void }
-    def initialize(from, to, path: ".")
+    sig { params(context: Context, from: Time, to: Time).void }
+    def initialize(context, from, to)
+      @context = context
       @from = from
       @to = to
-      @path = path
     end
 
     # Return one commit for each month between `from` and `to`
@@ -37,17 +35,16 @@ module Spoom
     sig { params(dates: T::Array[Time]).returns(T::Array[Git::Commit]) }
     def commits_for_dates(dates)
       dates.map do |t|
-        result = Spoom::Git.log(
+        result = @context.git_log(
           "--since='#{t}'",
           "--until='#{t.to_date.next_month}'",
           "--format='format:%h %at'",
           "--author-date-order",
           "-1",
-          path: @path,
         )
         next if result.out.empty?
 
-        Git.parse_commit(result.out.strip)
+        Spoom::Git::Commit.parse_line(result.out.strip)
       end.compact.uniq(&:sha)
     end
   end

data/lib/spoom/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Spoom
-  VERSION = "1.1.15"
+  VERSION = "1.2.0"
 end

data/lib/spoom.rb

@@ -10,58 +10,6 @@ module Spoom
   SPOOM_PATH = T.let((Pathname.new(__FILE__) / ".." / "..").to_s, String)
 
   class Error < StandardError; end
-
-  class ExecResult < T::Struct
-    extend T::Sig
-
-    const :out, String
-    const :err, String
-    const :status, T::Boolean
-    const :exit_code, Integer
-
-    sig { returns(String) }
-    def to_s
-      <<~STR
-        ########## STDOUT ##########
-        #{out.empty? ? "<empty>" : out}
-        ########## STDERR ##########
-        #{err.empty? ? "<empty>" : err}
-        ########## STATUS: #{status} ##########
-      STR
-    end
-  end
-
-  class << self
-    extend T::Sig
-
-    sig do
-      params(
-        cmd: String,
-        arg: String,
-        path: String,
-        capture_err: T::Boolean,
-      ).returns(ExecResult)
-    end
-    def exec(cmd, *arg, path: ".", capture_err: false)
-      if capture_err
-        stdout, stderr, status = T.unsafe(Open3).capture3([cmd, *arg].join(" "), chdir: path)
-        ExecResult.new(
-          out: stdout,
-          err: stderr,
-          status: status.success?,
-          exit_code: status.exitstatus,
-        )
-      else
-        stdout, status = T.unsafe(Open3).capture2([cmd, *arg].join(" "), chdir: path)
-        ExecResult.new(
-          out: stdout,
-          err: "",
-          status: status.success?,
-          exit_code: status.exitstatus,
-        )
-      end
-    end
-  end
 end
 
 require "spoom/context"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spoom
 version: !ruby/object:Gem::Version
-  version: 1.1.15
+  version: 1.2.0
 platform: ruby
 authors:
 - Alexandre Terrasa
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-12-14 00:00:00.000000000 Z
+date: 2023-03-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -130,6 +130,11 @@ files:
 - lib/spoom/cli/run.rb
 - lib/spoom/colors.rb
 - lib/spoom/context.rb
+- lib/spoom/context/bundle.rb
+- lib/spoom/context/exec.rb
+- lib/spoom/context/file_system.rb
+- lib/spoom/context/git.rb
+- lib/spoom/context/sorbet.rb
 - lib/spoom/coverage.rb
 - lib/spoom/coverage/d3.rb
 - lib/spoom/coverage/d3/base.rb
@@ -139,7 +144,6 @@ files:
 - lib/spoom/coverage/report.rb
 - lib/spoom/coverage/snapshot.rb
 - lib/spoom/file_tree.rb
-- lib/spoom/git.rb
 - lib/spoom/printer.rb
 - lib/spoom/sorbet.rb
 - lib/spoom/sorbet/config.rb
@@ -175,7 +179,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.4.9
 signing_key: 
 specification_version: 4
 summary: Useful tools for Sorbet enthusiasts.

data/lib/spoom/git.rb

@@ -1,130 +0,0 @@
-# typed: strict
-# frozen_string_literal: true
-
-require "time"
-
-module Spoom
-  # Execute git commands
-  module Git
-    class Commit < T::Struct
-      extend T::Sig
-
-      const :sha, String
-      const :time, Time
-
-      sig { returns(Integer) }
-      def timestamp
-        time.to_i
-      end
-    end
-
-    class << self
-      extend T::Sig
-
-      # Execute a `command`
-      sig { params(command: String, arg: String, path: String).returns(ExecResult) }
-      def exec(command, *arg, path: ".")
-        return ExecResult.new(
-          out: "",
-          err: "Error: `#{path}` is not a directory.",
-          status: false,
-          exit_code: 1,
-        ) unless File.directory?(path)
-
-        T.unsafe(Open3).popen3(command, *arg, chdir: path) do |_, stdout, stderr, thread|
-          status = T.cast(thread.value, Process::Status)
-          ExecResult.new(
-            out: stdout.read,
-            err: stderr.read,
-            status: T.must(status.success?),
-            exit_code: T.must(status.exitstatus),
-          )
-        end
-      end
-
-      # Git commands
-
-      sig { params(arg: String, path: String).returns(ExecResult) }
-      def checkout(*arg, path: ".")
-        exec("git checkout -q #{arg.join(" ")}", path: path)
-      end
-
-      sig { params(arg: String, path: String).returns(ExecResult) }
-      def diff(*arg, path: ".")
-        exec("git diff #{arg.join(" ")}", path: path)
-      end
-
-      sig { params(arg: String, path: String).returns(ExecResult) }
-      def log(*arg, path: ".")
-        exec("git log #{arg.join(" ")}", path: path)
-      end
-
-      sig { params(arg: String, path: String).returns(ExecResult) }
-      def show(*arg, path: ".")
-        exec("git show #{arg.join(" ")}", path: path)
-      end
-
-      sig { params(path: String).returns(T.nilable(String)) }
-      def current_branch(path: ".")
-        result = exec("git branch --show-current", path: path)
-        return nil unless result.status
-
-        result.out.strip
-      end
-
-      # Utils
-
-      # Get the last commit in the currently checked out branch
-      sig { params(path: String, short_sha: T::Boolean).returns(T.nilable(Commit)) }
-      def last_commit(path: ".", short_sha: true)
-        result = log("HEAD --format='%#{short_sha ? "h" : "H"} %at' -1", path: path)
-        return nil unless result.status
-
-        out = result.out.strip
-        return nil if out.empty?
-
-        parse_commit(out)
-      end
-
-      # Is there uncommited changes in `path`?
-      sig { params(path: String).returns(T::Boolean) }
-      def workdir_clean?(path: ".")
-        diff("HEAD", path: path).out.empty?
-      end
-
-      # Get the commit introducing the `sorbet/config` file
-      sig { params(path: String).returns(T.nilable(Commit)) }
-      def sorbet_intro_commit(path: ".")
-        result = log("--diff-filter=A --format='%h %at' -1 -- sorbet/config", path: path)
-        return nil unless result.status
-
-        out = result.out.strip
-        return nil if out.empty?
-
-        parse_commit(out)
-      end
-
-      # Get the commit removing the `sorbet/config` file
-      sig { params(path: String).returns(T.nilable(Commit)) }
-      def sorbet_removal_commit(path: ".")
-        result = log("--diff-filter=D --format='%h %at' -1 -- sorbet/config", path: path)
-        return nil unless result.status
-
-        out = result.out.strip
-        return nil if out.empty?
-
-        parse_commit(out)
-      end
-
-      # Parse a line formated as `%h %at` into a `Commit`
-      sig { params(string: String).returns(T.nilable(Commit)) }
-      def parse_commit(string)
-        sha, epoch = string.split(" ", 2)
-        return nil unless sha && epoch
-
-        time = Time.strptime(epoch, "%s")
-        Commit.new(sha: sha, time: time)
-      end
-    end
-  end
-end