spoom 1.0.4 → 1.0.9

data/lib/spoom/sorbet/lsp.rb

@@ -11,11 +11,9 @@ require_relative 'lsp/errors'
 module Spoom
   module LSP
     class Client
-      def initialize(sorbet_cmd, *sorbet_args)
+      def initialize(sorbet_bin, *sorbet_args, path: ".")
         @id = 0
-        Bundler.with_clean_env do
-          @in, @out, @err, @status = Open3.popen3([sorbet_cmd, *sorbet_args].join(" "))
-        end
+        @in, @out, @err, @status = T.unsafe(Open3).popen3(sorbet_bin, *sorbet_args, chdir: path)
       end
 
       def next_id

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

@@ -1,9 +1,24 @@
 # typed: true
 # frozen_string_literal: true
 
+require_relative "../../printer"
+
 module Spoom
   module LSP
+    module PrintableSymbol
+      extend T::Sig
+      extend T::Helpers
+
+      interface!
+
+      sig { abstract.params(printer: SymbolPrinter).void }
+      def accept_printer(printer); end
+    end
+
     class Hover < T::Struct
+      extend T::Sig
+      include PrintableSymbol
+
       const :contents, String
       const :range, T.nilable(Range)
 
@@ -14,9 +29,10 @@ module Spoom
         )
       end
 
+      sig { override.params(printer: SymbolPrinter).void }
       def accept_printer(printer)
         printer.print("#{contents}\n")
-        printer.visit(range) if range
+        printer.print_object(range) if range
       end
 
       def to_s
@@ -25,6 +41,9 @@ module Spoom
     end
 
     class Position < T::Struct
+      extend T::Sig
+      include PrintableSymbol
+
       const :line, Integer
       const :char, Integer
 
@@ -35,8 +54,9 @@ module Spoom
         )
       end
 
+      sig { override.params(printer: SymbolPrinter).void }
       def accept_printer(printer)
-        printer.print("#{line}:#{char}".light_black)
+        printer.print_colored("#{line}:#{char}", :light_black)
       end
 
       def to_s
@@ -45,6 +65,9 @@ module Spoom
     end
 
     class Range < T::Struct
+      extend T::Sig
+      include PrintableSymbol
+
       const :start, Position
       const :end, Position
 
@@ -55,10 +78,11 @@ module Spoom
         )
       end
 
+      sig { override.params(printer: SymbolPrinter).void }
       def accept_printer(printer)
-        printer.visit(start)
-        printer.print("-".light_black)
-        printer.visit(self.end)
+        printer.print_object(start)
+        printer.print_colored("-", :light_black)
+        printer.print_object(self.end)
       end
 
       def to_s
@@ -67,6 +91,9 @@ module Spoom
     end
 
     class Location < T::Struct
+      extend T::Sig
+      include PrintableSymbol
+
       const :uri, String
       const :range, LSP::Range
 
@@ -77,17 +104,21 @@ module Spoom
         )
       end
 
+      sig { override.params(printer: SymbolPrinter).void }
       def accept_printer(printer)
-        printer.print("#{uri.from_uri}:".light_black)
-        printer.visit(range)
+        printer.print_colored("#{printer.clean_uri(uri)}:", :light_black)
+        printer.print_object(range)
       end
 
       def to_s
-        "#{uri}:#{range})."
+        "#{uri}:#{range}"
       end
     end
 
     class SignatureHelp < T::Struct
+      extend T::Sig
+      include PrintableSymbol
+
       const :label, T.nilable(String)
       const :doc, Object # TODO
       const :params, T::Array[T.untyped] # TODO
@@ -100,6 +131,7 @@ module Spoom
         )
       end
 
+      sig { override.params(printer: SymbolPrinter).void }
       def accept_printer(printer)
         printer.print(label)
         printer.print("(")
@@ -113,6 +145,9 @@ module Spoom
     end
 
     class Diagnostic < T::Struct
+      extend T::Sig
+      include PrintableSymbol
+
       const :range, LSP::Range
       const :code, Integer
       const :message, String
@@ -127,12 +162,20 @@ module Spoom
         )
       end
 
+      sig { override.params(printer: SymbolPrinter).void }
+      def accept_printer(printer)
+        printer.print(to_s)
+      end
+
       def to_s
         "Error: #{message} (#{code})."
       end
     end
 
     class DocumentSymbol < T::Struct
+      extend T::Sig
+      include PrintableSymbol
+
       const :name, String
       const :detail, T.nilable(String)
       const :kind, Integer
@@ -151,6 +194,7 @@ module Spoom
         )
       end
 
+      sig { override.params(printer: SymbolPrinter).void }
       def accept_printer(printer)
         h = serialize.hash
         return if printer.seen.include?(h)
@@ -159,18 +203,18 @@ module Spoom
         printer.printt
         printer.print(kind_string)
         printer.print(' ')
-        printer.print(name.blue.bold)
-        printer.print(' ('.light_black)
+        printer.print_colored(name, :blue, :bold)
+        printer.print_colored(' (', :light_black)
         if range
-          printer.visit(range)
+          printer.print_object(range)
         elsif location
-          printer.visit(location)
+          printer.print_object(location)
         end
-        printer.print(')'.light_black)
+        printer.print_colored(')', :light_black)
         printer.printn
         unless children.empty?
           printer.indent
-          printer.visit(children)
+          printer.print_objects(children)
           printer.dedent
         end
         # TODO: also display details?
@@ -214,5 +258,55 @@ module Spoom
         26 => "type_parameter",
       }
     end
