spoom 1.1.11 → 1.1.13

data/lib/spoom/sorbet/lsp.rb

@@ -1,12 +1,12 @@
 # typed: strict
 # frozen_string_literal: true
 
-require 'open3'
-require 'json'
+require "open3"
+require "json"
 
-require_relative 'lsp/base'
-require_relative 'lsp/structures'
-require_relative 'lsp/errors'
+require_relative "lsp/base"
+require_relative "lsp/structures"
+require_relative "lsp/errors"
 
 module Spoom
   module LSP
@@ -58,10 +58,10 @@ module Spoom
         json = JSON.parse(raw_string)
 
         # Handle error in the LSP protocol
-        raise ResponseError.from_json(json['error']) if json['error']
+        raise ResponseError.from_json(json["error"]) if json["error"]
 
         # Handle typechecking errors
-        raise Error::Diagnostics.from_json(json['params']) if json['method'] == "textDocument/publishDiagnostics"
+        raise Error::Diagnostics.from_json(json["params"]) if json["method"] == "textDocument/publishDiagnostics"
 
         json
       end
@@ -71,16 +71,17 @@ module Spoom
       sig { params(workspace_path: String).void }
       def open(workspace_path)
         raise Error::AlreadyOpen, "Error: CLI already opened" if @open
+
         send(Request.new(
           next_id,
-          'initialize',
+          "initialize",
           {
-            'rootPath' => workspace_path,
-            'rootUri' => "file://#{workspace_path}",
-            'capabilities' => {},
+            "rootPath" => workspace_path,
+            "rootUri" => "file://#{workspace_path}",
+            "capabilities" => {},
           },
         ))
-        send(Notification.new('initialized', {}))
+        send(Notification.new("initialized", {}))
         @open = true
       end
 
