spoom 1.5.0 → 1.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff274fd4bbf10a58317e281a8e570908fc9827ff74799cb2380d3b90f032240e
-  data.tar.gz: 16d95b8b1311eade324cbd6086b7f4fd2a30a760478582571cc6f88768a593d5
+  metadata.gz: 59987238a3b2bae115f02d1da2a7e2a4cd6b3532d816bbe80d9153fa7819f989
+  data.tar.gz: d7e6bccfa046b7c457cb3e5d3d4383141243949021bd584b22cde0db0cc165ef
 SHA512:
-  metadata.gz: 90b22051252521cf38c3ed26a4e728526e57e190f0f1cd8aca1f2574f9f6219f608f28905ab4fb6dca1d54e04834182e470f9da779d664f205d269fb6ac4c0e4
-  data.tar.gz: 3aa88be0f3edb8f2cc32d89e76ff83833f295204d3739424c6ea35dbe48db4df41a325771f840451b6bea1ed5e329ee2efaefd2c503a76ee483590f751a3017a
+  metadata.gz: b2f53478b7fdee59bfa7c579c3686b6d6c388db8737584c02f613daa2c4d42c0be2c1baaa39c50e90137697f62d7b8bb04e9fdbb458defdfa7813be3b6cbbd36
+  data.tar.gz: 57b26d457d2235bedaff15c832accc34a9c5ffcb89876306394f12b74a87ce03964d0309cd62e213e9954607150968607227436ebeb522a84f27782f7cc8cac8

data/README.md

@@ -221,6 +221,20 @@ Count the number of type-checking errors if all files were bumped to true:
 $ spoom srb bump --count-errors --dry
 ```
 
+#### Translate sigs between RBI and RBS
+
+Translate all file sigs from RBI to RBS:
+
+```
+$ spoom srb sigs translate
+```
+
+Translate one file's sigs from RBS to RBI:
+
+```
+$ spoom srb sigs translate --from rbs --to rbi /path/to/file.rb
+```
+
 #### Interact with Sorbet LSP mode
 
 **Experimental**

data/lib/spoom/backtrace_filter/minitest.rb

@@ -6,11 +6,10 @@ require "minitest"
 module Spoom
   module BacktraceFilter
     class Minitest < ::Minitest::BacktraceFilter
-      extend T::Sig
+      SORBET_PATHS = Gem.loaded_specs["sorbet-runtime"].full_require_paths.freeze #: Array[String]
 
-      SORBET_PATHS = T.let(Gem.loaded_specs["sorbet-runtime"].full_require_paths.freeze, T::Array[String])
-
-      sig { override.params(bt: T.nilable(T::Array[String])).returns(T::Array[String]) }
+      # @override
+      #: (Array[String]? bt) -> Array[String]
       def filter(bt)
         super.select do |line|
           SORBET_PATHS.none? { |path| line.include?(path) }

data/lib/spoom/cli/deadcode.rb

@@ -6,7 +6,6 @@ require_relative "../deadcode"
 module Spoom
   module Cli
     class Deadcode < Thor
-      extend T::Sig
       include Helper
 
       default_task :deadcode
@@ -48,7 +47,7 @@ module Spoom
         default: "name",
         enum: ["name", "location"],
         desc: "Sort the output by name or location"
-      sig { params(paths: String).void }
+      #: (*String paths) -> void
       def deadcode(*paths)
         context = self.context
 

data/lib/spoom/cli/helper.rb

@@ -8,7 +8,6 @@ require "stringio"
 module Spoom
   module Cli
     module Helper
-      extend T::Sig
       extend T::Helpers
 
       include Colorize
@@ -16,7 +15,7 @@ module Spoom
       requires_ancestor { Thor }
 
       # Print `message` on `$stdout`
-      sig { params(message: String).void }
+      #: (String message) -> void
       def say(message)
         buffer = StringIO.new
         buffer << highlight(message)
@@ -29,13 +28,7 @@ module Spoom
       # Print `message` on `$stderr`
       #
       # The message is prefixed by a status (default: `Error`).
-      sig do
-        params(
-          message: String,
-          status: T.nilable(String),
-          nl: T::Boolean,
-        ).void
-      end
+      #: (String message, ?status: String?, ?nl: bool) -> void
       def say_error(message, status: "Error", nl: true)
         buffer = StringIO.new
         buffer << "#{red(status)}: " if status
@@ -49,13 +42,7 @@ module Spoom
       # Print `message` on `$stderr`
       #
       # The message is prefixed by a status (default: `Warning`).
-      sig do
-        params(
-          message: String,
-          status: T.nilable(String),
-          nl: T::Boolean,
-        ).void
-      end
+      #: (String message, ?status: String?, ?nl: bool) -> void
       def say_warning(message, status: "Warning", nl: true)
         buffer = StringIO.new
         buffer << "#{yellow(status)}: " if status
@@ -67,13 +54,13 @@ module Spoom
       end
 
       # Returns the context at `--path` (by default the current working directory)
-      sig { returns(Context) }
+      #: -> Context
       def context
-        @context ||= T.let(Context.new(exec_path), T.nilable(Context))
+        @context ||= Context.new(exec_path) #: Context?
       end
 
       # Raise if `spoom` is not ran inside a context with a `sorbet/config` file
-      sig { returns(Context) }
+      #: -> Context
       def context_requiring_sorbet!
         context = self.context
         unless context.has_sorbet_config?
@@ -88,29 +75,52 @@ module Spoom
       end
 
       # Return the path specified through `--path`
-      sig { returns(String) }
+      #: -> String
       def exec_path
         options[:path]
       end
 
+      # Collect files from `paths`, defaulting to `exec_path`
+      #: (Array[String] paths, ?include_rbi_files: bool) -> Array[String]
+      def collect_files(paths, include_rbi_files: false)
+        paths << exec_path if paths.empty?
+
+        files = paths.flat_map do |path|
+          if File.file?(path)
+            path
+          else
+            exts = ["rb"]
+            exts << "rbi" if include_rbi_files
+            Dir.glob("#{path}/**/*.{#{exts.join(",")}}")
+          end
+        end
+
+        if files.empty?
+          say_error("No files found")
+          exit(1)
+        end
+
+        files
+      end
+
       # Colors
 
       # Color used to highlight expressions in backticks
-      HIGHLIGHT_COLOR = T.let(Spoom::Color::BLUE, Spoom::Color)
+      HIGHLIGHT_COLOR = Spoom::Color::BLUE #: Spoom::Color
 
       # Is the `--color` option true?
-      sig { returns(T::Boolean) }
+      #: -> bool
       def color?
         options[:color]
       end
 
-      sig { params(string: String).returns(String) }
+      #: (String string) -> String
       def highlight(string)
         return string unless color?
 
         res = StringIO.new
         word = StringIO.new
-        in_ticks = T.let(false, T::Boolean)
+        in_ticks = false #: bool
         string.chars.each do |c|
           if c == "`" && !in_ticks
             in_ticks = true
@@ -128,39 +138,39 @@ module Spoom
       end
 
       # Colorize a string if `color?`
-      sig { params(string: String, color: Color).returns(String) }
+      #: (String string, *Color color) -> String
       def colorize(string, *color)
         return string unless color?
 
         T.unsafe(self).set_color(string, *color)
       end
 
-      sig { params(string: String).returns(String) }
+      #: (String string) -> String
       def blue(string)
         colorize(string, Color::BLUE)
       end
 
-      sig { params(string: String).returns(String) }
+      #: (String string) -> String
       def cyan(string)
         colorize(string, Color::CYAN)
       end
 
-      sig { params(string: String).returns(String) }
+      #: (String string) -> String
       def gray(string)
         colorize(string, Color::LIGHT_BLACK)
       end
 
-      sig { params(string: String).returns(String) }
+      #: (String string) -> String
       def green(string)
         colorize(string, Color::GREEN)
       end
 
-      sig { params(string: String).returns(String) }
+      #: (String string) -> String
       def red(string)
         colorize(string, Color::RED)
       end
 
