spoom 1.6.3 → 1.7.0

data/rbi/spoom.rbi

@@ -6,11 +6,8 @@
 
 module Spoom
   class << self
-    sig { params(ruby: ::String, file: ::String).returns(::Prism::Node) }
-    def parse_ruby(ruby, file:); end
-
-    sig { params(ruby: ::String, file: ::String).returns([::Prism::Node, T::Array[::Prism::Comment]]) }
-    def parse_ruby_with_comments(ruby, file:); end
+    sig { params(ruby: ::String, file: ::String, comments: T::Boolean).returns(::Prism::Node) }
+    def parse_ruby(ruby, file:, comments: T.unsafe(nil)); end
   end
 end
 
@@ -1133,6 +1130,7 @@ end
 
 Spoom::Deadcode::Plugins::ActiveRecord::ARRAY_METHODS = T.let(T.unsafe(nil), Array)
 Spoom::Deadcode::Plugins::ActiveRecord::CALLBACKS = T.let(T.unsafe(nil), Array)
+Spoom::Deadcode::Plugins::ActiveRecord::CALLBACK_CONDITIONS = T.let(T.unsafe(nil), Array)
 Spoom::Deadcode::Plugins::ActiveRecord::CRUD_METHODS = T.let(T.unsafe(nil), Array)
 
 class Spoom::Deadcode::Plugins::ActiveSupport < ::Spoom::Deadcode::Plugins::Base
@@ -2100,8 +2098,8 @@ class Spoom::Model::AttrReader < ::Spoom::Model::Attr; end
 class Spoom::Model::AttrWriter < ::Spoom::Model::Attr; end
 
 class Spoom::Model::Builder < ::Spoom::Model::NamespaceVisitor
-  sig { params(model: ::Spoom::Model, file: ::String, comments: T::Array[::Prism::Comment]).void }
-  def initialize(model, file, comments:); end
+  sig { params(model: ::Spoom::Model, file: ::String).void }
+  def initialize(model, file); end
 
   sig { override.params(node: ::Prism::CallNode).void }
   def visit_call_node(node); end
@@ -2554,117 +2552,42 @@ class Spoom::Printer
   def printt; end
 end
 
-Spoom::SPOOM_PATH = T.let(T.unsafe(nil), String)
-module Spoom::Sorbet; end
-
-class Spoom::Sorbet::Assertions
-  class << self
-    sig { params(ruby_contents: ::String, file: ::String).returns(::String) }
-    def rbi_to_rbs(ruby_contents, file:); end
-
-    private
-
-    sig { params(ruby_contents: ::String, file: ::String).returns(T::Array[::Spoom::Sorbet::Assertions::AssignNode]) }
-    def collect_assigns(ruby_contents, file:); end
-
-    sig { params(assign: ::Spoom::Sorbet::Assertions::AssignNode).returns(::String) }
-    def dedent_value(assign); end
-  end
-end
+module Spoom::RBS; end
+class Spoom::RBS::Annotations < ::Spoom::RBS::Comment; end
 