@@ -88,133 +89,140 @@ module Spoom
       def hover(uri, line, column)
         json = send(Request.new(
           next_id,
-          'textDocument/hover',
+          "textDocument/hover",
           {
-            'textDocument' => {
-              'uri' => uri,
+            "textDocument" => {
+              "uri" => uri,
             },
-            'position' => {
-              'line' => line,
-              'character' => column,
+            "position" => {
+              "line" => line,
+              "character" => column,
             },
-          }
+          },
         ))
 
-        return nil unless json && json['result']
-        Hover.from_json(json['result'])
+        return nil unless json && json["result"]
+
+        Hover.from_json(json["result"])
       end
 
       sig { params(uri: String, line: Integer, column: Integer).returns(T::Array[SignatureHelp]) }
       def signatures(uri, line, column)
         json = send(Request.new(
           next_id,
-          'textDocument/signatureHelp',
+          "textDocument/signatureHelp",
           {
-            'textDocument' => {
-              'uri' => uri,
+            "textDocument" => {
+              "uri" => uri,
             },
-            'position' => {
-              'line' => line,
-              'character' => column,
+            "position" => {
+              "line" => line,
+              "character" => column,
             },
-          }
+          },
         ))
 
-        return [] unless json && json['result'] && json['result']['signatures']
-        json['result']['signatures'].map { |loc| SignatureHelp.from_json(loc) }
+        return [] unless json && json["result"] && json["result"]["signatures"]
+
+        json["result"]["signatures"].map { |loc| SignatureHelp.from_json(loc) }
       end
 
       sig { params(uri: String, line: Integer, column: Integer).returns(T::Array[Location]) }
       def definitions(uri, line, column)
         json = send(Request.new(
           next_id,
-          'textDocument/definition',
+          "textDocument/definition",
           {
-            'textDocument' => {
-              'uri' => uri,
+            "textDocument" => {
+              "uri" => uri,
             },
-            'position' => {
-              'line' => line,
-              'character' => column,
+            "position" => {
+              "line" => line,
+              "character" => column,
             },
-          }
+          },
         ))
 
-        return [] unless json && json['result']
-        json['result'].map { |loc| Location.from_json(loc) }
+        return [] unless json && json["result"]
+
+        json["result"].map { |loc| Location.from_json(loc) }
       end
 
       sig { params(uri: String, line: Integer, column: Integer).returns(T::Array[Location]) }
       def type_definitions(uri, line, column)
         json = send(Request.new(
           next_id,
-          'textDocument/typeDefinition',
+          "textDocument/typeDefinition",
           {
-            'textDocument' => {
-              'uri' => uri,
+            "textDocument" => {
+              "uri" => uri,
             },
-            'position' => {
-              'line' => line,
-              'character' => column,
+            "position" => {
+              "line" => line,
+              "character" => column,
             },
-          }
+          },
         ))
 
-        return [] unless json && json['result']
-        json['result'].map { |loc| Location.from_json(loc) }
+        return [] unless json && json["result"]
+
+        json["result"].map { |loc| Location.from_json(loc) }
       end
 
       sig { params(uri: String, line: Integer, column: Integer, include_decl: T::Boolean).returns(T::Array[Location]) }
       def references(uri, line, column, include_decl = true)
         json = send(Request.new(
           next_id,
-          'textDocument/references',
+          "textDocument/references",
           {
-            'textDocument' => {
-              'uri' => uri,
+            "textDocument" => {
+              "uri" => uri,
             },
-            'position' => {
-              'line' => line,
-              'character' => column,
+            "position" => {
+              "line" => line,
+              "character" => column,
             },
-            'context' => {
-              'includeDeclaration' => include_decl,
+            "context" => {
+              "includeDeclaration" => include_decl,
             },
-          }
+          },
         ))
 
-        return [] unless json && json['result']
-        json['result'].map { |loc| Location.from_json(loc) }
+        return [] unless json && json["result"]
+
+        json["result"].map { |loc| Location.from_json(loc) }
       end
 
       sig { params(query: String).returns(T::Array[DocumentSymbol]) }
       def symbols(query)
         json = send(Request.new(
           next_id,
-          'workspace/symbol',
+          "workspace/symbol",
           {
-            'query' => query,
-          }
+            "query" => query,
+          },
         ))
 
-        return [] unless json && json['result']
-        json['result'].map { |loc| DocumentSymbol.from_json(loc) }
+        return [] unless json && json["result"]
+
+        json["result"].map { |loc| DocumentSymbol.from_json(loc) }
       end
 
       sig { params(uri: String).returns(T::Array[DocumentSymbol]) }
       def document_symbols(uri)
         json = send(Request.new(
           next_id,
-          'textDocument/documentSymbol',
+          "textDocument/documentSymbol",
           {
-            'textDocument' => {
-              'uri' => uri,
+            "textDocument" => {
+              "uri" => uri,
             },
-          }
+          },
         ))
 
-        return [] unless json && json['result']
-        json['result'].map { |loc| DocumentSymbol.from_json(loc) }
+        return [] unless json && json["result"]
+
+        json["result"].map { |loc| DocumentSymbol.from_json(loc) }
       end
 
       sig { void }

data/lib/spoom/sorbet/metrics.rb

@@ -6,26 +6,28 @@ require_relative "sigils"
 module Spoom
   module Sorbet
     module MetricsParser
-      extend T::Sig
-
       DEFAULT_PREFIX = "ruby_typer.unknown.."
 
-      sig { params(path: String, prefix: String).returns(T::Hash[String, Integer]) }
-      def self.parse_file(path, prefix = DEFAULT_PREFIX)
-        parse_string(File.read(path), prefix)
-      end
+      class << self
+        extend T::Sig
 
-      sig { params(string: String, prefix: String).returns(T::Hash[String, Integer]) }
-      def self.parse_string(string, prefix = DEFAULT_PREFIX)
-        parse_hash(JSON.parse(string), prefix)
-      end
+        sig { params(path: String, prefix: String).returns(T::Hash[String, Integer]) }
+        def parse_file(path, prefix = DEFAULT_PREFIX)
+          parse_string(File.read(path), prefix)
+        end
+
+        sig { params(string: String, prefix: String).returns(T::Hash[String, Integer]) }
+        def parse_string(string, prefix = DEFAULT_PREFIX)
+          parse_hash(JSON.parse(string), prefix)
+        end
 
-      sig { params(obj: T::Hash[String, T.untyped], prefix: String).returns(T::Hash[String, Integer]) }
-      def self.parse_hash(obj, prefix = DEFAULT_PREFIX)
-        obj["metrics"].each_with_object(Hash.new(0)) do |metric, metrics|
-          name = metric["name"]
-          name = name.sub(prefix, '')
-          metrics[name] = metric["value"] || 0
+        sig { params(obj: T::Hash[String, T.untyped], prefix: String).returns(T::Hash[String, Integer]) }
+        def parse_hash(obj, prefix = DEFAULT_PREFIX)
+          obj["metrics"].each_with_object(Hash.new(0)) do |metric, metrics|
+            name = metric["name"]
+            name = name.sub(prefix, "")
+            metrics[name] = metric["value"] || 0
+          end
         end
       end
     end

data/lib/spoom/sorbet/sigils.rb

@@ -27,70 +27,75 @@ module Spoom
 
       SIGIL_REGEXP = T.let(/^#[\ t]*typed[\ t]*:[ \t]*(\w*)[ \t]*/.freeze, Regexp)
 
-      # returns the full sigil comment string for the passed strictness
-      sig { params(strictness: String).returns(String) }
-      def self.sigil_string(strictness)
-        "# typed: #{strictness}"
-      end
+      class << self
+        extend T::Sig
 
-      # returns true if the passed string is a valid strictness (else false)
-      sig { params(strictness: String).returns(T::Boolean) }
-      def self.valid_strictness?(strictness)
-        VALID_STRICTNESS.include?(strictness.strip)
-      end
+        # returns the full sigil comment string for the passed strictness
+        sig { params(strictness: String).returns(String) }
+        def sigil_string(strictness)
+          "# typed: #{strictness}"
+        end
 
-      # returns the strictness of a sigil in the passed file content string (nil if no sigil)
-      sig { params(content: String).returns(T.nilable(String)) }
-      def self.strictness_in_content(content)
-        SIGIL_REGEXP.match(content)&.[](1)
-      end
+        # returns true if the passed string is a valid strictness (else false)
+        sig { params(strictness: String).returns(T::Boolean) }
+        def valid_strictness?(strictness)
+          VALID_STRICTNESS.include?(strictness.strip)
+        end
 
-      # returns a string which is the passed content but with the sigil updated to a new strictness
-      sig { params(content: String, new_strictness: String).returns(String) }
-      def self.update_sigil(content, new_strictness)
-        content.sub(SIGIL_REGEXP, sigil_string(new_strictness))
-      end
+        # returns the strictness of a sigil in the passed file content string (nil if no sigil)
+        sig { params(content: String).returns(T.nilable(String)) }
+        def strictness_in_content(content)
+          SIGIL_REGEXP.match(content)&.[](1)
+        end
 
-      # returns a string containing the strictness of a sigil in a file at the passed path
-      # * returns nil if no sigil
-      sig { params(path: T.any(String, Pathname)).returns(T.nilable(String)) }
-      def self.file_strictness(path)
-        return nil unless File.file?(path)
-        content = File.read(path, encoding: Encoding::ASCII_8BIT)
-        strictness_in_content(content)
-      end
+        # returns a string which is the passed content but with the sigil updated to a new strictness
+        sig { params(content: String, new_strictness: String).returns(String) }
+        def update_sigil(content, new_strictness)
+          content.sub(SIGIL_REGEXP, sigil_string(new_strictness))
+        end
 
-      # changes the sigil in the file at the passed path to the specified new strictness
-      sig { params(path: T.any(String, Pathname), new_strictness: String).returns(T::Boolean) }
-      def self.change_sigil_in_file(path, new_strictness)
-        content = File.read(path, encoding: Encoding::ASCII_8BIT)
-        new_content = update_sigil(content, new_strictness)
+        # returns a string containing the strictness of a sigil in a file at the passed path
+        # * returns nil if no sigil
+        sig { params(path: T.any(String, Pathname)).returns(T.nilable(String)) }
+        def file_strictness(path)
+          return nil unless File.file?(path)
 
-        File.write(path, new_content, encoding: Encoding::ASCII_8BIT)
+          content = File.read(path, encoding: Encoding::ASCII_8BIT)
+          strictness_in_content(content)
+        end
 
-        strictness_in_content(new_content) == new_strictness
-      end
+        # changes the sigil in the file at the passed path to the specified new strictness
+        sig { params(path: T.any(String, Pathname), new_strictness: String).returns(T::Boolean) }
+        def change_sigil_in_file(path, new_strictness)
+          content = File.read(path, encoding: Encoding::ASCII_8BIT)
+          new_content = update_sigil(content, new_strictness)
 
-      # changes the sigil to have a new strictness in a list of files
-      sig { params(path_list: T::Array[String], new_strictness: String).returns(T::Array[String]) }
-      def self.change_sigil_in_files(path_list, new_strictness)
-        path_list.filter do |path|
-          change_sigil_in_file(path, new_strictness)
+          File.write(path, new_content, encoding: Encoding::ASCII_8BIT)
+
+          strictness_in_content(new_content) == new_strictness
         end
-      end
 
-      # finds all files in the specified directory with the passed strictness
-      sig do
-        params(
-          directory: T.any(String, Pathname),
-          strictness: String,
-          extension: String
-        ).returns(T::Array[String])
-      end
-      def self.files_with_sigil_strictness(directory, strictness, extension: ".rb")
-        paths = Dir.glob("#{File.expand_path(directory)}/**/*#{extension}").sort.uniq
-        paths.filter do |path|
-          file_strictness(path) == strictness
+        # changes the sigil to have a new strictness in a list of files
+        sig { params(path_list: T::Array[String], new_strictness: String).returns(T::Array[String]) }
+        def change_sigil_in_files(path_list, new_strictness)
+          path_list.filter do |path|
+            change_sigil_in_file(path, new_strictness)
+          end
+        end
+
+        # finds all files in the specified directory with the passed strictness
+        sig do
+          params(
+            directory: T.any(String, Pathname),
+            strictness: String,
+            extension: String,
+          ).returns(T::Array[String])
+        end
+        def files_with_sigil_strictness(directory, strictness, extension: ".rb")
+          paths = Dir.glob("#{File.expand_path(directory)}/**/*#{extension}").sort.uniq
+          paths.filter do |path|
+            file_strictness(path) == strictness
+          end
         end
       end
     end

data/lib/spoom/sorbet.rb

@@ -25,10 +25,10 @@ module Spoom
           arg: String,
           path: String,
           capture_err: T::Boolean,
-          sorbet_bin: T.nilable(String)
+          sorbet_bin: T.nilable(String),
         ).returns(ExecResult)
       end
-      def srb(*arg, path: '.', capture_err: false, sorbet_bin: nil)
+      def srb(*arg, path: ".", capture_err: false, sorbet_bin: nil)
         if sorbet_bin
           arg.prepend(sorbet_bin)
         else
@@ -42,20 +42,20 @@ module Spoom
           arg: String,
           path: String,
           capture_err: T::Boolean,
-          sorbet_bin: T.nilable(String)
+          sorbet_bin: T.nilable(String),
         ).returns(ExecResult)
       end
-      def srb_tc(*arg, path: '.', capture_err: false, sorbet_bin: nil)
+      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: '.')
+      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|
+        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
@@ -65,19 +65,20 @@ module Spoom
           arg: String,
           path: String,
           capture_err: T::Boolean,
-          sorbet_bin: T.nilable(String)
+          sorbet_bin: T.nilable(String),
         ).returns(T.nilable(String))
       end
-      def srb_version(*arg, path: '.', capture_err: false, sorbet_bin: nil)
+      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
+          sorbet_bin: sorbet_bin,
         ), ExecResult)
         return nil unless result.status
