spoom 1.0.3 → 1.0.4

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

@@ -0,0 +1,58 @@
+# typed: true
+# frozen_string_literal: true
+
+module Spoom
+  module LSP
+    # Base messaging
+    # We don't use T::Struct for those so we can subclass them
+
+    # A general message as defined by JSON-RPC.
+    #
+    # The language server protocol always uses `"2.0"` as the `jsonrpc` version.
+    class Message
+      attr_reader :jsonrpc
+
+      def initialize
+        @jsonrpc = '2.0'
+      end
+
+      def as_json
+        instance_variables.each_with_object({}) do |var, obj|
+          val = instance_variable_get(var)
+          obj[var.to_s.delete('@')] = val if val
+        end
+      end
+
+      def to_json(*args)
+        as_json.to_json(*args)
+      end
+    end
+
+    # A request message to describe a request between the client and the server.
+    #
+    # Every processed request must send a response back to the sender of the request.
+    class Request < Message
+      attr_reader :id, :method, :params
+
+      def initialize(id, method, params)
+        super()
+        @id = id
+        @method = method
+        @params = params
+      end
+    end
+
+    # A notification message.
+    #
+    # A processed notification message must not send a response back. They work like events.
+    class Notification < Message
+      attr_reader :method, :params
+
+      def initialize(method, params)
+        super()
+        @method = method
+        @params = params
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# typed: true
+# frozen_string_literal: true
+
+module Spoom
+  module LSP
+    class Error < StandardError
+      class AlreadyOpen < Error; end
+      class BadHeaders < Error; end
+
+      class Diagnostics < Error
+        attr_reader :uri, :diagnostics
+
+        def self.from_json(json)
+          Diagnostics.new(
+            json['uri'],
+            json['diagnostics'].map { |d| Diagnostic.from_json(d) }
+          )
+        end
+
+        def initialize(uri, diagnostics)
+          @uri = uri
+          @diagnostics = diagnostics
+        end
+      end
+    end
+
+    class ResponseError < Error
+      attr_reader :code, :message, :data
+
+      def self.from_json(json)
+        ResponseError.new(
+          json['code'],
+          json['message'],
+          json['data']
+        )
+      end
+
+      def initialize(code, message, data)
+        @code = code
+        @message = message
+        @data = data
+      end
+    end
+  end
+end

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

