spoom 1.0.3 → 1.0.4

data/lib/spoom/config.rb

@@ -0,0 +1,11 @@
+# typed: true
+# frozen_string_literal: true
+
+module Spoom
+  module Config
+    SORBET_CONFIG = "sorbet/config"
+    SORBET_GEM_PATH = Gem::Specification.find_by_name("sorbet-static").full_gem_path
+    SORBET_PATH = (Pathname.new(SORBET_GEM_PATH) / "libexec" / "sorbet").to_s
+    WORKSPACE_PATH = (Pathname.new(ENV['BUNDLE_GEMFILE']) / "..").to_s
+  end
+end

data/lib/spoom/sorbet.rb

@@ -0,0 +1,70 @@
+# typed: true
+# frozen_string_literal: true
+
+require "spoom/sorbet/config"
+require "spoom/sorbet/errors"
+require "spoom/sorbet/lsp"
+require "spoom/sorbet/metrics"
+
+require "open3"
+
+module Spoom
+  module Sorbet
+    extend T::Sig
+
+    sig { params(arg: String, path: String, capture_err: T::Boolean).returns([String, T::Boolean]) }
+    def self.srb(*arg, path: '.', capture_err: false)
+      opts = {}
+      opts[:chdir] = path
+      out = T.let("", T.nilable(String))
+      res = T.let(false, T::Boolean)
+      if capture_err
+        Open3.popen2e(["bundle", "exec", "srb", *arg].join(" "), opts) do |_, o, t|
+          out = o.read
+          res = T.cast(t.value, Process::Status).success?
+        end
+      else
+        Open3.popen2(["bundle", "exec", "srb", *arg].join(" "), opts) do |_, o, t|
+          out = o.read
+          res = T.cast(t.value, Process::Status).success?
+        end
+      end
+      [out || "", res]
+    end
+
+    sig { params(arg: String, path: String, capture_err: T::Boolean).returns([String, T::Boolean]) }
+    def self.srb_tc(*arg, path: '.', capture_err: false)
+      srb(*T.unsafe(["tc", *arg]), path: path, capture_err: capture_err)
+    end
+
+    # List all files typechecked by Sorbet from its `config`
+    sig { params(config: Config, path: String).returns(T::Array[String]) }
+    def self.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 { params(arg: String, path: String, capture_err: T::Boolean).returns(T.nilable(String)) }
+    def self.srb_version(*arg, path: '.', capture_err: false)
+      out, res = srb(*T.unsafe(["--version", *arg]), path: path, capture_err: capture_err)
+      return nil unless res
+      out.split(" ")[2]
+    end
+
+    sig { params(arg: String, path: String, capture_err: T::Boolean).returns(T.nilable(Metrics)) }
+    def self.srb_metrics(*arg, path: '.', capture_err: false)
+      metrics_file = "metrics.tmp"
+      metrics_path = "#{path}/#{metrics_file}"
+      srb_tc(*T.unsafe(["--metrics-file=#{metrics_file}", *arg]), path: path, capture_err: capture_err)
+      if File.exist?(metrics_path)
+        metrics = Spoom::Sorbet::Metrics.parse_file(metrics_path)
+        File.delete(metrics_path)
+        return metrics
+      end
+      nil
+    end
+  end
+end

data/lib/spoom/sorbet/config.rb

@@ -27,12 +27,13 @@ module Spoom
       extend T::Sig
 
       sig { returns(T::Array[String]) }
-      attr_reader :paths, :ignore
+      attr_reader :paths, :ignore, :allowed_extensions
 
       sig { void }
       def initialize
         @paths = T.let([], T::Array[String])
         @ignore = T.let([], T::Array[String])
+        @allowed_extensions = T.let([], T::Array[String])
       end
 
       class << self
@@ -46,13 +47,21 @@ module Spoom
         sig { params(sorbet_config: String).returns(Spoom::Sorbet::Config) }
         def parse_string(sorbet_config)
           config = Config.new
-          ignore = T.let(false, T::Boolean)
-          skip = T.let(false, T::Boolean)
+          state = T.let(nil, T.nilable(Symbol))
           sorbet_config.each_line do |line|
             line = line.strip
             case line
+            when /^--allowed-extension$/
+              state = :extension
+              next
+            when /^--allowed-extension=/
+              config.allowed_extensions << parse_option(line)
+              next
+            when /^--ignore=/
+              config.ignore << parse_option(line)
+              next
             when /^--ignore$/
-              ignore = true
+              state = :ignore
               next
             when /^--ignore=/
               config.ignore << parse_option(line)
@@ -70,18 +79,21 @@ module Spoom
             when /^--.*=/
               next
             when /^--/
-              skip = true
+              state = :skip
             when /^-.*=?/
               next
             else
-              if ignore
+              case state
+              when :ignore
                 config.ignore << line
-                ignore = false
-              elsif skip
-                skip = false
+              when :extension
+                config.allowed_extensions << line
+              when :skip
+                # nothing
               else
                 config.paths << line
               end
+              state = nil
             end
           end
           config

data/lib/spoom/sorbet/errors.rb

@@ -0,0 +1,129 @@
+# typed: true
+# frozen_string_literal: true
+
+module Spoom
+  module Sorbet
+    module Errors
+      # Parse errors from Sorbet output
+      class Parser
+        extend T::Sig
+
+        HEADER = [
+          "👋 Hey there! Heads up that this is not a release build of sorbet.",
+          "Release builds are faster and more well-supported by the Sorbet team.",
+          "Check out the README to learn how to build Sorbet in release mode.",
+          "To forcibly silence this error, either pass --silence-dev-message,",
+          "or set SORBET_SILENCE_DEV_MESSAGE=1 in your shell environment.",
+        ]
+
+        sig { params(output: String).returns(T::Array[Error]) }
+        def self.parse_string(output)
+          parser = Spoom::Sorbet::Errors::Parser.new
+          parser.parse(output)
+        end
+
+        sig { void }
+        def initialize
+          @errors = []
+          @current_error = nil
+        end
+
+        sig { params(output: String).returns(T::Array[Error]) }
+        def parse(output)
+          output.each_line do |line|
+            break if /^No errors! Great job\./.match?(line)
+            break if /^Errors: /.match?(line)
+            next if HEADER.include?(line.strip)
+
+            next if line == "\n"
+
+            if leading_spaces(line) == 0
+              close_error if @current_error
+              open_error(line)
+              next
+            end
+
+            append_error(line) if @current_error
+          end
+          close_error if @current_error
+          @errors
+        end
+
+        private
+
+        sig { params(line: String).returns(T.nilable(Integer)) }
+        def leading_spaces(line)
+          line.index(/[^ ]/)
+        end
+
+        sig { params(line: String).void }
+        def open_error(line)
+          raise "Error: Already parsing an error!" if @current_error
+          @current_error = Error.from_error_line(line)
+        end
+
+        sig { void }
+        def close_error
+          raise "Error: Not already parsing an error!" unless @current_error
+          @errors << @current_error
+          @current_error = nil
+        end
+
+        sig { params(line: String).void }
+        def append_error(line)
+          raise "Error: Not already parsing an error!" unless @current_error
+          @current_error.more << line
+        end
+      end
+
+      class Error
+        include Comparable
+        extend T::Sig
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :file, :message
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :line, :code
+
+        sig { returns(T::Array[String]) }
+        attr_reader :more
+
+        sig do
+          params(
+            file: T.nilable(String),
+            line: T.nilable(Integer),
+            message: T.nilable(String),
+            code: T.nilable(Integer),
+            more: T::Array[String]
+          ).void
+        end
+        def initialize(file, line, message, code, more = [])
+          @file = file
+          @line = line
+          @message = message
+          @code = code
+          @more = more
+        end
+
+        sig { params(line: String).returns(Error) }
+        def self.from_error_line(line)
+          file, line, rest = line.split(/: ?/, 3)
+          message, code = rest&.split(%r{ https://srb\.help/}, 2)
+          Error.new(file, line&.to_i, message, code&.to_i)
+        end
+
+        sig { params(other: T.untyped).returns(Integer) }
+        def <=>(other)
+          return 0 unless other.is_a?(Error)
+          [file, line, code, message] <=> [other.file, other.line, other.code, other.message]
+        end
+
+        sig { returns(String) }
+        def to_s
+          "#{file}:#{line}: #{message} (#{code})"
+        end
+      end
+    end
+  end
+end

data/lib/spoom/sorbet/lsp.rb

@@ -0,0 +1,194 @@
+# typed: true
+# frozen_string_literal: true
+
+require 'open3'
+require 'json'
+
+require_relative 'lsp/base'
+require_relative 'lsp/structures'
+require_relative 'lsp/errors'
+
+module Spoom
+  module LSP
+    class Client
+      def initialize(sorbet_cmd, *sorbet_args)
+        @id = 0
+        Bundler.with_clean_env do
+          @in, @out, @err, @status = Open3.popen3([sorbet_cmd, *sorbet_args].join(" "))
+        end
+      end
+
+      def next_id
+        @id += 1
+      end
+
+      def send_raw(json_string)
+        @in.puts("Content-Length:#{json_string.length}\r\n\r\n#{json_string}")
+      end
+
+      def send(message)
+        send_raw(message.to_json)
+        read if message.is_a?(Request)
+      end
+
+      def read_raw
+        header = @out.gets
+
+        # Sorbet returned an error and forgot to answer
+        raise Error::BadHeaders, "bad response headers" unless header&.match?(/Content-Length: /)
+
+        len = header.slice(::Range.new(16, nil)).to_i
+        @out.read(len + 2) # +2 'cause of the final \r\n
+      end
+
+      def read
+        json = JSON.parse(read_raw)
+
+        # Handle error in the LSP protocol
+        raise ResponseError.from_json(json['error']) if json['error']
+
+        # Handle typechecking errors
+        raise Error::Diagnostics.from_json(json['params']) if json['method'] == "textDocument/publishDiagnostics"
+
+        json
+      end
+
+      # LSP requests
+
+      def open(workspace_path)
+        raise Error::AlreadyOpen, "Error: CLI already opened" if @open
+        send(Request.new(
+          next_id,
+          'initialize',
+          {
+            'rootPath' => workspace_path,
+            'rootUri' => "file://#{workspace_path}",
+            'capabilities' => {},
+          },
+        ))
+        send(Notification.new('initialized', {}))
+        @open = true
+      end
+
+      def hover(uri, line, column)
+        json = send(Request.new(
+          next_id,
+          'textDocument/hover',
+          {
+            'textDocument' => {
+              'uri' => uri,
+            },
+            'position' => {
+              'line' => line,
+              'character' => column,
+            },
+          }
+        ))
+        return nil unless json['result']
+        Hover.from_json(json['result'])
+      end
+
+      def signatures(uri, line, column)
+        json = send(Request.new(
+          next_id,
+          'textDocument/signatureHelp',
+          {
+            'textDocument' => {
+              'uri' => uri,
+            },
+            'position' => {
+              'line' => line,
+              'character' => column,
+            },
+          }
+        ))
+        json['result']['signatures'].map { |loc| SignatureHelp.from_json(loc) }
+      end
+
+      def definitions(uri, line, column)
+        json = send(Request.new(
+          next_id,
+          'textDocument/definition',
+          {
+            'textDocument' => {
+              'uri' => uri,
+            },
+            'position' => {
+              'line' => line,
+              'character' => column,
+            },
+          }
+        ))
+        json['result'].map { |loc| Location.from_json(loc) }
+      end
+
+      def type_definitions(uri, line, column)
+        json = send(Request.new(
+          next_id,
+          'textDocument/typeDefinition',
+          {
+            'textDocument' => {
+              'uri' => uri,
+            },
+            'position' => {
+              'line' => line,
+              'character' => column,
+            },
+          }
+        ))
+        json['result'].map { |loc| Location.from_json(loc) }
+      end
+
+      def references(uri, line, column, include_decl = true)
+        json = send(Request.new(
+          next_id,
+          'textDocument/references',
+          {
+            'textDocument' => {
+              'uri' => uri,
+            },
+            'position' => {
+              'line' => line,
+              'character' => column,
+            },
+            'context' => {
+              'includeDeclaration' => include_decl,
+            },
+          }
+        ))
+        json['result'].map { |loc| Location.from_json(loc) }
+      end
+
+      def symbols(query)
+        json = send(Request.new(
+          next_id,
+          'workspace/symbol',
+          {
+            'query' => query,
+          }
+        ))
+        json['result'].map { |loc| DocumentSymbol.from_json(loc) }
+      end
+
+      def document_symbols(uri)
+        json = send(Request.new(
+          next_id,
+          'textDocument/documentSymbol',
+          {
+            'textDocument' => {
+              'uri' => uri,
+            },
+          }
+        ))
+        json['result'].map { |loc| DocumentSymbol.from_json(loc) }
+      end
+
+      def close
+        send(Request.new(next_id, "shutdown", nil))
+        @in.close
+        @out.close
+        @err.close
+      end
+    end
+  end
+end