spoom 1.0.4 → 1.0.9

data/lib/spoom/cli/commands/lsp.rb

@@ -1,156 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require 'shellwords'
-
-require_relative "base"
-require_relative "../symbol_printer"
-require_relative "../../sorbet/lsp"
-
-module Spoom
-  module Cli
-    module Commands
-      class LSP < Base
-        default_task :show
-
-        desc "interactive", "interactive LSP mode"
-        def show
-          in_sorbet_project!
-          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|
-            Dir["**/*.rb"].each do |file|
-              res = client.document_symbols(file.to_uri)
-              next if res.empty?
-              puts "Symbols from `#{file}`:"
-              SymbolPrinter.print_object(res, options["no_color"])
-            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(file.to_uri, line.to_i, col.to_i)
-            say "Hovering `#{file}:#{line}:#{col}`:"
-            if res
-              SymbolPrinter.print_object(res, options["no_color"])
-            else
-              puts "<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(file.to_uri, line.to_i, col.to_i)
-            puts "Definitions for `#{file}:#{line}:#{col}`:"
-            SymbolPrinter.print_list(res, options["no_color"])
-          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)
-            puts "Symbols matching `#{query}`:"
-            printer = SymbolPrinter.new(2, options["no_color"])
-            res.each do |symbol|
-              next if symbol.location.uri.start_with?("https")
-              printer.visit(symbol)
-            end
-          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(file.to_uri)
-            puts "Symbols from `#{file}`:"
-            SymbolPrinter.print_object(res, options["no_color"])
-          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(file.to_uri, line.to_i, col.to_i)
-            puts "References to `#{file}:#{line}:#{col}`:"
-            SymbolPrinter.print_list(res, options["no_color"])
-          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(file.to_uri, line.to_i, col.to_i)
-            puts "Signature for `#{file}:#{line}:#{col}`:"
-            SymbolPrinter.print_list(res, options["no_color"])
-          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(file.to_uri, line.to_i, col.to_i)
-            say "Type for `#{file}:#{line}:#{col}`:"
-            SymbolPrinter.print_list(res, options["no_color"])
-          end
-        end
-
-        no_commands do
-          def lsp_client
-            in_sorbet_project!
-            client = Spoom::LSP::Client.new(
-              Spoom::Config::SORBET_PATH,
-              "--lsp",
-              "--enable-all-experimental-lsp-features",
-              "--disable-watchman",
-            )
-            client.open(Spoom::Config::WORKSPACE_PATH)
-            client
-          end
-
-          def run(&block)
-            client = lsp_client
-            block.call(client)
-          rescue Spoom::LSP::Error::Diagnostics => err
-            say_error("Sorbet returned typechecking errors for `#{err.uri.from_uri}`")
-            err.diagnostics.each do |d|
-              say_error("#{d.message} (#{d.code})", "  #{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
-        end
-      end
-    end
-  end
-end

data/lib/spoom/cli/commands/run.rb

@@ -1,92 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require_relative "base"
-
-module Spoom
-  module Cli
-    module Commands
-      class Run < Base
-        default_task :tc
-
-        desc "tc", "run srb tc"
-        option :limit, type: :numeric, aliases: :l
-        option :code, type: :numeric, aliases: :c
-        option :sort, type: :string, aliases: :s
-        def tc
-          in_sorbet_project!
-
-          limit = options[:limit]
-          sort = options[:sort]
-          code = options[:code]
-          colors = !options[:no_color]
-
-          unless limit || code || sort
-            return Spoom::Sorbet.srb_tc(capture_err: false).last
-          end
-
-          output, status = Spoom::Sorbet.srb_tc(capture_err: true)
-          if status
-            $stderr.print(output)
-            return 0
-          end
-
-          errors = Spoom::Sorbet::Errors::Parser.parse_string(output)
-          errors_count = errors.size
-
-          errors = sort == "code" ? errors.sort_by { |e| [e.code, e.file, e.line, e.message] } : errors.sort
-          errors = errors.select { |e| e.code == code } if code
-          errors = T.must(errors.slice(0, limit)) if limit
-
-          errors.each do |e|
-            code = colorize_code(e.code, colors)
-            message = colorize_message(e.message, colors)
-            $stderr.puts "#{code} - #{e.file}:#{e.line}: #{message}"
-          end
-
-          if errors_count == errors.size
-            $stderr.puts "Errors: #{errors_count}"
-          else
-            $stderr.puts "Errors: #{errors.size} shown, #{errors_count} total"
-          end
-
-          1
-        end
-
-        desc "metrics", "run srb tc and display metrics"
-        def metrics
-          in_sorbet_project!
-
-          metrics = Spoom::Sorbet.srb_metrics(capture_err: false)
-          if metrics
-            metrics.show
-          else
-            puts "no data"
-          end
-        end
-
-        no_commands do
-          def colorize_code(code, colors = true)
-            return code.to_s unless colors
-            code.to_s.light_black
-          end
-
-          def colorize_message(message, colors = true)
-            return message unless colors
-
-            cyan = T.let(false, T::Boolean)
-            word = StringIO.new
-            message.chars.each do |c|
-              if c == '`'
-                cyan = !cyan
-                next
-              end
-              word << (cyan ? c.cyan : c.red)
-            end
-            word.string
-          end
-        end
-      end
-    end
-  end
-end

data/lib/spoom/cli/symbol_printer.rb

@@ -1,71 +0,0 @@
-# typed: true
-# frozen_string_literal: true
-
-require "colorize"
-
-module Spoom
-  module Cli
-    class SymbolPrinter
-      attr_accessor :seen, :no_color
-
-      def self.print_list(list, no_color)
-        printer = SymbolPrinter.new(2, no_color)
-        list.each do |item|
-          printer.print(" * ")
-          printer.visit(item)
-          printer.printn
-        end
-      end
-
-      def self.print_object(object, no_color)
-        printer = SymbolPrinter.new(2, no_color)
-        printer.visit(object)
-      end
-
-      def initialize(default_indent, no_color = false)
-        @seen = Set.new
-        @current_indent = default_indent
-        @no_color = no_color
-        String.disable_colorization = no_color
-      end
-
-      def indent
-        @current_indent += 2
-      end
-
-      def dedent
-        @current_indent -= 2
-      end
-
-      def print(string)
-        Kernel.print(string)
-      end
-
-      def printn
-        print("\n")
-      end
-
-      def printt
-        print(" " * @current_indent)
-      end
-
-      def visit(object)
-        if object.is_a?(Array)
-          object.each { |e| visit(e) }
-        else
-          object.accept_printer(self)
-        end
-      end
-    end
-  end
-end
-
-class String
-  def to_uri
-    "file://" + File.join(Spoom::Config::WORKSPACE_PATH, self)
-  end
-
-  def from_uri
-    sub("file://#{Spoom::Config::WORKSPACE_PATH}", "")
-  end
-end

data/lib/spoom/config.rb

@@ -1,11 +0,0 @@
-# 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