spoom 1.5.4 → 1.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9bc28693fcde4f611e66f65d11d3a33c99e99a3ecf9bc7c7446d42e0db193cda
-  data.tar.gz: 7c5ef49d91e54b10dd435794e68497364473e7a977a84df5ba3229966a7ea77f
+  metadata.gz: ebcf07d1aa065b643270105e211a05e9698befb8a67cf307c87c2fb957cd69fa
+  data.tar.gz: 4de71559b8d0812d7ab2456404cdf1ec840bd7031c7138a04e3233208ab8f827
 SHA512:
-  metadata.gz: 6e487003f4b3ff1b6250cfd91770a5b2aa0ecd06587e0f90f3a5b8955626f35fa98a6075f75ea35f2a49db78f38c019964d67777e2797635225ac9821c9e225d
-  data.tar.gz: 6a21e1986075cf301e79e9b544c0fe30b0929eb328eaceef3ff079a5b92bbcce254f3d3dfbe75e36ef78b30bfac04be029f4078185ce42667423692be71227d8
+  metadata.gz: ffd0520b3dcce46ea2ee2e00f4f7de974cedf21eddc706bed67616696f3f23406cbee80aeb62715c7dbfa7562a88486e21b6424b84b62d9f9a13b0a2d2f287b9
+  data.tar.gz: 7a7256c1a7114e46254d0cd648306ee8b1e9565522671318c710af33a571461da14b40e0d99405e63a12481f05c29b35bc3d0e660c8e7129928f1a9c34264ca9

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 = 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))
       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,23 +75,44 @@ 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) -> Array[String]
+      def collect_files(paths)
+        paths << exec_path if paths.empty?
+
+        files = paths.flat_map do |path|
+          if File.file?(path)
+            path
+          else
+            Dir.glob("#{path}/**/*.rb")
+          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)
 
       # 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?
 
@@ -128,39 +136,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::Assertions.rbi_to_rbs(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/sigs.rb

@@ -7,22 +7,34 @@ module Spoom
   module Cli
     module Srb
       class Sigs < Thor
-        extend T::Sig
         include Helper
 
         desc "translate", "Translate signatures 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"
+        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"
         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)
 
           say("Translating signatures from `#{from}` to `#{to}` " \
             "in `#{files.size}` file#{files.size == 1 ? "" : "s"}...\n\n")
 
-          transformed_files = transform_files(files) do |_file, contents|
-            Spoom::Sorbet::Sigs.rbi_to_rbs(contents)
+          case from
+          when "rbi"
+            transformed_files = transform_files(files) do |_file, contents|
+              Spoom::Sorbet::Sigs.rbi_to_rbs(contents)
+            end
+          when "rbs"
+            transformed_files = transform_files(files) do |_file, contents|
+              Spoom::Sorbet::Sigs.rbs_to_rbi(contents)
+            end
           end
 
           say("Translated signatures in `#{transformed_files}` file#{transformed_files == 1 ? "" : "s"}.")
@@ -41,26 +53,119 @@ module Spoom
           say("Stripped signatures from `#{transformed_files}` file#{transformed_files == 1 ? "" : "s"}.")
         end
 
-        no_commands do
-          def collect_files(paths)
-            paths << "." if paths.empty?
-
-            files = paths.flat_map do |path|
-              if File.file?(path)
-                [path]
-              else
-                Dir.glob("#{path}/**/*.rb")
-              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::Sigs.rbs_to_rbi(contents)
+          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
 
-            if files.empty?
-              say_error("No files to transform")
+          # 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-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
 
-            files
+            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
 
@@ -83,6 +188,16 @@ module Spoom
 
             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

data/lib/spoom/cli/srb.rb

@@ -1,6 +1,7 @@
 # typed: strict
 # frozen_string_literal: true
 
+require_relative "srb/assertions"
 require_relative "srb/bump"
 require_relative "srb/coverage"
 require_relative "srb/lsp"
@@ -11,14 +12,17 @@ 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 "sigs", "Translate signatures from/to RBI and RBS"
         subcommand "sigs", Spoom::Cli::Srb::Sigs

data/lib/spoom/cli.rb

@@ -10,7 +10,6 @@ require_relative "cli/srb"
 module Spoom
   module Cli
     class Main < Thor
-      extend T::Sig
       include Helper
 
       class_option :color, type: :boolean, default: true, desc: "Use colors"
@@ -54,7 +53,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 = ".")
         say_warning("This command is deprecated. Please use `spoom srb bump` instead.")
 