-class Spoom::Sorbet::Assertions::AssignNode
-  sig do
-    params(
-      node: T.any(::Prism::ClassVariableAndWriteNode, ::Prism::ClassVariableOperatorWriteNode, ::Prism::ClassVariableOrWriteNode, ::Prism::ClassVariableWriteNode, ::Prism::ConstantAndWriteNode, ::Prism::ConstantOperatorWriteNode, ::Prism::ConstantOrWriteNode, ::Prism::ConstantPathAndWriteNode, ::Prism::ConstantPathOperatorWriteNode, ::Prism::ConstantPathOrWriteNode, ::Prism::ConstantPathWriteNode, ::Prism::ConstantWriteNode, ::Prism::GlobalVariableAndWriteNode, ::Prism::GlobalVariableOperatorWriteNode, ::Prism::GlobalVariableOrWriteNode, ::Prism::GlobalVariableWriteNode, ::Prism::InstanceVariableAndWriteNode, ::Prism::InstanceVariableOperatorWriteNode, ::Prism::InstanceVariableOrWriteNode, ::Prism::InstanceVariableWriteNode, ::Prism::LocalVariableAndWriteNode, ::Prism::LocalVariableOperatorWriteNode, ::Prism::LocalVariableOrWriteNode, ::Prism::LocalVariableWriteNode),
-      operator_loc: ::Prism::Location,
-      value: ::Prism::Node,
-      type: ::Prism::Node
-    ).void
-  end
-  def initialize(node, operator_loc, value, type); end
-
-  sig do
-    returns(T.any(::Prism::ClassVariableAndWriteNode, ::Prism::ClassVariableOperatorWriteNode, ::Prism::ClassVariableOrWriteNode, ::Prism::ClassVariableWriteNode, ::Prism::ConstantAndWriteNode, ::Prism::ConstantOperatorWriteNode, ::Prism::ConstantOrWriteNode, ::Prism::ConstantPathAndWriteNode, ::Prism::ConstantPathOperatorWriteNode, ::Prism::ConstantPathOrWriteNode, ::Prism::ConstantPathWriteNode, ::Prism::ConstantWriteNode, ::Prism::GlobalVariableAndWriteNode, ::Prism::GlobalVariableOperatorWriteNode, ::Prism::GlobalVariableOrWriteNode, ::Prism::GlobalVariableWriteNode, ::Prism::InstanceVariableAndWriteNode, ::Prism::InstanceVariableOperatorWriteNode, ::Prism::InstanceVariableOrWriteNode, ::Prism::InstanceVariableWriteNode, ::Prism::LocalVariableAndWriteNode, ::Prism::LocalVariableOperatorWriteNode, ::Prism::LocalVariableOrWriteNode, ::Prism::LocalVariableWriteNode))
-  end
-  def node; end
+class Spoom::RBS::Comment
+  sig { params(string: ::String, location: ::Prism::Location).void }
+  def initialize(string, location); end
 
   sig { returns(::Prism::Location) }
-  def operator_loc; end
+  def location; end
 
   sig { returns(::String) }
-  def rbs_type; end
-
-  def type; end
-
-  sig { returns(::Prism::Node) }
-  def value; end
+  def string; end
 end
 
-Spoom::Sorbet::Assertions::AssignType = T.type_alias { T.any(::Prism::ClassVariableAndWriteNode, ::Prism::ClassVariableOperatorWriteNode, ::Prism::ClassVariableOrWriteNode, ::Prism::ClassVariableWriteNode, ::Prism::ConstantAndWriteNode, ::Prism::ConstantOperatorWriteNode, ::Prism::ConstantOrWriteNode, ::Prism::ConstantPathAndWriteNode, ::Prism::ConstantPathOperatorWriteNode, ::Prism::ConstantPathOrWriteNode, ::Prism::ConstantPathWriteNode, ::Prism::ConstantWriteNode, ::Prism::GlobalVariableAndWriteNode, ::Prism::GlobalVariableOperatorWriteNode, ::Prism::GlobalVariableOrWriteNode, ::Prism::GlobalVariableWriteNode, ::Prism::InstanceVariableAndWriteNode, ::Prism::InstanceVariableOperatorWriteNode, ::Prism::InstanceVariableOrWriteNode, ::Prism::InstanceVariableWriteNode, ::Prism::LocalVariableAndWriteNode, ::Prism::LocalVariableOperatorWriteNode, ::Prism::LocalVariableOrWriteNode, ::Prism::LocalVariableWriteNode) }
-
-class Spoom::Sorbet::Assertions::Locator < ::Spoom::Visitor
+class Spoom::RBS::Comments
   sig { void }
   def initialize; end
 