@@ -0,0 +1,218 @@
+# typed: true
+# frozen_string_literal: true
+
+module Spoom
+  module LSP
+    class Hover < T::Struct
+      const :contents, String
+      const :range, T.nilable(Range)
+
+      def self.from_json(json)
+        Hover.new(
+          contents: json['contents']['value'],
+          range: json['range'] ? Range.from_json(json['range']) : nil
+        )
+      end
+
+      def accept_printer(printer)
+        printer.print("#{contents}\n")
+        printer.visit(range) if range
+      end
+
+      def to_s
+        "#{contents} (#{range})."
+      end
+    end
+
+    class Position < T::Struct
+      const :line, Integer
+      const :char, Integer
+
+      def self.from_json(json)
+        Position.new(
+          line: json['line'].to_i,
+          char: json['character'].to_i
+        )
+      end
+
+      def accept_printer(printer)
+        printer.print("#{line}:#{char}".light_black)
+      end
+
+      def to_s
+        "#{line}:#{char}"
+      end
+    end
+
+    class Range < T::Struct
+      const :start, Position
+      const :end, Position
+
+      def self.from_json(json)
+        Range.new(
+          start: Position.from_json(json['start']),
+          end: Position.from_json(json['end'])
+        )
+      end
+
+      def accept_printer(printer)
+        printer.visit(start)
+        printer.print("-".light_black)
+        printer.visit(self.end)
+      end
+
+      def to_s
+        "#{start}-#{self.end}"
+      end
+    end
+
+    class Location < T::Struct
+      const :uri, String
+      const :range, LSP::Range
+
+      def self.from_json(json)
+        Location.new(
+          uri: json['uri'],
+          range: Range.from_json(json['range'])
+        )
+      end
+
+      def accept_printer(printer)
+        printer.print("#{uri.from_uri}:".light_black)
+        printer.visit(range)
+      end
+
+      def to_s
+        "#{uri}:#{range})."
+      end
+    end
+
+    class SignatureHelp < T::Struct
+      const :label, T.nilable(String)
+      const :doc, Object # TODO
+      const :params, T::Array[T.untyped] # TODO
+
+      def self.from_json(json)
+        SignatureHelp.new(
+          label: json['label'],
+          doc: json['documentation'],
+          params: json['parameters'],
+        )
+      end
+
+      def accept_printer(printer)
+        printer.print(label)
+        printer.print("(")
+        printer.print(params.map { |l| "#{l['label']}: #{l['documentation']}" }.join(", "))
+        printer.print(")")
+      end
+
+      def to_s
+        "#{label}(#{params})."
+      end
+    end
+
+    class Diagnostic < T::Struct
+      const :range, LSP::Range
+      const :code, Integer
+      const :message, String
+      const :informations, Object
+
+      def self.from_json(json)
+        Diagnostic.new(
+          range: Range.from_json(json['range']),
+          code: json['code'].to_i,
+          message: json['message'],
+          informations: json['relatedInformation']
+        )
+      end
+
+      def to_s
+        "Error: #{message} (#{code})."
+      end
+    end
+
+    class DocumentSymbol < T::Struct
+      const :name, String
+      const :detail, T.nilable(String)
+      const :kind, Integer
+      const :location, T.nilable(Location)
+      const :range, T.nilable(Range)
+      const :children, T::Array[DocumentSymbol]
+
+      def self.from_json(json)
+        DocumentSymbol.new(
+          name: json['name'],
+          detail: json['detail'],
+          kind: json['kind'],
+          location: json['location'] ? Location.from_json(json['location']) : nil,
+          range: json['range'] ? Range.from_json(json['range']) : nil,
+          children: json['children'] ? json['children'].map { |symbol| DocumentSymbol.from_json(symbol) } : [],
+        )
+      end
+
+      def accept_printer(printer)
+        h = serialize.hash
+        return if printer.seen.include?(h)
+        printer.seen.add(h)
+
+        printer.printt
+        printer.print(kind_string)
+        printer.print(' ')
+        printer.print(name.blue.bold)
+        printer.print(' ('.light_black)
+        if range
+          printer.visit(range)
+        elsif location
+          printer.visit(location)
+        end
+        printer.print(')'.light_black)
+        printer.printn
+        unless children.empty?
+          printer.indent
+          printer.visit(children)
+          printer.dedent
+        end
+        # TODO: also display details?
+      end
+
+      def to_s
+        "#{name} (#{range})"
+      end
+
+      def kind_string
+        return "<unknown:#{kind}>" unless SYMBOL_KINDS.key?(kind)
+        SYMBOL_KINDS[kind]
+      end
+
+      SYMBOL_KINDS = {
+        1 => "file",
+        2 => "module",
+        3 => "namespace",
+        4 => "package",
+        5 => "class",
+        6 => "def",
+        7 => "property",
+        8 => "field",
+        9 => "constructor",
+        10 => "enum",
+        11 => "interface",
+        12 => "function",
+        13 => "variable",
+        14 => "const",
+        15 => "string",
+        16 => "number",
+        17 => "boolean",
+        18 => "array",
+        19 => "object",
+        20 => "key",
+        21 => "null",
+        22 => "enum_member",
+        23 => "struct",
+        24 => "event",
+        25 => "operator",
+        26 => "type_parameter",
+      }
+    end
+  end
+end

data/lib/spoom/sorbet/metrics.rb

@@ -0,0 +1,102 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Sorbet
+    class Metrics < T::Struct
+      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) }
+      def self.parse_file(path, prefix = DEFAULT_PREFIX)
+        parse_string(File.read(path), prefix)
+      end
+
+      sig { params(string: String, prefix: String).returns(Metrics) }
+      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) }
+      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}"]
+        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/version.rb

@@ -1,5 +1,6 @@
+# typed: true
 # frozen_string_literal: true
 
 module Spoom
-  VERSION = "1.0.3"
+  VERSION = "1.0.4"
 end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: spoom
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
 - Alexandre Terrasa
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-07-07 00:00:00.000000000 Z
+date: 2020-08-05 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: sorbet-runtime
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: sorbet-runtime
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: sorbet
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +80,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.5.5
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.19.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.19.2
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - alexandre.terrasa@shopify.com
@@ -93,7 +121,21 @@ files:
 - Rakefile
 - exe/spoom
 - lib/spoom.rb
+- lib/spoom/cli.rb
+- lib/spoom/cli/commands/base.rb
+- lib/spoom/cli/commands/config.rb
+- lib/spoom/cli/commands/lsp.rb
+- lib/spoom/cli/commands/run.rb
+- lib/spoom/cli/symbol_printer.rb
+- lib/spoom/config.rb
+- lib/spoom/sorbet.rb
 - lib/spoom/sorbet/config.rb
+- lib/spoom/sorbet/errors.rb
+- lib/spoom/sorbet/lsp.rb
+- lib/spoom/sorbet/lsp/base.rb
+- lib/spoom/sorbet/lsp/errors.rb
+- lib/spoom/sorbet/lsp/structures.rb
+- lib/spoom/sorbet/metrics.rb
 - lib/spoom/version.rb
 homepage: https://github.com/Shopify/spoom
 licenses: