spoom 1.7.0 → 1.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 232ecacb9d25232ca17356951f795baf011b5ec9dd4c18b5688be1c474bccf2b
-  data.tar.gz: 824782c6b5b810cae1a88805e3dd196a4499f4f04fce86e57fc933873958cbd9
+  metadata.gz: 59987238a3b2bae115f02d1da2a7e2a4cd6b3532d816bbe80d9153fa7819f989
+  data.tar.gz: d7e6bccfa046b7c457cb3e5d3d4383141243949021bd584b22cde0db0cc165ef
 SHA512:
-  metadata.gz: de1b4478214f3be4f3369b7930cd6a3b96dac3e6c5ba506a3e25380bf1733b093996851dc59537ef56c2700eb63e3d0c317cc3ab44d0690e0255da38c0e6da77
-  data.tar.gz: 61e14bcfd81428eb251b514b4b21c0febd5df783bc5221e68d1c5ca44e3c5ae34017c12e13d034d331c31ee8900a38847e3712197797431122c5a24d57fc144b
+  metadata.gz: b2f53478b7fdee59bfa7c579c3686b6d6c388db8737584c02f613daa2c4d42c0be2c1baaa39c50e90137697f62d7b8bb04e9fdbb458defdfa7813be3b6cbbd36
+  data.tar.gz: 57b26d457d2235bedaff15c832accc34a9c5ffcb89876306394f12b74a87ce03964d0309cd62e213e9954607150968607227436ebeb522a84f27782f7cc8cac8

data/lib/spoom/cli/srb/metrics.rb