-  sig { returns(T::Array[::Spoom::Sorbet::Assertions::AssignNode]) }
-  def assigns; end
-
-  sig { params(node: ::Prism::Node).returns(T::Boolean) }
-  def contains_heredoc?(node); end
-
-  sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) }
-  def t?(node); end
-
-  sig { params(node: ::Prism::CallNode).returns(T::Boolean) }
-  def t_annotation?(node); end
-
-  sig do
-    params(
-      node: T.any(::Prism::ClassVariableAndWriteNode, ::Prism::ClassVariableOperatorWriteNode, ::Prism::ClassVariableOrWriteNode, ::Prism::ClassVariableWriteNode, ::Prism::ConstantAndWriteNode, ::Prism::ConstantOperatorWriteNode, ::Prism::ConstantOrWriteNode, ::Prism::ConstantPathAndWriteNode, ::Prism::ConstantPathOperatorWriteNode, ::Prism::ConstantPathOrWriteNode, ::Prism::ConstantPathWriteNode, ::Prism::ConstantWriteNode, ::Prism::GlobalVariableAndWriteNode, ::Prism::GlobalVariableOperatorWriteNode, ::Prism::GlobalVariableOrWriteNode, ::Prism::GlobalVariableWriteNode, ::Prism::InstanceVariableAndWriteNode, ::Prism::InstanceVariableOperatorWriteNode, ::Prism::InstanceVariableOrWriteNode, ::Prism::InstanceVariableWriteNode, ::Prism::LocalVariableAndWriteNode, ::Prism::LocalVariableOperatorWriteNode, ::Prism::LocalVariableOrWriteNode, ::Prism::LocalVariableWriteNode)
-    ).void
-  end
-  def visit_assign(node); end
-
-  def visit_class_variable_and_write_node(*args, **_arg1, &blk); end
-  def visit_class_variable_operator_write_node(*args, **_arg1, &blk); end
-  def visit_class_variable_or_write_node(*args, **_arg1, &blk); end
-  def visit_class_variable_write_node(*args, **_arg1, &blk); end
-  def visit_constant_and_write_node(*args, **_arg1, &blk); end
-  def visit_constant_operator_write_node(*args, **_arg1, &blk); end
-  def visit_constant_or_write_node(*args, **_arg1, &blk); end
-  def visit_constant_path_and_write_node(*args, **_arg1, &blk); end
-  def visit_constant_path_operator_write_node(*args, **_arg1, &blk); end
-  def visit_constant_path_or_write_node(*args, **_arg1, &blk); end
-  def visit_constant_path_write_node(*args, **_arg1, &blk); end
-  def visit_constant_write_node(*args, **_arg1, &blk); end
-  def visit_global_variable_and_write_node(*args, **_arg1, &blk); end
-  def visit_global_variable_operator_write_node(*args, **_arg1, &blk); end
-  def visit_global_variable_or_write_node(*args, **_arg1, &blk); end
-  def visit_global_variable_write_node(*args, **_arg1, &blk); end
-  def visit_instance_variable_and_write_node(*args, **_arg1, &blk); end
-  def visit_instance_variable_operator_write_node(*args, **_arg1, &blk); end
-  def visit_instance_variable_or_write_node(*args, **_arg1, &blk); end
-  def visit_instance_variable_write_node(*args, **_arg1, &blk); end
-  def visit_local_variable_and_write_node(*args, **_arg1, &blk); end
-  def visit_local_variable_operator_write_node(*args, **_arg1, &blk); end
-  def visit_local_variable_or_write_node(*args, **_arg1, &blk); end
-  def visit_local_variable_write_node(*args, **_arg1, &blk); end
-  def visit_multi_write_node(*args, **_arg1, &blk); end
-end
-
-Spoom::Sorbet::Assertions::Locator::ANNOTATION_METHODS = T.let(T.unsafe(nil), Array)
-
-class Spoom::Sorbet::Assertions::Locator::HeredocVisitor < ::Spoom::Visitor
-  sig { void }
-  def initialize; end
+  sig { returns(T::Array[::Spoom::RBS::Annotations]) }
+  def annotations; end
 
   sig { returns(T::Boolean) }
-  def contains_heredoc; end
+  def empty?; end
 
-  sig { override.params(node: T.nilable(::Prism::Node)).void }
-  def visit(node); end
+  sig { returns(T::Array[::Spoom::RBS::Signature]) }
+  def signatures; end
 end
 
+module Spoom::RBS::ExtractRBSComments
+  sig { params(node: ::Prism::Node).returns(::Spoom::RBS::Comments) }
+  def node_rbs_comments(node); end
+end
+
+class Spoom::RBS::Signature < ::Spoom::RBS::Comment; end
+Spoom::SPOOM_PATH = T.let(T.unsafe(nil), String)
+module Spoom::Sorbet; end
 Spoom::Sorbet::BIN_PATH = T.let(T.unsafe(nil), String)
 Spoom::Sorbet::CONFIG_PATH = T.let(T.unsafe(nil), String)
 
@@ -2859,87 +2782,250 @@ Spoom::Sorbet::Sigils::STRICTNESS_STRONG = T.let(T.unsafe(nil), String)
 Spoom::Sorbet::Sigils::STRICTNESS_TRUE = T.let(T.unsafe(nil), String)
 Spoom::Sorbet::Sigils::VALID_STRICTNESS = T.let(T.unsafe(nil), Array)
 
-class Spoom::Sorbet::Sigs
+module Spoom::Sorbet::Translate
   class << self
-    sig { params(ruby_contents: ::String, positional_names: T::Boolean).returns(::String) }
-    def rbi_to_rbs(ruby_contents, positional_names: T.unsafe(nil)); end
+    sig { params(ruby_contents: ::String, file: ::String).returns(::String) }
+    def rbs_comments_to_sorbet_sigs(ruby_contents, file:); end
+
+    sig { params(ruby_contents: ::String, file: ::String).returns(::String) }
+    def sorbet_assertions_to_rbs_comments(ruby_contents, file:); end
+
+    sig { params(ruby_contents: ::String, file: ::String, positional_names: T::Boolean).returns(::String) }
+    def sorbet_sigs_to_rbs_comments(ruby_contents, file:, positional_names: T.unsafe(nil)); end
 
-    sig { params(ruby_contents: ::String).returns(::String) }
-    def rbs_to_rbi(ruby_contents); end
+    sig { params(ruby_contents: ::String, file: ::String).returns(::String) }
+    def strip_sorbet_sigs(ruby_contents, file:); end
+  end
+end
 
-    sig { params(ruby_contents: ::String).returns(::String) }
-    def strip(ruby_contents); end
+class Spoom::Sorbet::Translate::Error < ::Spoom::Error; end
 
-    private
+class Spoom::Sorbet::Translate::RBSCommentsToSorbetSigs < ::Spoom::Sorbet::Translate::Translator
+  include ::Spoom::RBS::ExtractRBSComments
 
-    sig { params(ruby_contents: ::String).returns(T::Array[[::RBI::RBSComment, T.any(::RBI::Attr, ::RBI::Method)]]) }
-    def collect_rbs_comments(ruby_contents); 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 { params(ruby_contents: ::String).returns(T::Array[[::RBI::Sig, T.any(::RBI::Attr, ::RBI::Method)]]) }
-    def collect_sorbet_sigs(ruby_contents); end
+  sig { override.params(node: ::Prism::SingletonClassNode).void }
+  def visit_singleton_class_node(node); end
+
+  private
+
+  sig do
+    params(
+      node: T.any(::Prism::ClassNode, ::Prism::ModuleNode, ::Prism::SingletonClassNode),
+      constant_regex: ::Regexp
+    ).returns(T::Boolean)
   end
+  def already_extends?(node, constant_regex); end
+
+  sig { params(node: T.any(::Prism::ClassNode, ::Prism::ModuleNode, ::Prism::SingletonClassNode)).void }
+  def apply_class_annotations(node); end
+
+  sig { params(annotations: T::Array[::Spoom::RBS::Annotations], sig: ::RBI::Sig).void }
+  def apply_member_annotations(annotations, sig); end
+
+  sig { params(node: ::Prism::CallNode).void }
+  def visit_attr(node); end
 end
 
-class Spoom::Sorbet::Sigs::Error < ::Spoom::Error; end
+class Spoom::Sorbet::Translate::SorbetAssertionsToRBSComments < ::Spoom::Sorbet::Translate::Translator
+  sig { override.params(node: ::Prism::CallNode).void }
+  def visit_call_node(node); end
+
+  private
 
-class Spoom::Sorbet::Sigs::RBIToRBSTranslator
-  class << self
-    sig do
-      params(
-        sig: ::RBI::Sig,
-        node: T.any(::RBI::Attr, ::RBI::Method),
-        positional_names: T::Boolean
-      ).returns(::String)
-    end
-    def translate(sig, node, positional_names: T.unsafe(nil)); end
+  sig { params(node: ::Prism::Node).returns(T::Boolean) }
+  def at_end_of_line?(node); end
 
-    private
+  sig { params(call: ::Prism::CallNode).void }
+  def build_rbs_annotation(call); end
 
-    sig { params(sig: ::RBI::Sig, node: ::RBI::Attr, positional_names: T::Boolean).returns(::String) }
-    def translate_attr_sig(sig, node, positional_names: T.unsafe(nil)); end
+  sig { params(assign: ::Prism::Node, value: ::Prism::Node).returns(::String) }
+  def dedent_value(assign, value); end
 
