spoom 1.6.3 → 1.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4e47e1d01da6e3ee465eccc91bb4e3cd29549bb06d585ec0c3b6c6c129120a56
-  data.tar.gz: fbff7dfda675c426510d4147ab5ebaa281eb3480eb5bf8c09648b143f46a9c40
+  metadata.gz: 87a613b9da2addba3344ec53859a248cfbdc6805f7e24a87797b92f0487a1697
+  data.tar.gz: 61b5686efef0f8bc03ff948ef5053330b067318d1535ffbdcdc84b0b29ccc80a
 SHA512:
-  metadata.gz: 2e555b99d0fca2a6e4a2da4cc5b36313d8823d4736c205187f52bab79670e839251cd22f47ba525c171ca3cff6dc59559b95969f3c7fc6aa103ff7d38f1144fa
-  data.tar.gz: 8a2c8b5e18b55c1f5813e33f2ebe03c86610de90c96b6d805bded2f79278da2897862a97bf70de5843135086373435e22bffc71f10b9aaf71b67d118797731e7
+  metadata.gz: e70eef5d6ccd57d8ae2eb766493cf16ba26eee6ed5e210c0340e87c11e7c7f80881cdd3e1513bff1fe7a46417972709f1f65988ebd254a624cffc004d7f8459a
+  data.tar.gz: ecf60bcaebaf6cd10498762858a47690ec0550b8259659fcef5af635090cf82120826fb8e15163610ed0497bc62920175815325715b893460910af4766b74fe0

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

@@ -19,7 +19,7 @@ module Spoom
             "in `#{files.size}` file#{files.size == 1 ? "" : "s"}...\n\n")
 
           transformed_files = transform_files(files) do |file, contents|
-            Spoom::Sorbet::Assertions.rbi_to_rbs(contents, file: file)
+            Spoom::Sorbet::Translate.sorbet_assertions_to_rbs_comments(contents, file: file)
           end
 
           say("Translated type assertions in `#{transformed_files}` file#{transformed_files == 1 ? "" : "s"}.")

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/sigs.rb

@@ -1,8 +1,6 @@
 # typed: true
 # frozen_string_literal: true
 
-require "spoom/sorbet/sigs"
-
 module Spoom
   module Cli
     module Srb
@@ -34,12 +32,12 @@ module Spoom
 
           case from
           when "rbi"
-            transformed_files = transform_files(files) do |_file, contents|
-              Spoom::Sorbet::Sigs.rbi_to_rbs(contents, positional_names: options[:positional_names])
+            transformed_files = transform_files(files) do |file, contents|
+              Spoom::Sorbet::Translate.sorbet_sigs_to_rbs_comments(contents, file: file, positional_names: options[:positional_names])
             end
           when "rbs"
-            transformed_files = transform_files(files) do |_file, contents|
-              Spoom::Sorbet::Sigs.rbs_to_rbi(contents)
+            transformed_files = transform_files(files) do |file, contents|
+              Spoom::Sorbet::Translate.rbs_comments_to_sorbet_sigs(contents, file: file)
             end
           end
 
@@ -52,8 +50,8 @@ module Spoom
 
           say("Stripping signatures from `#{files.size}` file#{files.size == 1 ? "" : "s"}...\n\n")
 
-          transformed_files = transform_files(files) do |_file, contents|
-            Spoom::Sorbet::Sigs.strip(contents)
+          transformed_files = transform_files(files) do |file, contents|
+            Spoom::Sorbet::Translate.strip_sorbet_sigs(contents, file: file)
           end
 
           say("Stripped signatures from `#{transformed_files}` file#{transformed_files == 1 ? "" : "s"}.")
@@ -93,8 +91,8 @@ module Spoom
           # Then, we transform the copied files to translate all the RBS signatures into RBI signatures.
           say("Translating signatures from RBS to RBI...")
           files = collect_files([copy_context.absolute_path])
-          transform_files(files) do |_file, contents|
-            Spoom::Sorbet::Sigs.rbs_to_rbi(contents)
+          transform_files(files) do |file, contents|
+            Spoom::Sorbet::Translate.rbs_comments_to_sorbet_sigs(contents, file: file)
           end
 
           # We need to inject `extend T::Sig` to be sure all the classes can run the `sig{}` blocks.

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/deadcode/index.rb

@@ -49,10 +49,10 @@ module Spoom
 
       #: (String rb, file: String, ?plugins: Array[Plugins::Base]) -> void
       def index_ruby(rb, file:, plugins: [])
-        node, comments = Spoom.parse_ruby_with_comments(rb, file: file)
+        node = Spoom.parse_ruby(rb, file: file, comments: true)
 
         # Index definitions
-        model_builder = Model::Builder.new(@model, file, comments: comments)
+        model_builder = Model::Builder.new(@model, file)
         model_builder.visit(node)
 
         # Index references

data/lib/spoom/deadcode/plugins/active_record.rb

@@ -41,6 +41,11 @@ module Spoom
           "before_validation",
         ].freeze #: Array[String]
 
