spoom 1.0.4 → 1.0.9

data/lib/spoom/cli/lsp.rb

@@ -0,0 +1,165 @@
+# 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
+        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|
+          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
+          in_sorbet_project!
+          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

@@ -0,0 +1,109 @@
+# 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, lazy_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"
+      def tc(*arg)
+        in_sorbet_project!
+
+        path = exec_path
+        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
+          output, status = T.unsafe(Spoom::Sorbet).srb_tc(*arg, path: path, capture_err: false, sorbet_bin: sorbet)
+          say_error(output, status: nil, nl: false)
+          exit(status)
+        end
+
+        output, status = T.unsafe(Spoom::Sorbet).srb_tc(*arg, path: path, capture_err: true, sorbet_bin: sorbet)
+        if status
+          say_error(output, status: nil, nl: false)
+          exit(0)
+        end
+
+        errors = Spoom::Sorbet::Errors::Parser.parse_string(output)
+        errors_count = errors.size
+
+        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 = errors.select { |e| e.code == code } if code
+        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)
+      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 ? c.cyan : c.red)
+          end
+          word.string
+        end
+      end
+    end
+  end
+end

data/lib/spoom/coverage.rb

@@ -0,0 +1,89 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "coverage/snapshot"
+require_relative "coverage/report"
+require_relative "file_tree"
+
+require "date"
+
+module Spoom
+  module Coverage
+    extend T::Sig
+
+    sig { params(path: String, rbi: T::Boolean, sorbet_bin: T.nilable(String)).returns(Snapshot) }
+    def self.snapshot(path: '.', rbi: true, sorbet_bin: nil)
+      config = sorbet_config(path: path)
+      config.allowed_extensions.push(".rb", ".rbi") if config.allowed_extensions.empty?
+
+      new_config = config.copy
+      new_config.allowed_extensions.reject! { |ext| !rbi && ext == ".rbi" }
+
+      metrics = Spoom::Sorbet.srb_metrics(
+        "--no-config",
+        new_config.options_string,
+        path: path,
+        capture_err: true,
+        sorbet_bin: sorbet_bin
+      )
+
+      snapshot = Snapshot.new
+      return snapshot unless metrics
+
+      sha = Spoom::Git.last_commit(path: path)
+      snapshot.commit_sha = sha
+      snapshot.commit_timestamp = Spoom::Git.commit_timestamp(sha, path: path).to_i if sha
+
+      snapshot.files = metrics.fetch("types.input.files", 0)
+      snapshot.modules = metrics.fetch("types.input.modules.total", 0)
+      snapshot.classes = metrics.fetch("types.input.classes.total", 0)
+      snapshot.singleton_classes = metrics.fetch("types.input.singleton_classes.total", 0)
+      snapshot.methods_with_sig = metrics.fetch("types.sig.count", 0)
+      snapshot.methods_without_sig = metrics.fetch("types.input.methods.total", 0) - snapshot.methods_with_sig
+      snapshot.calls_typed = metrics.fetch("types.input.sends.typed", 0)
+      snapshot.calls_untyped = metrics.fetch("types.input.sends.total", 0) - snapshot.calls_typed
+
+      snapshot.duration += metrics.fetch("run.utilization.system_time.us", 0)
+      snapshot.duration += metrics.fetch("run.utilization.user_time.us", 0)
+
+      Snapshot::STRICTNESSES.each do |strictness|
+        next unless metrics.key?("types.input.files.sigil.#{strictness}")
+        snapshot.sigils[strictness] = T.must(metrics["types.input.files.sigil.#{strictness}"])
+      end
+
+      snapshot.version_static = Spoom::Sorbet.version_from_gemfile_lock(gem: "sorbet-static", path: path)
+      snapshot.version_runtime = Spoom::Sorbet.version_from_gemfile_lock(gem: "sorbet-runtime", path: path)
+
+      snapshot
+    end
+
+    sig { params(snapshots: T::Array[Snapshot], palette: D3::ColorPalette, path: String).returns(Report) }
+    def self.report(snapshots, palette:, path: ".")
+      intro_commit = Git.sorbet_intro_commit(path: path)
+      intro_date = intro_commit ? Git.commit_time(intro_commit, path: path) : nil
+
+      Report.new(
+        project_name: File.basename(File.expand_path(path)),
+        palette: palette,
+        snapshots: snapshots,
+        sigils_tree: sigils_tree(path: path),
+        sorbet_intro_commit: intro_commit,
+        sorbet_intro_date: intro_date,
+      )
+    end
+
+    sig { params(path: String).returns(Sorbet::Config) }
+    def self.sorbet_config(path: ".")
+      Sorbet::Config.parse_file("#{path}/#{Spoom::Sorbet::CONFIG_PATH}")
+    end
+
+    sig { params(path: String).returns(FileTree) }
+    def self.sigils_tree(path: ".")
+      config = sorbet_config(path: path)
+      files = Sorbet.srb_files(config, path: path)
+      files.select! { |file| file =~ /\.rb$/ }
+      files.reject! { |file| file =~ %r{/test/} }
+      FileTree.new(files, strip_prefix: path)
+    end
+  end
+end