+
         result.out.split(" ")[2]
       end
 
@@ -86,10 +87,10 @@ module Spoom
           arg: String,
           path: String,
           capture_err: T::Boolean,
-          sorbet_bin: T.nilable(String)
+          sorbet_bin: T.nilable(String),
         ).returns(T.nilable(T::Hash[String, Integer]))
       end
-      def srb_metrics(*arg, path: '.', capture_err: false, sorbet_bin: nil)
+      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(
@@ -98,7 +99,7 @@ module Spoom
           *arg,
           path: path,
           capture_err: capture_err,
-          sorbet_bin: sorbet_bin
+          sorbet_bin: sorbet_bin,
         )
         if File.exist?(metrics_path)
           metrics = Spoom::Sorbet::MetricsParser.parse_file(metrics_path)
@@ -112,11 +113,13 @@ module Spoom
       #
       # 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: '.')
+      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
+
         content[1]
       end
     end

data/lib/spoom/timeline.rb

@@ -15,7 +15,7 @@ module Spoom
     end
 
     # Return one commit for each month between `from` and `to`
-    sig { returns(T::Array[String]) }
+    sig { returns(T::Array[Git::Commit]) }
     def ticks
       commits_for_dates(months)
     end
@@ -34,20 +34,21 @@ module Spoom
     end
 
     # Return one commit for each date in `dates`