-    sig { params(sig: ::RBI::Sig, node: ::RBI::Method, positional_names: T::Boolean).returns(::String) }
-    def translate_method_sig(sig, node, positional_names: T.unsafe(nil)); end
-  end
+  sig { params(node: T.nilable(::Prism::Node)).returns(T::Boolean) }
+  def t?(node); end
+
+  sig { params(node: ::Prism::CallNode).returns(T::Boolean) }
+  def t_annotation?(node); end
 end
 
-class Spoom::Sorbet::Sigs::RBSToRBITranslator
-  class << self
-    sig { params(comment: ::RBI::RBSComment, node: T.any(::RBI::Attr, ::RBI::Method)).returns(T.nilable(::String)) }
-    def translate(comment, node); end
+Spoom::Sorbet::Translate::SorbetAssertionsToRBSComments::LINE_BREAK = T.let(T.unsafe(nil), Integer)
 
-    private
+class Spoom::Sorbet::Translate::SorbetSigsToRBSComments < ::Spoom::Sorbet::Translate::Translator
+  sig { params(ruby_contents: ::String, file: ::String, positional_names: T::Boolean).void }
+  def initialize(ruby_contents, file:, positional_names:); 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 { params(comment: ::RBI::RBSComment, node: ::RBI::Attr).returns(::String) }
-    def translate_attr_sig(comment, node); end
+  sig { override.params(node: ::Prism::ConstantWriteNode).void }
+  def visit_constant_write_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
 