+        CALLBACK_CONDITIONS = [
+          "if",
+          "unless",
+        ].freeze #: Array[String]
+
         CRUD_METHODS = [
           "assign_attributes",
           "create",
@@ -63,9 +68,23 @@ module Spoom
         #: (Send send) -> void
         def on_send(send)
           if send.recv.nil? && CALLBACKS.include?(send.name)
+            # Process direct symbol arguments
             send.each_arg(Prism::SymbolNode) do |arg|
               @index.reference_method(arg.unescaped, send.location)
             end
+
+            # Process hash arguments for conditions like if: :method_name
+            send.each_arg_assoc do |key, value|
+              key = key.slice.delete_suffix(":")
+
+              case key
+              when *CALLBACK_CONDITIONS
+                if value&.is_a?(Prism::SymbolNode)
+                  @index.reference_method(value.unescaped, send.location)
+                end
+              end
+            end
+
             return
           end
 

data/lib/spoom/model/builder.rb

@@ -5,15 +5,12 @@ module Spoom
   class Model
     # Populate a Model by visiting the nodes from a Ruby file
     class Builder < NamespaceVisitor
-      #: (Model model, String file, ?comments: Array[Prism::Comment]) -> void
-      def initialize(model, file, comments:)
+      #: (Model model, String file) -> void
+      def initialize(model, file)
         super()
 
         @model = model
         @file = file
-        @comments_by_line = comments.to_h do |c|
-          [c.location.start_line, c]
-        end #: Hash[Integer, Prism::Comment]
         @namespace_nesting = [] #: Array[Namespace]
         @visibility_stack = [Visibility::Public] #: Array[Visibility]
         @last_sigs = [] #: Array[Sig]
@@ -263,22 +260,20 @@ module Spoom
 
       #: (Prism::Node node) -> Array[Comment]
       def node_comments(node)
+        last_line = node.location.start_line
         comments = []
 
-        start_line = node.location.start_line
-        start_line -= 1 unless @comments_by_line.key?(start_line)
+        node.location.leading_comments.reverse_each do |comment|
+          if comment.location.start_line < last_line - 1
+            break
+          end
 
-        start_line.downto(1) do |line|
-          comment = @comments_by_line[line]
-          break unless comment
+          last_line = comment.location.start_line
 
-          spoom_comment = Comment.new(
+          comments.unshift(Comment.new(
             comment.slice.gsub(/^#\s?/, "").rstrip,
             Location.from_prism(@file, comment.location),
-          )
-
-          comments.unshift(spoom_comment)
-          @comments_by_line.delete(line)
+          ))
         end
 
         comments

data/lib/spoom/model/model.rb

@@ -84,7 +84,7 @@ module Spoom
       #: Array[Comment]
       attr_reader :comments
 
-      #: (Symbol symbol, owner: Namespace?, location: Location, ?comments: Array[Comment]) -> void
+      #: (Symbol symbol, owner: Namespace?, location: Location, comments: Array[Comment]) -> void
       def initialize(symbol, owner:, location:, comments:)
         @symbol = symbol
         @owner = owner

data/lib/spoom/parse.rb

@@ -7,8 +7,8 @@ module Spoom
   class ParseError < Error; end
 
   class << self
-    #: (String ruby, file: String) -> Prism::Node
-    def parse_ruby(ruby, file:)
+    #: (String ruby, file: String, ?comments: bool) -> Prism::Node
+    def parse_ruby(ruby, file:, comments: false)
       result = Prism.parse(ruby)
       unless result.success?
         message = +"Error while parsing #{file}:\n"
@@ -20,23 +20,9 @@ module Spoom
         raise ParseError, message
       end
 
-      result.value
-    end
-
-    #: (String ruby, file: String) -> [Prism::Node, Array[Prism::Comment]]
-    def parse_ruby_with_comments(ruby, file:)
-      result = Prism.parse(ruby)
-      unless result.success?
-        message = +"Error while parsing #{file}:\n"
-
-        result.errors.each do |e|
-          message << "- #{e.message} (at #{e.location.start_line}:#{e.location.start_column})\n"
-        end
+      result.attach_comments! if comments
 
-        raise ParseError, message
-      end
-
-      [result.value, result.comments]
+      result.value
     end
   end
 end

data/lib/spoom/rbs.rb

@@ -0,0 +1,77 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module RBS
+    class Comments
+      #: Array[Annotations]
+      attr_reader :annotations
+
+      #: Array[Signature]
+      attr_reader :signatures
+
+      #: -> void
+      def initialize
+        @annotations = [] #: Array[Annotations]
+        @signatures = [] #: Array[Signature]
+      end
+
+      #: -> bool
+      def empty?
+        @annotations.empty? && @signatures.empty?
+      end
+    end
+
+    class Comment
+      #: String
+      attr_reader :string
+
+      #: Prism::Location
+      attr_reader :location
+
+      #: (String, Prism::Location) -> void
+      def initialize(string, location)
+        @string = string
+        @location = location
+      end
+    end
+
+    class Annotations < Comment; end
+    class Signature < Comment; end
+
+    module ExtractRBSComments
+      #: (Prism::Node) -> Comments
+      def node_rbs_comments(node)
+        res = Comments.new
+
+        comments = node.location.leading_comments.reverse
+        return res if comments.empty?
+
+        continuation_comments = [] #: Array[Prism::Comment]
+
+        comments.each do |comment|
+          string = comment.slice
+
+          if string.start_with?("# @")
+            string = string.delete_prefix("#").strip
+            res.annotations << Annotations.new(string, comment.location)
+          elsif string.start_with?("#: ")
+            string = string.delete_prefix("#:").strip
+            location = comment.location
+
+            continuation_comments.reverse_each do |continuation_comment|
+              string = "#{string}#{continuation_comment.slice.delete_prefix("#|")}"
+              location = location.join(continuation_comment.location)
+            end
+            continuation_comments.clear
+            res.signatures << Signature.new(string, location)
+          elsif string.start_with?("#|")
+            continuation_comments << comment
+          end
+        end
+
+        res
+      end
+    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