data/lib/spoom/colors.rb

@@ -3,8 +3,6 @@
 
 module Spoom
   class Color < T::Enum
-    extend T::Sig
-
     enums do
       CLEAR           = new("\e[0m")
       BOLD            = new("\e[1m")
@@ -28,16 +26,14 @@ module Spoom
       LIGHT_WHITE     = new("\e[97m")
     end
 
-    sig { returns(String) }
+    #: -> String
     def ansi_code
       serialize
     end
   end
 
   module Colorize
-    extend T::Sig
-
-    sig { params(string: String, color: Color).returns(String) }
+    #: (String string, *Color color) -> String
     def set_color(string, *color)
       "#{color.map(&:ansi_code).join}#{string}#{Color::CLEAR.ansi_code}"
     end

data/lib/spoom/context/bundle.rb

@@ -5,49 +5,48 @@ module Spoom
   class Context
     # Bundle features for a context
     module Bundle
-      extend T::Sig
       extend T::Helpers
 
       requires_ancestor { Context }
 
       # Read the contents of the Gemfile in this context directory
-      sig { returns(T.nilable(String)) }
+      #: -> String?
       def read_gemfile
         read("Gemfile")
       end
 
       # Read the contents of the Gemfile.lock in this context directory
-      sig { returns(T.nilable(String)) }
+      #: -> String?
       def read_gemfile_lock
         read("Gemfile.lock")
       end
 
       # Set the `contents` of the Gemfile in this context directory
-      sig { params(contents: String, append: T::Boolean).void }
+      #: (String contents, ?append: bool) -> void
       def write_gemfile!(contents, append: false)
         write!("Gemfile", contents, append: append)
       end
 
       # Run a command with `bundle` in this context directory
-      sig { params(command: String, version: T.nilable(String), capture_err: T::Boolean).returns(ExecResult) }
+      #: (String command, ?version: String?, ?capture_err: bool) -> ExecResult
       def bundle(command, version: nil, capture_err: true)
         command = "_#{version}_ #{command}" if version
         exec("bundle #{command}", capture_err: capture_err)
       end
 
       # Run `bundle install` in this context directory
-      sig { params(version: T.nilable(String), capture_err: T::Boolean).returns(ExecResult) }
+      #: (?version: String?, ?capture_err: bool) -> ExecResult
       def bundle_install!(version: nil, capture_err: true)
         bundle("install", version: version, capture_err: capture_err)
       end
 
       # Run a command `bundle exec` in this context directory
-      sig { params(command: String, version: T.nilable(String), capture_err: T::Boolean).returns(ExecResult) }
+      #: (String command, ?version: String?, ?capture_err: bool) -> ExecResult
       def bundle_exec(command, version: nil, capture_err: true)
         bundle("exec #{command}", version: version, capture_err: capture_err)
       end
 
-      sig { returns(T::Hash[String, Bundler::LazySpecification]) }
+      #: -> Hash[String, Bundler::LazySpecification]
       def gemfile_lock_specs
         return {} unless file?("Gemfile.lock")
 
@@ -58,7 +57,7 @@ module Spoom
       # Get `gem` version from the `Gemfile.lock` content
       #
       # Returns `nil` if `gem` cannot be found in the Gemfile.
-      sig { params(gem: String).returns(T.nilable(Gem::Version)) }
+      #: (String gem) -> Gem::Version?
       def gem_version_from_gemfile_lock(gem)
         gemfile_lock_specs[gem]&.version
       end

data/lib/spoom/context/exec.rb

@@ -3,14 +3,12 @@
 
 module Spoom
   class ExecResult < T::Struct
-    extend T::Sig
-
     const :out, String
     const :err, T.nilable(String)
     const :status, T::Boolean
     const :exit_code, Integer
 
-    sig { returns(String) }
+    #: -> String
     def to_s
       <<~STR
         ########## STDOUT ##########
@@ -25,13 +23,12 @@ module Spoom
   class Context
     # Execution features for a context
     module Exec
-      extend T::Sig
       extend T::Helpers
 
       requires_ancestor { Context }
 
       # Run a command in this context directory
-      sig { params(command: String, capture_err: T::Boolean).returns(ExecResult) }
+      #: (String command, ?capture_err: bool) -> ExecResult
       def exec(command, capture_err: true)
         Bundler.with_unbundled_env do
           opts = T.let({ chdir: absolute_path }, T::Hash[Symbol, T.untyped])