-    sig { params(rbs_comment: ::RBI::RBSComment, node: ::RBI::Method).returns(::String) }
-    def translate_method_sig(rbs_comment, node); end
+  private
+
+  sig { params(sigs: T::Array[[::Prism::CallNode, ::RBI::Sig]]).void }
+  def apply_member_annotations(sigs); end
+
+  sig { params(node: ::Prism::ConstantWriteNode).returns(::String) }
+  def build_type_member_string(node); end
+
+  sig { params(node: ::Prism::CallNode).void }
+  def visit_attr(node); end
+
+  sig { params(node: ::Prism::CallNode).void }
+  def visit_class_annotation(node); end
+
+  sig { params(node: ::Prism::CallNode).void }
+  def visit_extend(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
+end
+
+class Spoom::Sorbet::Translate::StripSorbetSigs < ::Spoom::Sorbet::Translate::Translator
+  sig { override.params(node: ::Prism::CallNode).void }
+  def visit_call_node(node); end
+end
+
+class Spoom::Sorbet::Translate::Translator < ::Spoom::Visitor
+  abstract!
+
+  sig { params(ruby_contents: ::String, file: ::String).void }
+  def initialize(ruby_contents, file:); end
+
+  sig { returns(::String) }
+  def rewrite; end
+
+  private
+
+  sig { params(offset: ::Integer).returns(::Integer) }
+  def adjust_to_line_end(offset); end
+
+  sig { params(offset: ::Integer).returns(::Integer) }
+  def adjust_to_line_start(offset); end
+
+  sig { params(offset: ::Integer).returns(::Integer) }
+  def adjust_to_new_line(offset); end
+
+  sig { params(node: ::Prism::CallNode).returns(T::Boolean) }
+  def sorbet_sig?(node); end
 end
 
-class Spoom::Sorbet::Sigs::Scanner
-  sig { params(source: ::String).void }
-  def initialize(source); end
+module Spoom::Source; end
+
+class Spoom::Source::Delete < ::Spoom::Source::Edit
+  sig { params(from: ::Integer, to: ::Integer).void }
+  def initialize(from, to); end
+
+  sig { override.params(bytes: T::Array[T.untyped]).void }
+  def apply(bytes); end
+
+  sig { returns(::Integer) }
+  def from; end
+
+  sig { override.returns([::Integer, ::Integer]) }
+  def range; end
+
+  def to; end
 
-  sig { params(line: ::Integer, character: ::Integer).returns(::Integer) }
-  def find_char_position(line, character); end
+  sig { override.returns(::String) }
+  def to_s; end
 end
 
-Spoom::Sorbet::Sigs::Scanner::LINE_BREAK = T.let(T.unsafe(nil), Integer)
+class Spoom::Source::Edit
+  abstract!
+
+  sig { abstract.params(bytes: T::Array[::Integer]).void }
+  def apply(bytes); end
+
+  sig { abstract.returns([::Integer, ::Integer]) }
+  def range; end
+end
+
+class Spoom::Source::Insert < ::Spoom::Source::Edit
+  sig { params(position: ::Integer, text: ::String).void }
+  def initialize(position, text); end
+
+  sig { override.params(bytes: T::Array[::Integer]).void }
+  def apply(bytes); end
+
+  sig { returns(::Integer) }
+  def position; end
+
+  sig { override.returns([::Integer, ::Integer]) }
+  def range; end
 
-class Spoom::Sorbet::Sigs::SigsLocator < ::RBI::Visitor
+  sig { returns(::String) }
+  def text; end
+
+  sig { override.returns(::String) }
+  def to_s; end
+end
+
+class Spoom::Source::PositionError < ::Spoom::Error; end
+
+class Spoom::Source::Replace < ::Spoom::Source::Edit
+  sig { params(from: ::Integer, to: ::Integer, text: ::String).void }
+  def initialize(from, to, text); end
+
+  sig { override.params(bytes: T::Array[::Integer]).void }
+  def apply(bytes); end
+
+  sig { returns(::Integer) }
+  def from; end
+
+  sig { override.returns([::Integer, ::Integer]) }
+  def range; end
+
+  sig { returns(::String) }
+  def text; end
+
+  def to; end
+
+  sig { override.returns(::String) }
+  def to_s; end
+end
+
+class Spoom::Source::Rewriter
   sig { void }
   def initialize; end
 
-  sig { returns(T::Array[[::RBI::RBSComment, T.any(::RBI::Attr, ::RBI::Method)]]) }
-  def rbs_comments; end
+  sig { params(other: ::Spoom::Source::Edit).void }
+  def <<(other); end
 
-  sig { returns(T::Array[[::RBI::Sig, T.any(::RBI::Attr, ::RBI::Method)]]) }
-  def sigs; end
-
-  sig { override.params(node: T.nilable(::RBI::Node)).void }
-  def visit(node); end
+  sig { params(bytes: T::Array[::Integer]).void }
+  def rewrite!(bytes); end
 end
 
 class Spoom::Timeline

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: spoom
 version: !ruby/object:Gem::Version
-  version: 1.6.3
+  version: 1.7.0
 platform: ruby
 authors:
 - Alexandre Terrasa
@@ -107,6 +107,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.3.3
+- !ruby/object:Gem::Dependency
+  name: rbs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0.dev.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0.dev.4
 - !ruby/object:Gem::Dependency
   name: rexml
   requirement: !ruby/object:Gem::Requirement
@@ -226,8 +240,8 @@ files:
 - lib/spoom/parse.rb
 - lib/spoom/poset.rb
 - lib/spoom/printer.rb
+- lib/spoom/rbs.rb
 - lib/spoom/sorbet.rb
-- lib/spoom/sorbet/assertions.rb
 - lib/spoom/sorbet/config.rb
 - lib/spoom/sorbet/errors.rb
 - lib/spoom/sorbet/lsp.rb
@@ -236,7 +250,14 @@ files:
 - lib/spoom/sorbet/lsp/structures.rb
 - lib/spoom/sorbet/metrics.rb
 - lib/spoom/sorbet/sigils.rb
-- lib/spoom/sorbet/sigs.rb
+- lib/spoom/sorbet/translate.rb
+- lib/spoom/sorbet/translate/rbs_comments_to_sorbet_sigs.rb
+- lib/spoom/sorbet/translate/sorbet_assertions_to_rbs_comments.rb
+- lib/spoom/sorbet/translate/sorbet_sigs_to_rbs_comments.rb
+- lib/spoom/sorbet/translate/strip_sorbet_sigs.rb
+- lib/spoom/sorbet/translate/translator.rb
+- lib/spoom/source.rb
+- lib/spoom/source/rewriter.rb
 - lib/spoom/timeline.rb
 - lib/spoom/version.rb
 - lib/spoom/visitor.rb
@@ -263,7 +284,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.8
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Useful tools for Sorbet enthusiasts.
 test_files: []