-      sig { params(string: String).returns(String) }
+      #: (String string) -> String
       def yellow(string)
         colorize(string, Color::YELLOW)
       end

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

@@ -0,0 +1,48 @@
+# typed: true
+# frozen_string_literal: true
+
+module Spoom
+  module Cli
+    module Srb
+      class Assertions < Thor
+        include Helper
+
+        desc "translate", "Translate type assertions from/to RBI and RBS"
+        option :from, type: :string, aliases: :f, desc: "From format", enum: ["rbi"], default: "rbi"
+        option :to, type: :string, aliases: :t, desc: "To format", enum: ["rbs"], default: "rbs"
+        def translate(*paths)
+          from = options[:from]
+          to = options[:to]
+          files = collect_files(paths)
+
+          say("Translating type assertions from `#{from}` to `#{to}` " \
+            "in `#{files.size}` file#{files.size == 1 ? "" : "s"}...\n\n")
+
+          transformed_files = transform_files(files) do |file, contents|
+            Spoom::Sorbet::Translate.sorbet_assertions_to_rbs_comments(contents, file: file)
+          end
+
+          say("Translated type assertions in `#{transformed_files}` file#{transformed_files == 1 ? "" : "s"}.")
+        end
+
+        no_commands do
+          def transform_files(files, &block)
+            transformed_count = 0
+
+            files.each do |file|
+              contents = File.read(file)
+              contents = block.call(file, contents)
+              File.write(file, contents)
+              transformed_count += 1
+            rescue Spoom::ParseError => error
+              say_warning("Can't parse #{file}: #{error.message}")
+              next
+            end
+
+            transformed_count
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -8,7 +8,6 @@ module Spoom
   module Cli
     module Srb
       class Bump < Thor
-        extend T::Sig
         include Helper
 
         default_task :bump
@@ -46,7 +45,7 @@ module Spoom
           default: false,
           desc: "Count the number of errors if all files were bumped"
         option :sorbet_options, type: :string, default: "", desc: "Pass options to Sorbet"
-        sig { params(directory: String).void }
+        #: (?String directory) -> void
         def bump(directory = ".")
           context = context_requiring_sorbet!
           from = options[:from]

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

@@ -89,7 +89,7 @@ module Spoom
 
             context.git_checkout!(ref: commit.sha)
 
-            snapshot = T.let(nil, T.nilable(Spoom::Coverage::Snapshot))
+            snapshot = nil #: Spoom::Coverage::Snapshot?
             if options[:bundle_install]
               Bundler.with_unbundled_env do
                 next unless bundle_install(path, commit.sha)

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