+
+    class SymbolPrinter < Printer
+      extend T::Sig
+
+      attr_accessor :seen, :prefix
+
+      sig do
+        params(
+          out: T.any(IO, StringIO),
+          colors: T::Boolean,
+          indent_level: Integer,
+          prefix: T.nilable(String)
+        ).void
+      end
+      def initialize(out: $stdout, colors: true, indent_level: 0, prefix: nil)
+        super(out: out, colors: colors, indent_level: indent_level)
+        @seen = Set.new
+        @out = out
+        @colors = colors
+        @indent_level = indent_level
+        @prefix = prefix
+      end
+
+      sig { params(object: T.nilable(PrintableSymbol)).void }
+      def print_object(object)
+        return unless object
+        object.accept_printer(self)
+      end
+
+      sig { params(objects: T::Array[PrintableSymbol]).void }
+      def print_objects(objects)
+        objects.each { |object| print_object(object) }
+      end
+
+      sig { params(uri: String).returns(String) }
+      def clean_uri(uri)
+        return uri unless prefix
+        uri.delete_prefix(prefix)
+      end
+
+      sig { params(objects: T::Array[PrintableSymbol]).void }
+      def print_list(objects)
+        objects.each do |object|
+          printt
+          print "* "
+          print_object(object)
+          printn
+        end
+      end
+    end
   end
 end

data/lib/spoom/sorbet/metrics.rb

@@ -1,102 +1,33 @@
 # typed: strict
 # frozen_string_literal: true
 
+require_relative "sigils"
+
 module Spoom
   module Sorbet
-    class Metrics < T::Struct
+    module MetricsParser
       extend T::Sig
 
       DEFAULT_PREFIX = "ruby_typer.unknown.."
-      SIGILS = T.let(["ignore", "false", "true", "strict", "strong", "__STDLIB_INTERNAL"], T::Array[String])
-
-      const :repo, String
-      const :sha, String
-      const :status, String
-      const :branch, String
-      const :timestamp, Integer
-      const :uuid, String
-      const :metrics, T::Hash[String, T.nilable(Integer)]
 
-      sig { params(path: String, prefix: String).returns(Metrics) }
+      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
 
-      sig { params(string: String, prefix: String).returns(Metrics) }
+      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(obj: T::Hash[String, T.untyped], prefix: String).returns(Metrics) }
+      sig { params(obj: T::Hash[String, T.untyped], prefix: String).returns(T::Hash[String, Integer]) }
       def self.parse_hash(obj, prefix = DEFAULT_PREFIX)
-        Metrics.new(
-          repo: obj.fetch("repo"),
-          sha: obj.fetch("sha"),
-          status: obj.fetch("status"),
-          branch: obj.fetch("branch"),
-          timestamp: obj.fetch("timestamp").to_i,
-          uuid: obj.fetch("uuid"),
-          metrics: obj["metrics"].each_with_object({}) do |metric, all|
-            name = metric["name"]
-            name = name.sub(prefix, '')
-            all[name] = metric["value"].to_i
-          end,
-        )
-      end
-
-      sig { returns(T::Hash[String, T.nilable(Integer)]) }
-      def files_by_strictness
-        SIGILS.each_with_object({}) do |sigil, map|
-          map[sigil] = metrics["types.input.files.sigil.#{sigil}"]
+        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
-
-      sig { returns(Integer) }
-      def files_count
-        files_by_strictness.values.compact.sum
-      end
-
-      sig { params(key: String).returns(T.nilable(Integer)) }
-      def [](key)
-        metrics[key]
-      end
-
-      sig { returns(String) }
-      def to_s
-        "Metrics<#{repo}-#{timestamp}-#{status}>"
-      end
-
-      sig { params(out: T.any(IO, StringIO)).void }
-      def show(out = $stdout)
-        files = files_count
-
-        out.puts "Sigils:"
-        out.puts "  files: #{files}"
-        files_by_strictness.each do |sigil, value|
-          next unless value
-          out.puts "  #{sigil}: #{value}#{percent(value, files)}"
-        end
-
-        out.puts "\nMethods:"
-        m = metrics['types.input.methods.total']
-        s = metrics['types.sig.count']
-        out.puts "  methods: #{m}"
-        out.puts "  signatures: #{s}#{percent(s, m)}"
-
-        out.puts "\nSends:"
-        t = metrics['types.input.sends.typed']
-        s = metrics['types.input.sends.total']
-        out.puts "  sends: #{s}"
-        out.puts "  typed: #{t}#{percent(t, s)}"
-      end
-
-      private
-
-      sig { params(value: T.nilable(Integer), total: T.nilable(Integer)).returns(String) }
-      def percent(value, total)
-        return "" if value.nil? || total.nil? || total == 0
-        " (#{value * 100 / total}%)"
-      end
     end
   end
 end

data/lib/spoom/sorbet/sigils.rb

@@ -0,0 +1,98 @@
+# typed: strict
+# frozen_string_literal: true
+
+# The term "sigil" refers to the magic comment at the top of the file that has the form `# typed: <strictness>`,
+# where "strictness" represents the level at which Sorbet will report errors
+# See https://sorbet.org/docs/static for a more complete explanation
+module Spoom
+  module Sorbet
+    module Sigils
+      extend T::Sig
+
+      STRICTNESS_IGNORE = "ignore"
+      STRICTNESS_FALSE = "false"
+      STRICTNESS_TRUE = "true"
+      STRICTNESS_STRICT = "strict"
+      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])
+
+      SIGIL_REGEXP = T.let(/^#\s*typed\s*:\s*(\w*)\s*$/.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
+
+      # 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 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 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 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.exist?(path)
+        content = File.read(path, encoding: Encoding::ASCII_8BIT)
+        strictness_in_content(content)
+      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)
+
+        File.write(path, new_content)
+
+        strictness_in_content(new_content) == new_strictness
+      end
+
+      # 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)
+        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
+        end
+      end
+    end
+  end
+end