@@ -0,0 +1,68 @@
+# typed: true
+# frozen_string_literal: true
+
+module Spoom
+  module Cli
+    module Srb
+      class Metrics < Thor
+        include Helper
+
+        default_task :show
+
+        desc "show", "Show metrics about Sorbet usage"
+        option :dump, type: :boolean, default: false
+        def show(*paths)
+          files = collect_files(paths)
+          metrics = Spoom::Sorbet::Metrics.collect_code_metrics(files)
+
+          if options[:dump]
+            metrics.sort_by { |key, _value| key }.each do |key, value|
+              puts "#{key} #{value}"
+            end
+
+            return
+          end
+
+          say("Files: `#{files.size}`")
+
+          ["classes", "modules", "singleton_classes"].each do |key|
+            value = metrics[key]
+            next if value == 0
+
+            say("\n#{key.capitalize}: `#{value}`")
+            ["with_srb_type_params", "with_rbs_type_params"].each do |subkey|
+              say(" * #{subkey.gsub("_", " ")}: `#{metrics["#{key}_#{subkey}"]}`")
+            end
+          end
+
+          ["methods", "accessors"].each do |key|
+            value = metrics[key]
+            next if value == 0
+
+            say("\n#{key.capitalize}: `#{value}`")
+            ["without_sig", "with_srb_sig", "with_rbs_sig"].each do |subkey|
+              say(" * #{subkey.gsub("_", " ")}: `#{metrics["#{key}_#{subkey}"]}`")
+            end
+          end
+
+          say("\nT. calls: `#{metrics["T_calls"]}`")
+          metrics
+            .select { |key, _value| key.start_with?("T.") }
+            .sort_by { |_key, value| -value }
+            .each do |key, value|
+              say(" * #{key}: `#{value}`")
+            end
+
+          say("\nRBS Assertions: `#{metrics["rbs_assertions"]}`")
+          metrics
+            .reject { |key, _value| key == "rbs_assertions" }
+            .select { |key, _value| key.start_with?("rbs_") }
+            .sort_by { |_key, value| -value }
+            .each do |key, value|
+            say(" * #{key}: `#{value}`")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spoom/cli/srb.rb

@@ -5,6 +5,7 @@ require_relative "srb/assertions"
 require_relative "srb/bump"
 require_relative "srb/coverage"
 require_relative "srb/lsp"
+require_relative "srb/metrics"
 require_relative "srb/sigs"
 require_relative "srb/tc"
 
@@ -24,6 +25,9 @@ module Spoom
         desc "lsp", "Send LSP requests to Sorbet"
         subcommand "lsp", Spoom::Cli::Srb::LSP
 
+        desc "metrics", "Collect metrics about Sorbet usage"
+        subcommand "metrics", Spoom::Cli::Srb::Metrics
+
         desc "sigs", "Translate signatures from/to RBI and RBS"
         subcommand "sigs", Spoom::Cli::Srb::Sigs
 

data/lib/spoom/context/sorbet.rb

@@ -48,7 +48,7 @@ module Spoom
         return unless file?(metrics_file)
 
         metrics_path = absolute_path_to(metrics_file)
-        metrics = Spoom::Sorbet::MetricsParser.parse_file(metrics_path)
+        metrics = Spoom::Sorbet::Metrics::MetricsFileParser.parse_file(metrics_path)
         remove!(metrics_file)
         metrics
       end

data/lib/spoom/counters.rb

@@ -0,0 +1,22 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  #: [K = String, V = Integer, Elem = [String, Integer]]
+  class Counters < Hash
+    #: -> void
+    def initialize
+      super(0)
+    end
+
+    #: (String) -> void
+    def increment(key)
+      self[key] += 1
+    end
+
+    #: (String) -> Integer
+    def [](key)
+      super(key) #: as Integer
+    end
+  end
+end

data/lib/spoom/sorbet/metrics/code_metrics_visitor.rb

@@ -0,0 +1,236 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Sorbet
+    module Metrics
+      class << self
+        #: (Array[String]) -> Spoom::Counters
+        def collect_code_metrics(files)
+          counters = Counters.new
+
+          files.each do |file|
+            counters.increment("files")
+
+            content = File.read(file)
+            node = Spoom.parse_ruby(content, file: file, comments: true)
+            visitor = CodeMetricsVisitor.new(counters)
+            visitor.visit(node)
+          end
+
+          counters
+        end
+      end
+
+      # Collects metrics about how Sorbet is used in the codebase.
+      #
+      # This approach is different from the metrics file we get directly from Sorbet.
+      #
+      # This visitor actually visits the codebase and collects metrics about the amount of signatures, `T.` calls,
+      # and other metrics. It also knows about RBS comments.
+      #
+      # On the other hand, the metrics file is a snapshot of the metrics at type checking time and knows about
+      # is calls are typed, how many assertions are done, etc.
+      class CodeMetricsVisitor < Spoom::Visitor
+        include RBS::ExtractRBSComments
+
+        #: Counters
+        attr_reader :counters
+
+        #: (Spoom::Counters) -> void
+        def initialize(counters)
+          super()
+
+          @counters = counters
+
+          @last_sigs = [] #: Array[Prism::CallNode]
+          @type_params = [] #: Array[Prism::CallNode]
+        end
+
+        # @override
+        #: (Prism::Node?) -> void
+        def visit(node)
+          return if node.nil?
+
+          node.location.trailing_comments.each do |comment|
+            text = comment.slice.strip
+            next unless text.start_with?("#:")
+
+            @counters.increment("rbs_assertions")
+
+            case text
+            when /^#: as !nil/
+              @counters.increment("rbs_must")
+            when /^#: as untyped/
+              @counters.increment("rbs_unsafe")
+            when /^#: as/
+              @counters.increment("rbs_cast")
+            when /^#:/
+              @counters.increment("rbs_let")
+            end
+          end
+
+          super
+        end
+
+        # @override
+        #: (Prism::ClassNode) -> void
+        def visit_class_node(node)
+          visit_scope(node) do
+            super
+          end
+        end
+
+        # @override
+        #: (Prism::ModuleNode) -> void
+        def visit_module_node(node)
+          visit_scope(node) do
+            super
+          end
+        end
+
+        # @override
+        #: (Prism::SingletonClassNode) -> void
+        def visit_singleton_class_node(node)
+          visit_scope(node) do
+            super
+          end
+        end
+
+        # @override
+        #: (Prism::DefNode) -> void
+        def visit_def_node(node)
+          unless node.name.to_s.start_with?("test_")
+            @counters.increment("methods")
+
+            rbs_sigs = node_rbs_comments(node).signatures
+            srb_sigs = collect_last_srb_sigs
+
+            if rbs_sigs.any?
+              @counters.increment("methods_with_rbs_sig")
+            end
+
+            if srb_sigs.any?
+              @counters.increment("methods_with_srb_sig")
+            end
+
+            if rbs_sigs.empty? && srb_sigs.empty?
+              @counters.increment("methods_without_sig")
+            end
+          end
+
+          super
+        end
+
+        # @override
+        #: (Prism::CallNode) -> void
+        def visit_call_node(node)
+          @counters.increment("calls")
+
+          case node.name
+          when :attr_accessor, :attr_reader, :attr_writer
+            visit_attr_accessor(node)
+            return
+          when :sig
+            visit_sig(node)
+            return
+          when :type_member, :type_template
+            visit_type_member(node)
+            return
+          end
+
+          case node.receiver&.slice
+          when /^(::)?T$/
+            @counters.increment("T_calls")
+            @counters.increment("T.#{node.name}")
+          end
+
+          super
+        end
+
+        private
+
+        #: (Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode) { -> void } -> void
+        def visit_scope(node, &block)
+          key = node_key(node)
+          @counters.increment(key)
+          @counters.increment("#{key}_with_rbs_type_params") if node_rbs_comments(node).signatures.any?
+
+          old_type_params = @type_params
+          @type_params = []
+
+          yield
+
+          @counters.increment("#{key}_with_srb_type_params") if @type_params.any?
+
+          @type_params = old_type_params
+        end
+
+        #: (Prism::CallNode) -> void
+        def visit_attr_accessor(node)
+          @counters.increment("accessors")
+
+          rbs_sigs = node_rbs_comments(node).signatures
+          srb_sigs = collect_last_srb_sigs
+
+          if rbs_sigs.any?
+            @counters.increment("accessors_with_rbs_sig")
+          end
+
+          if srb_sigs.any?
+            @counters.increment("accessors_with_srb_sig")
+          end
+
+          if rbs_sigs.empty? && srb_sigs.empty?
+            @counters.increment("accessors_without_sig")
+          end
+        end
+
+        #: (Prism::CallNode) -> void
+        def visit_sig(node)
+          @last_sigs << node
+          @counters.increment("srb_sigs")
+
+          if node.slice =~ /abstract/
+            @counters.increment("srb_sigs_abstract")
+          end
+        end
+
+        #: (Prism::CallNode) -> void
+        def visit_type_member(node)
+          key = case node.name
+          when :type_member
+            "type_members"
+          when :type_template
+            "type_templates"
+          else
+            return
+          end
+
+          @counters.increment(key)
+
+          @type_params << node
+        end
+
+        #: -> Array[Prism::CallNode]
+        def collect_last_srb_sigs
+          sigs = @last_sigs.dup
+          @last_sigs.clear
+          sigs
+        end
+
+        #: (Prism::ClassNode | Prism::ModuleNode | Prism::SingletonClassNode) -> String
+        def node_key(node)
+          case node
+          when Prism::ClassNode
+            "classes"
+          when Prism::ModuleNode
+            "modules"
+          when Prism::SingletonClassNode
+            "singleton_classes"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spoom/sorbet/metrics/metrics_file_parser.rb

@@ -0,0 +1,34 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "spoom/sorbet/sigils"
+
+module Spoom
+  module Sorbet
+    module Metrics
+      module MetricsFileParser
+        DEFAULT_PREFIX = "ruby_typer.unknown."
+
+        class << self
+          #: (String path, ?String prefix) -> Hash[String, Integer]
+          def parse_file(path, prefix = DEFAULT_PREFIX)
+            parse_string(File.read(path), prefix)
+          end
+
+          #: (String string, ?String prefix) -> Hash[String, Integer]
+          def parse_string(string, prefix = DEFAULT_PREFIX)
+            parse_hash(JSON.parse(string), prefix)
+          end
+
+          #: (Hash[String, untyped] obj, ?String prefix) -> Counters
+          def parse_hash(obj, prefix = DEFAULT_PREFIX)
+            obj["metrics"].each_with_object(Counters.new) do |metric, metrics|
+              name = metric["name"].sub(prefix, "")
+              metrics[name] = metric["value"] || 0
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spoom/sorbet/metrics.rb

@@ -1,33 +1,5 @@
 # typed: strict
 # frozen_string_literal: true
 
-require_relative "sigils"
-
-module Spoom
-  module Sorbet
-    module MetricsParser
-      DEFAULT_PREFIX = "ruby_typer.unknown."
-
-      class << self
-        #: (String path, ?String prefix) -> Hash[String, Integer]
-        def parse_file(path, prefix = DEFAULT_PREFIX)
-          parse_string(File.read(path), prefix)
-        end
-
-        #: (String string, ?String prefix) -> Hash[String, Integer]
-        def parse_string(string, prefix = DEFAULT_PREFIX)
-          parse_hash(JSON.parse(string), prefix)
-        end
-
-        #: (Hash[String, untyped] obj, ?String prefix) -> Hash[String, Integer]
-        def parse_hash(obj, prefix = DEFAULT_PREFIX)
-          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
-      end
-    end
-  end
-end
+require "spoom/sorbet/metrics/code_metrics_visitor"
+require "spoom/sorbet/metrics/metrics_file_parser"

data/lib/spoom/sorbet/translate/rbs_comments_to_sorbet_sigs.rb

@@ -132,7 +132,6 @@ module Spoom
             comments.annotations.reverse_each do |annotation|
               from = adjust_to_line_start(annotation.location.start_offset)
               to = adjust_to_line_end(annotation.location.end_offset)
-              @rewriter << Source::Delete.new(from, to)
 
               content = case annotation.string
               when "@abstract"
@@ -147,8 +146,12 @@ module Spoom
                 srb_type = ::RBS::Parser.parse_type(annotation.string.delete_prefix("@requires_ancestor: "))
                 rbs_type = RBI::RBS::TypeTranslator.translate(srb_type)
                 "requires_ancestor { #{rbs_type} }"
+              else
+                next
               end
 
+              @rewriter << Source::Delete.new(from, to)
+
               newline = node.body.nil? ? "" : "\n"
               @rewriter << Source::Insert.new(insert_pos, "\n#{indent}#{content}#{newline}")
             end

data/lib/spoom/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Spoom
-  VERSION = "1.7.0"
+  VERSION = "1.7.2"
 end

data/lib/spoom.rb

@@ -18,6 +18,7 @@ require "spoom/model"
 require "spoom/source"
 require "spoom/deadcode"
 require "spoom/rbs"
+require "spoom/counters"
 require "spoom/sorbet"
 require "spoom/cli"
 require "spoom/version"

data/rbi/spoom.rbi

@@ -165,10 +165,19 @@ class Spoom::Cli::Srb::Main < ::Thor
   def coverage(*args); end
   def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
   def lsp(*args); end
+  def metrics(*args); end
   def sigs(*args); end
   def tc(*args); end
 end
 
+class Spoom::Cli::Srb::Metrics < ::Thor
+  include ::Spoom::Colorize
+  include ::Spoom::Cli::Helper
+
+  def help(command = T.unsafe(nil), subcommand = T.unsafe(nil)); end
+  def show(*paths); end
+end
+
 class Spoom::Cli::Srb::Sigs < ::Thor
   include ::Spoom::Colorize
   include ::Spoom::Cli::Helper
@@ -422,6 +431,17 @@ module Spoom::Context::Sorbet
   def write_sorbet_config!(contents, append: T.unsafe(nil)); end
 end
 
+class Spoom::Counters < ::Hash
+  sig { void }
+  def initialize; end
+
+  sig { params(key: ::String).returns(::Integer) }
+  def [](key); end
+
+  sig { params(key: ::String).void }
+  def increment(key); end
+end
+
 module Spoom::Coverage
   class << self
     sig { params(context: ::Spoom::Context).returns(::Spoom::FileTree) }
@@ -2445,29 +2465,25 @@ end
 class Spoom::ParseError < ::Spoom::Error; end
 
 class Spoom::Poset
-  extend T::Generic
-
-  E = type_member { { upper: Object } }
-
   sig { void }
   def initialize; end
 
-  sig { params(value: E).returns(Spoom::Poset::Element[E]) }
+  sig { params(value: T.untyped).returns(Spoom::Poset::Element[T.untyped]) }
   def [](value); end
 
-  sig { params(from: E, to: E).void }
+  sig { params(from: T.untyped, to: T.untyped).void }
   def add_direct_edge(from, to); end
 
-  sig { params(value: E).returns(Spoom::Poset::Element[E]) }
+  sig { params(value: T.untyped).returns(Spoom::Poset::Element[T.untyped]) }
   def add_element(value); end
 
-  sig { params(from: E, to: E).returns(T::Boolean) }
+  sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
   def direct_edge?(from, to); end
 
-  sig { params(from: E, to: E).returns(T::Boolean) }
+  sig { params(from: T.untyped, to: T.untyped).returns(T::Boolean) }
   def edge?(from, to); end
 
-  sig { params(value: E).returns(T::Boolean) }
+  sig { params(value: T.untyped).returns(T::Boolean) }
   def element?(value); end
 
   sig { params(direct: T::Boolean, transitive: T::Boolean).void }
@@ -2478,39 +2494,36 @@ class Spoom::Poset
 end
 
 class Spoom::Poset::Element
-  extend T::Generic
   include ::Comparable
 
-  E = type_member { { upper: Object } }
-
-  sig { params(value: E).void }
+  sig { params(value: T.untyped).void }
   def initialize(value); end
 
   sig { params(other: T.untyped).returns(T.nilable(::Integer)) }
   def <=>(other); end
 
-  sig { returns(T::Array[E]) }
+  sig { returns(T::Array[T.untyped]) }
   def ancestors; end
 
-  sig { returns(T::Array[E]) }
+  sig { returns(T::Array[T.untyped]) }
   def children; end
 
-  sig { returns(T::Array[E]) }
+  sig { returns(T::Array[T.untyped]) }
   def descendants; end
 
   def dfroms; end
 
-  sig { returns(T::Set[Spoom::Poset::Element[E]]) }
+  sig { returns(T::Set[Spoom::Poset::Element[T.untyped]]) }
   def dtos; end
 
   def froms; end
 
-  sig { returns(T::Array[E]) }
+  sig { returns(T::Array[T.untyped]) }
   def parents; end
 
   def tos; end
 
-  sig { returns(E) }
+  sig { returns(T.untyped) }
   def value; end
 end
 
@@ -2732,12 +2745,72 @@ Spoom::Sorbet::GEM_PATH = T.let(T.unsafe(nil), String)
 Spoom::Sorbet::GEM_VERSION = T.let(T.unsafe(nil), String)
 Spoom::Sorbet::KILLED_CODE = T.let(T.unsafe(nil), Integer)
 
-module Spoom::Sorbet::MetricsParser
+module Spoom::Sorbet::Metrics
+  class << self
+    sig { params(files: T::Array[::String]).returns(Spoom::Counters) }
+    def collect_code_metrics(files); end
+  end
+end
+
+class Spoom::Sorbet::Metrics::CodeMetricsVisitor < ::Spoom::Visitor
+  include ::Spoom::RBS::ExtractRBSComments
+
+  sig { params(counters: Spoom::Counters).void }
+  def initialize(counters); end
+
+  sig { returns(Spoom::Counters) }
+  def counters; end
+
+  sig { override.params(node: T.nilable(::Prism::Node)).void }
+  def visit(node); end
+
+  sig { override.params(node: ::Prism::CallNode).void }
+  def visit_call_node(node); end
+
+  sig { override.params(node: ::Prism::ClassNode).void }
+  def visit_class_node(node); end
+
+  sig { override.params(node: ::Prism::DefNode).void }
+  def visit_def_node(node); end
+
+  sig { override.params(node: ::Prism::ModuleNode).void }
+  def visit_module_node(node); end
+
+  sig { override.params(node: ::Prism::SingletonClassNode).void }
+  def visit_singleton_class_node(node); end
+
+  private
+
+  sig { returns(T::Array[::Prism::CallNode]) }
+  def collect_last_srb_sigs; end
+
+  sig { params(node: T.any(::Prism::ClassNode, ::Prism::ModuleNode, ::Prism::SingletonClassNode)).returns(::String) }
+  def node_key(node); end
+
+  sig { params(node: ::Prism::CallNode).void }
+  def visit_attr_accessor(node); end
+
+  sig do
+    params(
+      node: T.any(::Prism::ClassNode, ::Prism::ModuleNode, ::Prism::SingletonClassNode),
+      block: T.proc.void
+    ).void
+  end
+  def visit_scope(node, &block); end
+
+  sig { params(node: ::Prism::CallNode).void }
+  def visit_sig(node); end
+
+  sig { params(node: ::Prism::CallNode).void }
+  def visit_type_member(node); end
+end
+
+module Spoom::Sorbet::Metrics::MetricsFileParser
   class << self
     sig { params(path: ::String, prefix: ::String).returns(T::Hash[::String, ::Integer]) }
     def parse_file(path, prefix = T.unsafe(nil)); end
 
-    sig { params(obj: T::Hash[::String, T.untyped], prefix: ::String).returns(T::Hash[::String, ::Integer]) }
+    sig { params(obj: T::Hash[::String, T.untyped], prefix: ::String).returns(Spoom::Counters) }
     def parse_hash(obj, prefix = T.unsafe(nil)); end
 
     sig { params(string: ::String, prefix: ::String).returns(T::Hash[::String, ::Integer]) }
@@ -2745,7 +2818,7 @@ module Spoom::Sorbet::MetricsParser
   end
 end
 
-Spoom::Sorbet::MetricsParser::DEFAULT_PREFIX = T.let(T.unsafe(nil), String)
+Spoom::Sorbet::Metrics::MetricsFileParser::DEFAULT_PREFIX = T.let(T.unsafe(nil), String)
 Spoom::Sorbet::SEGFAULT_CODE = T.let(T.unsafe(nil), Integer)
 
 module Spoom::Sorbet::Sigils

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spoom
 version: !ruby/object:Gem::Version
-  version: 1.7.0
+  version: 1.7.2
 platform: ruby
 authors:
 - Alexandre Terrasa
@@ -185,6 +185,7 @@ files:
 - lib/spoom/cli/srb/bump.rb
 - lib/spoom/cli/srb/coverage.rb
 - lib/spoom/cli/srb/lsp.rb
+- lib/spoom/cli/srb/metrics.rb
 - lib/spoom/cli/srb/sigs.rb
 - lib/spoom/cli/srb/tc.rb
 - lib/spoom/colors.rb
@@ -194,6 +195,7 @@ files:
 - lib/spoom/context/file_system.rb
 - lib/spoom/context/git.rb
 - lib/spoom/context/sorbet.rb
+- lib/spoom/counters.rb
 - lib/spoom/coverage.rb
 - lib/spoom/coverage/d3.rb
 - lib/spoom/coverage/d3/base.rb
@@ -249,6 +251,8 @@ files:
 - lib/spoom/sorbet/lsp/errors.rb
 - lib/spoom/sorbet/lsp/structures.rb
 - lib/spoom/sorbet/metrics.rb
+- lib/spoom/sorbet/metrics/code_metrics_visitor.rb
+- lib/spoom/sorbet/metrics/metrics_file_parser.rb
 - lib/spoom/sorbet/sigils.rb
 - lib/spoom/sorbet/translate.rb
 - lib/spoom/sorbet/translate/rbs_comments_to_sorbet_sigs.rb