@@ -0,0 +1,209 @@
+# typed: true
+# frozen_string_literal: true
+
+module Spoom
+  module Cli
+    module Srb
+      class Sigs < Thor
+        include Helper
+
+        desc "translate", "Translate signatures from/to RBI and RBS"
+        option :from, type: :string, aliases: :f, desc: "From format", enum: ["rbi", "rbs"], default: "rbi"
+        option :to, type: :string, aliases: :t, desc: "To format", enum: ["rbi", "rbs"], default: "rbs"
+        option :positional_names,
+          type: :boolean,
+          aliases: :p,
+          desc: "Use positional names when translating from RBI to RBS",
+          default: true
+        option :include_rbi_files, type: :boolean, desc: "Include RBI files", default: false
+        def translate(*paths)
+          from = options[:from]
+          to = options[:to]
+
+          if from == to
+            say_error("Can't translate signatures from `#{from}` to `#{to}`")
+            exit(1)
+          end
+
+          files = collect_files(paths, include_rbi_files: options[:include_rbi_files])
+
+          say("Translating signatures from `#{from}` to `#{to}` " \
+            "in `#{files.size}` file#{files.size == 1 ? "" : "s"}...\n\n")
+
+          case from
+          when "rbi"
+            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::Translate.rbs_comments_to_sorbet_sigs(contents, file: file)
+            end
+          end
+
+          say("Translated signatures in `#{transformed_files}` file#{transformed_files == 1 ? "" : "s"}.")
+        end
+
+        desc "strip", "Strip all the signatures from the files"
+        def strip(*paths)
+          files = collect_files(paths)
+
+          say("Stripping signatures from `#{files.size}` file#{files.size == 1 ? "" : "s"}...\n\n")
+
+          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"}.")
+        end
+
+        # Extract signatures from gem's files and save them to the output file
+        #
+        # This command will use Tapioca to generate a `.rbi` file that contains the signatures of all the files listed
+        # in the gemspec.
+        desc "export", "Export gem files signatures"
+        option :gemspec, type: :string, desc: "Path to the gemspec file", optional: true, default: nil
+        option :check_sync, type: :boolean, desc: "Check the generated RBI is up to date", default: false
+        def export(output_path = nil)
+          gemspec = options[:gemspec]
+
+          unless gemspec
+            say("Locating gemspec file...")
+            gemspec = Dir.glob("*.gemspec").first
+            unless gemspec
+              say_error("No gemspec file found")
+              exit(1)
+            end
+            say("Using `#{gemspec}` as gemspec file")
+          end
+
+          spec = Gem::Specification.load(gemspec)
+
+          # First, we copy the files to a temporary directory so we can rewrite them without messing with the
+          # original ones.
+          say("Copying files to a temporary directory...")
+          copy_context = Spoom::Context.mktmp!
+          FileUtils.cp_r(
+            ["Gemfile", "Gemfile.lock", gemspec, "lib/"],
+            copy_context.absolute_path,
+          )
+
+          # 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::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.
+          # For this we find the entry point of the gem and inject the `extend T::Sig` line at the top of the file.
+          entry_point = "lib/#{spec.name}.rb"
+          unless copy_context.file?(entry_point)
+            say_error("No entry point found at `#{entry_point}`")
+            exit(1)
+          end
+
+          say("Injecting `extend T::Sig` to `#{entry_point}`...")
+          copy_context.write!(entry_point, <<~RB)
+            require "sorbet-runtime"
+
+            class Module; include T::Sig; end
+            extend T::Sig
+
+            #{copy_context.read(entry_point)}
+          RB
+
+          # Now we create a new context to import our modified gem and run tapioca
+          say("Running Tapioca...")
+          tapioca_context = Spoom::Context.mktmp!
+          tapioca_context.write!("Gemfile", <<~RB)
+            source "https://rubygems.org"
+
+            gem "tapioca"
+            gem "#{spec.name}", path: "#{copy_context.absolute_path}"
+          RB
+          exec(tapioca_context, "bundle install")
+          exec(tapioca_context, "bundle exec tapioca gem #{spec.name} --no-doc --no-loc --no-file-header")
+
+          rbi_path = tapioca_context.glob("sorbet/rbi/gems/#{spec.name}@*.rbi").first
+          unless rbi_path && tapioca_context.file?(rbi_path)
+            say_error("No RBI file found at `sorbet/rbi/gems/#{spec.name}@*.rbi`")
+            exit(1)
+          end
+
+          tapioca_context.write!(rbi_path, tapioca_context.read(rbi_path).gsub(/^# typed: true/, <<~RB.rstrip))
+            # typed: true
+
+            # DO NOT EDIT MANUALLY
+            # This is an autogenerated file for types exported from the `#{spec.name}` gem.
+            # Please instead update this file by running `spoom srb sigs export`.
+          RB
+
+          output_path ||= "rbi/#{spec.name}.rbi"
+          generated_path = tapioca_context.absolute_path_to(rbi_path)
+
+          if options[:check_sync]
+            # If the check option is set, we just compare the generated RBI with the one in the gem.
+            # If they are different, we exit with a non-zero exit code.
+            unless system("diff -u -L 'generated' -L 'current' #{generated_path} #{output_path} >&2")
+              say_error(<<~ERR, status: "\nError")
+                The RBI file at `#{output_path}` is not up to date
+
+                Please run `spoom srb sigs export` to update it.
+              ERR
+              exit(1)
+            end
+
+            say("The RBI file at `#{output_path}` is up to date")
+            exit(0)
+          else
+            output_dir = File.dirname(output_path)
+            FileUtils.rm_rf(output_dir)
+            FileUtils.mkdir_p(output_dir)
+            FileUtils.cp(generated_path, output_path)
+
+            say("Exported signatures to `#{output_path}`")
+          end
+        ensure
+          copy_context&.destroy!
+          tapioca_context&.destroy!
+        end
+
+        no_commands do
+          def transform_files(files, &block)
+            transformed_count = 0
+
+            files.each do |file|
+              contents = File.read(file)
+              first_line = contents.lines.first
+
+              if first_line&.start_with?("# encoding:")
+                encoding = T.must(first_line).gsub(/^#\s*encoding:\s*/, "").strip
+                contents = contents.force_encoding(encoding)
+              end
+
+              contents = block.call(file, contents)
+              File.write(file, contents)
+              transformed_count += 1
+            rescue RBI::Error => error
+              say_warning("Can't parse #{file}: #{error.message}")
+              next
+            end
+
+            transformed_count
+          end
+
+          def exec(context, command)
+            res = context.exec(command)
+
+            unless res.status
+              $stderr.puts "Error: #{command} failed"
+              $stderr.puts res.err
+              exit(1)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -22,6 +22,7 @@ module Spoom
         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 :junit_output_path, type: :string, desc: "Output failures to XML file formatted for JUnit"
         option :sorbet, type: :string, desc: "Path to custom Sorbet bin"
         option :sorbet_options, type: :string, default: "", desc: "Pass options to Sorbet"
         def tc(*paths_to_select)
@@ -32,6 +33,7 @@ module Spoom
           uniq = options[:uniq]
           format = options[:format]
           count = options[:count]
+          junit_output_path = options[:junit_output_path]
           sorbet = options[:sorbet]
 
           unless limit || code || sort
@@ -55,6 +57,12 @@ module Spoom
 
           if result.status
             say_error(result.err, status: nil, nl: false)
+            if junit_output_path
+              doc = Spoom::Sorbet::Errors.to_junit_xml([])
+              file = File.open(junit_output_path, "w")
+              doc.write(output: file, indent: 2)
+              file.close
+            end
             exit(0)
           end
 
@@ -94,6 +102,13 @@ module Spoom
             say_error(line, status: nil)
           end
 
+          if junit_output_path
+            doc = Spoom::Sorbet::Errors.to_junit_xml(errors)
+            file = File.open(junit_output_path, "w")
+            doc.write(output: file, indent: 2)
+            file.close
+          end
+
           if count
             if errors_count == errors.size
               say_error("Errors: #{errors_count}", status: nil)
@@ -132,7 +147,7 @@ module Spoom
           def colorize_message(message)
             return message unless color?
 
-            cyan = T.let(false, T::Boolean)
+            cyan = false #: bool
             word = StringIO.new
             message.chars.each do |c|
               if c == "`"

data/lib/spoom/cli/srb.rb

@@ -1,23 +1,35 @@
 # typed: strict
 # frozen_string_literal: true
 
+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"
 
 module Spoom
   module Cli
     module Srb
       class Main < Thor
-        desc "lsp", "Send LSP requests to Sorbet"
-        subcommand "lsp", Spoom::Cli::Srb::LSP
+        desc "assertions", "Translate type assertions from/to RBI and RBS"
+        subcommand "assertions", Spoom::Cli::Srb::Assertions
+
+        desc "bump", "Change Sorbet sigils from one strictness to another when no errors"
+        subcommand "bump", Spoom::Cli::Srb::Bump
 
         desc "coverage", "Collect metrics related to Sorbet coverage"
         subcommand "coverage", Spoom::Cli::Srb::Coverage
 
-        desc "bump", "Change Sorbet sigils from one strictness to another when no errors"
-        subcommand "bump", Spoom::Cli::Srb::Bump
+        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
 
         desc "tc", "Run typechecking with advanced options"
         subcommand "tc", Spoom::Cli::Srb::Tc