spoom 1.2.4 → 1.3.0

data/lib/spoom/cli/lsp.rb

@@ -1,168 +0,0 @@
-# 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
-        context_requiring_sorbet!
-
-        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?
-
-            say("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
-            say("<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)
-          say("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") }
-          say("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))
-          say("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)
-          say("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)
-          say("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
-          context_requiring_sorbet!
-
-          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})", status: "  #{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

data/lib/spoom/cli/run.rb

@@ -1,148 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-module Spoom
-  module Cli
-    class Run < Thor
-      include Helper
-
-      default_task :tc
-
-      SORT_CODE = "code"
-      SORT_LOC = "loc"
-      SORT_ENUM = [SORT_CODE, SORT_LOC]
-
-      DEFAULT_FORMAT = "%C - %F:%L: %M"
-
-      desc "tc", "Run `srb tc`"
-      option :limit, type: :numeric, aliases: :l, desc: "Limit displayed errors"
-      option :code, type: :numeric, aliases: :c, desc: "Filter displayed errors by code"
-      option :sort, type: :string, aliases: :s, desc: "Sort errors", enum: SORT_ENUM, default: SORT_LOC
-      option :format, type: :string, aliases: :f, desc: "Format line output"
-      option :uniq, type: :boolean, aliases: :u, desc: "Remove duplicated lines"
-      option :count, type: :boolean, default: true, desc: "Show errors count"
-      option :sorbet, type: :string, desc: "Path to custom Sorbet bin"
-      option :sorbet_options, type: :string, default: "", desc: "Pass options to Sorbet"
-      def tc(*paths_to_select)
-        context = context_requiring_sorbet!
-        limit = options[:limit]
-        sort = options[:sort]
-        code = options[:code]
-        uniq = options[:uniq]
-        format = options[:format]
-        count = options[:count]
-        sorbet = options[:sorbet]
-
-        unless limit || code || sort
-          result = T.unsafe(context).srb_tc(
-            *options[:sorbet_options].split(" "),
-            capture_err: false,
-            sorbet_bin: sorbet,
-          )
-
-          say_error(result.err, status: nil, nl: false)
-          exit(result.status)
-        end
-
-        error_url_base = Spoom::Sorbet::Errors::DEFAULT_ERROR_URL_BASE
-        result = T.unsafe(context).srb_tc(
-          *options[:sorbet_options].split(" "),
-          "--error-url-base=#{error_url_base}",
-          capture_err: true,
-          sorbet_bin: sorbet,
-        )
-
-        if result.status
-          say_error(result.err, status: nil, nl: false)
-          exit(0)
-        end
-
-        unless result.exit_code == 100
-          # Sorbet will return exit code 100 if there are type checking errors.
-          # If Sorbet returned something else, it means it didn't terminate normally.
-          say_error(result.err, status: nil, nl: false)
-          exit(1)
-        end
-
-        errors = Spoom::Sorbet::Errors::Parser.parse_string(result.err, error_url_base: error_url_base)
-        errors_count = errors.size
-
-        errors = errors.select { |e| e.code == code } if code
-
-        unless paths_to_select.empty?
-          errors.select! do |error|
-            paths_to_select.any? { |path_to_select| error.file&.start_with?(path_to_select) }
-          end
-        end
-
-        errors = case sort
-        when SORT_CODE
-          Spoom::Sorbet::Errors.sort_errors_by_code(errors)
-        when SORT_LOC
-          errors.sort
-        else
-          errors # preserve natural sort
-        end
-
-        errors = T.must(errors.slice(0, limit)) if limit
-
-        lines = errors.map { |e| format_error(e, format || DEFAULT_FORMAT) }
-        lines = lines.uniq if uniq
-
-        lines.each do |line|
-          say_error(line, status: nil)
-        end
-
-        if count
-          if errors_count == errors.size
-            say_error("Errors: #{errors_count}", status: nil)
-          else
-            say_error("Errors: #{errors.size} shown, #{errors_count} total", status: nil)
-          end
-        end
-
-        exit(1)
-      rescue Spoom::Sorbet::Error::Segfault => error
-        say_error(<<~ERR, status: nil)
-          #{red("!!! Sorbet exited with code #{error.result.exit_code} - SEGFAULT !!!")}
-
-          This is most likely related to a bug in Sorbet.
-        ERR
-
-        exit(error.result.exit_code)
-      rescue Spoom::Sorbet::Error::Killed => error
-        say_error(<<~ERR, status: nil)
-          #{red("!!! Sorbet exited with code #{error.result.exit_code} - KILLED !!!")}
-        ERR
-
-        exit(error.result.exit_code)
-      end
-
-      no_commands do
-        def format_error(error, format)
-          line = format
-          line = line.gsub(/%C/, yellow(error.code.to_s))
-          line = line.gsub(/%F/, error.file)
-          line = line.gsub(/%L/, error.line.to_s)
-          line = line.gsub(/%M/, colorize_message(error.message))
-          line
-        end
-
-        def colorize_message(message)
-          return message unless color?
-
-          cyan = T.let(false, T::Boolean)
-          word = StringIO.new
-          message.chars.each do |c|
-            if c == "`"
-              cyan = !cyan
-              next
-            end
-            word << (cyan ? cyan(c) : red(c))
-          end
-          word.string
-        end
-      end
-    end
-  end
-end