data/lib/spoom/coverage/d3.rb

@@ -0,0 +1,110 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "d3/circle_map"
+require_relative "d3/pie"
+require_relative "d3/timeline"
+
+module Spoom
+  module Coverage
+    module D3
+      extend T::Sig
+
+      COLOR_IGNORE = "#999"
+      COLOR_FALSE = "#db4437"
+      COLOR_TRUE = "#0f9d58"
+      COLOR_STRICT = "#0a7340"
+      COLOR_STRONG = "#064828"
+
+      sig { returns(String) }
+      def self.header_style
+        <<~CSS
+          svg {
+            width: 100%;
+            height: 100%;
+          }
+
+          .tooltip {
+            font: 12px Arial, sans-serif;
+            color: #fff;
+            text-align: center;
+            background: rgba(0, 0, 0, 0.6);
+            padding: 5px;
+            border: 0px;
+            border-radius: 4px;
+            position: absolute;
+            top: 0;
+            left: 0;
+            opacity: 0;
+          }
+
+          .label {
+            font: 14px Arial, sans-serif;
+            font-weight: bold;
+            fill: #fff;
+            text-anchor: middle;
+            pointer-events: none;
+          }
+
+          .label .small {
+            font-size: 10px;
+          }
+
+          #{Pie.header_style}
+          #{CircleMap.header_style}
+          #{Timeline.header_style}
+        CSS
+      end
+
+      sig { params(palette: ColorPalette).returns(String) }
+      def self.header_script(palette)
+        <<~JS
+          var parseDate = d3.timeParse("%s");
+
+          function strictnessColor(strictness) {
+            switch(strictness) {
+              case "ignore":
+                return "#{palette.ignore}";
+              case "false":
+                return "#{palette.false}";
+              case "true":
+                return "#{palette.true}";
+              case "strict":
+                return "#{palette.strict}";
+              case "strong":
+                return "#{palette.strong}";
+            }
+            return "#{palette.false}";
+          }
+
+          function toPercent(value, sum) {
+            return value ? Math.round(value * 100 / sum) : 0;
+          }
+
+          var tooltip = d3.select("body")
+            .append("div")
+              .append("div")
+                .attr("class", "tooltip");
+
+          function moveTooltip(d) {
+            return tooltip
+              .style("left", (d3.event.pageX + 20) + "px")
+              .style("top", (d3.event.pageY) + "px")
+          }
+
+          #{Pie.header_script}
+          #{CircleMap.header_script}
+          #{Timeline.header_script}
+        JS
+      end
+
+      class ColorPalette < T::Struct
+        prop :ignore, String
+        prop :false, String
+        prop :true, String
+        prop :strict, String
+        prop :strong, String
+      end
+    end
+  end
+end