-    sig { params(dates: T::Array[Time]).returns(T::Array[String]) }
+    sig { params(dates: T::Array[Time]).returns(T::Array[Git::Commit]) }
     def commits_for_dates(dates)
       dates.map do |t|
         result = Spoom::Git.log(
           "--since='#{t}'",
           "--until='#{t.to_date.next_month}'",
-          "--format='format:%h'",
+          "--format='format:%h %at'",
           "--author-date-order",
           "-1",
           path: @path,
         )
         next if result.out.empty?
-        result.out
-      end.compact.uniq
+
+        Git.parse_commit(result.out.strip)
+      end.compact.uniq(&:sha)
     end
   end
 end

data/lib/spoom/version.rb

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

data/lib/spoom.rb

@@ -12,41 +12,59 @@ module Spoom
   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
-  end
 
-  sig do
-    params(
-      cmd: String,
-      arg: String,
-      path: String,
-      capture_err: T::Boolean
-    ).returns(ExecResult)
+    sig { returns(String) }
+    def to_s
+      <<~STR
+        ########## STDOUT ##########
+        #{out.empty? ? "<empty>" : out}
+        ########## STDERR ##########
+        #{err.empty? ? "<empty>" : err}
+        ########## STATUS: #{status} ##########
+      STR
+    end
   end
-  def self.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
-      )
+
+  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"
 require "spoom/colors"
 require "spoom/sorbet"
 require "spoom/cli"