spoom 1.5.4 → 1.6.0

data/lib/spoom/poset.rb

@@ -7,14 +7,13 @@ module Spoom
   # The partial order relation is a binary relation that is reflexive, antisymmetric, and transitive.
   # It can be used to represent a hierarchy of classes or modules, the dependencies between gems, etc.
   class Poset
-    extend T::Sig
     extend T::Generic
 
     class Error < Spoom::Error; end
 
     E = type_member { { upper: Object } }
 
-    sig { void }
+    #: -> void
     def initialize
       @elements = T.let({}, T::Hash[E, Element[E]])
     end
@@ -22,7 +21,7 @@ module Spoom
     # Get the POSet element for a given value
     #
     # Raises if the element is not found
-    sig { params(value: E).returns(Element[E]) }
+    #: (E value) -> Element[E]
     def [](value)
       element = @elements[value]
       raise Error, "POSet::Element not found for #{value}" unless element
@@ -31,7 +30,7 @@ module Spoom
     end
 
     # Add an element to the POSet
-    sig { params(value: E).returns(Element[E]) }
+    #: (E value) -> Element[E]
     def add_element(value)
       element = @elements[value]
       return element if element
@@ -40,7 +39,7 @@ module Spoom
     end
 
     # Is the given value a element in the POSet?
-    sig { params(value: E).returns(T::Boolean) }
+    #: (E value) -> bool
     def element?(value)
       @elements.key?(value)
     end
@@ -50,7 +49,7 @@ module Spoom
     # Transitive edges (transitive closure) are automatically computed.
     # Adds the elements if they don't exist.
     # If the direct edge already exists, nothing is done.
-    sig { params(from: E, to: E).void }
+    #: (E from, E to) -> void
     def add_direct_edge(from, to)
       from_element = add_element(from)
       to_element = add_element(to)
@@ -88,7 +87,7 @@ module Spoom
     end
 
     # Is there an edge (direct or indirect) from `from` to `to`?
-    sig { params(from: E, to: E).returns(T::Boolean) }
+    #: (E from, E to) -> bool
     def edge?(from, to)
       from_element = @elements[from]
       return false unless from_element
@@ -97,13 +96,13 @@ module Spoom
     end
 
     # Is there a direct edge from `from` to `to`?
-    sig { params(from: E, to: E).returns(T::Boolean) }
+    #: (E from, E to) -> bool
     def direct_edge?(from, to)
       self[from].parents.include?(to)
     end
 
     # Show the POSet as a DOT graph using xdot (used for debugging)
-    sig { params(direct: T::Boolean, transitive: T::Boolean).void }
+    #: (?direct: bool, ?transitive: bool) -> void
     def show_dot(direct: true, transitive: true)
       Open3.popen3("xdot -") do |stdin, _stdout, _stderr, _thread|
         stdin.write(to_dot(direct: direct, transitive: transitive))
@@ -112,7 +111,7 @@ module Spoom
     end
 
     # Return the POSet as a DOT graph
-    sig { params(direct: T::Boolean, transitive: T::Boolean).returns(String) }
+    #: (?direct: bool, ?transitive: bool) -> String
     def to_dot(direct: true, transitive: true)
       dot = +"digraph {\n"
       dot << "  rankdir=BT;\n"
@@ -134,21 +133,20 @@ module Spoom
 
     # An element in a POSet
     class Element
-      extend T::Sig
       extend T::Generic
       include Comparable
 
       E = type_member { { upper: Object } }
 
       # The value held by this element
-      sig { returns(E) }
+      #: E
       attr_reader :value
 
       # Edges (direct and indirect) from this element to other elements in the same POSet
-      sig { returns(T::Set[Element[E]]) }
+      #: Set[Element[E]]
       attr_reader :dtos, :tos, :dfroms, :froms
 
-      sig { params(value: E).void }
+      #: (E value) -> void
       def initialize(value)
         @value = value
         @dtos = T.let(Set.new, T::Set[Element[E]])
@@ -157,7 +155,7 @@ module Spoom
         @froms = T.let(Set.new, T::Set[Element[E]])
       end
 
-      sig { params(other: T.untyped).returns(T.nilable(Integer)) }
+      #: (untyped other) -> Integer?
       def <=>(other)
         return unless other.is_a?(Element)
         return 0 if self == other
@@ -170,25 +168,25 @@ module Spoom
       end
 
       # Direct parents of this element
-      sig { returns(T::Array[E]) }
+      #: -> Array[E]
       def parents
         @dtos.map(&:value)
       end
 
       # Direct and indirect ancestors of this element
-      sig { returns(T::Array[E]) }
+      #: -> Array[E]
       def ancestors
         @tos.map(&:value)
       end
 
       # Direct children of this element
-      sig { returns(T::Array[E]) }
+      #: -> Array[E]
       def children
         @dfroms.map(&:value)
       end
 
       # Direct and indirect descendants of this element
-      sig { returns(T::Array[E]) }
+      #: -> Array[E]
       def descendants
         @froms.map(&:value)
       end

data/lib/spoom/printer.rb

@@ -5,15 +5,12 @@ require "stringio"
 
 module Spoom
   class Printer
-    extend T::Sig
-    extend T::Helpers
-
     include Colorize
 
-    sig { returns(T.any(IO, StringIO)) }
+    #: (IO | StringIO)
     attr_accessor :out
 
-    sig { params(out: T.any(IO, StringIO), colors: T::Boolean, indent_level: Integer).void }
+    #: (?out: (IO | StringIO), ?colors: bool, ?indent_level: Integer) -> void
     def initialize(out: $stdout, colors: true, indent_level: 0)
       @out = out
       @colors = colors
@@ -21,19 +18,19 @@ module Spoom
     end
 
     # Increase indent level
-    sig { void }
+    #: -> void
     def indent
       @indent_level += 2
     end
 
     # Decrease indent level
-    sig { void }
+    #: -> void
     def dedent
       @indent_level -= 2
     end
 
     # Print `string` into `out`
-    sig { params(string: T.nilable(String)).void }
+    #: (String? string) -> void
     def print(string)
       return unless string
 
@@ -43,7 +40,7 @@ module Spoom
     # Print `string` colored with `color` into `out`
     #
     # Does not use colors unless `@colors`.
-    sig { params(string: T.nilable(String), color: Color).void }
+    #: (String? string, *Color color) -> void
     def print_colored(string, *color)
       return unless string
 
@@ -52,13 +49,13 @@ module Spoom
     end
 
     # Print a new line into `out`
-    sig { void }
+    #: -> void
     def printn
       print("\n")
     end
 
     # Print `string` with indent and newline
-    sig { params(string: T.nilable(String)).void }
+    #: (String? string) -> void
     def printl(string)
       return unless string
 
@@ -68,13 +65,13 @@ module Spoom
     end
 
     # Print an indent space into `out`
-    sig { void }
+    #: -> void
     def printt
       print(" " * @indent_level)
     end
 
     # Colorize `string` with color if `@colors`
-    sig { params(string: String, color: Spoom::Color).returns(String) }
+    #: (String string, *Spoom::Color color) -> String
     def colorize(string, *color)
       return string unless @colors
 

data/lib/spoom/sorbet/assertions.rb

@@ -0,0 +1,278 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "rbi"
+
+module Spoom
+  module Sorbet
+    class Assertions
+      class << self
+        #: (String, file: String) -> String
+        def rbi_to_rbs(ruby_contents, file:)
+          old_encoding = ruby_contents.encoding
+          ruby_contents = ruby_contents.encode("UTF-8") unless old_encoding == "UTF-8"
+          ruby_bytes = ruby_contents.bytes
+
+          assigns = collect_assigns(ruby_contents, file: file)
+
+          assigns.reverse.each do |assign|
+            # Adjust the end offset to locate the end of the line:
+            #
+            # So this:
+            #
+            #     (a = T.let(nil, T.nilable(String)))
+            #
+            # properly becomes:
+            #
+            #     (a = nil) #: String?
+            #
+            # This is important to avoid translating the `nil` as `nil` instead of `nil #: String?`
+            end_offset = assign.node.location.end_offset
+            end_offset += 1 while (ruby_bytes[end_offset] != "\n".ord) && (end_offset < ruby_bytes.size)
+            T.unsafe(ruby_bytes).insert(end_offset, *" #: #{assign.rbs_type}".bytes)
+
+            # Rewrite the value
+            start_offset = assign.operator_loc.end_offset
+            end_offset = assign.node.value.location.start_offset + assign.node.value.location.length
+            ruby_bytes[start_offset...end_offset] = " #{dedent_value(assign)}".bytes
+          end
+
+          ruby_bytes.pack("C*").force_encoding(old_encoding)
+        end
+
+        private
+
+        #: (String, file: String) -> Array[AssignNode]
+        def collect_assigns(ruby_contents, file:)
+          node = Spoom.parse_ruby(ruby_contents, file: file)
+          visitor = Locator.new
+          visitor.visit(node)
+          visitor.assigns
+        end
+
+        #: (AssignNode) -> String
+        def dedent_value(assign)
+          if assign.value.location.start_line == assign.node.location.start_line
+            # The value is on the same line as the assign, so we can just return the slice as is:
+            # ```rb
+            # a = T.let(nil, T.nilable(String))
+            # ```
+            # becomes
+            # ```rb
+            # a = nil #: String?
+            # ```
+            return assign.value.slice
+          end
+
+          # The value is on a different line, so we need to dedent it:
+          # ```rb
+          # a = T.let(
+          #   [
+          #     1, 2, 3,
+          #   ],
+          #   T::Array[Integer],
+          # )
+          # ```
+          # becomes
+          # ```rb
+          # a = [
+          #   1, 2, 3,
+          # ] #: Array[Integer]
+          # ```
+          indent = assign.value.location.start_line - assign.node.location.start_line
+          lines = assign.value.slice.lines
+          if lines.size > 1
+            lines[1..]&.each_with_index do |line, i|
+              lines[i + 1] = line.delete_prefix("  " * indent)
+            end
+          end
+          lines.join
+        end
+      end
+
+      AssignType = T.type_alias do
+        T.any(
+          Prism::ClassVariableAndWriteNode,
+          Prism::ClassVariableOrWriteNode,
+          Prism::ClassVariableOperatorWriteNode,
+          Prism::ClassVariableWriteNode,
+          Prism::ConstantAndWriteNode,
+          Prism::ConstantOrWriteNode,
+          Prism::ConstantOperatorWriteNode,
+          Prism::ConstantWriteNode,
+          Prism::ConstantPathAndWriteNode,
+          Prism::ConstantPathOrWriteNode,
+          Prism::ConstantPathOperatorWriteNode,
+          Prism::ConstantPathWriteNode,
+          Prism::GlobalVariableAndWriteNode,
+          Prism::GlobalVariableOrWriteNode,
+          Prism::GlobalVariableOperatorWriteNode,
+          Prism::GlobalVariableWriteNode,
+          Prism::InstanceVariableAndWriteNode,
+          Prism::InstanceVariableOperatorWriteNode,
+          Prism::InstanceVariableOrWriteNode,
+          Prism::InstanceVariableWriteNode,
+          Prism::LocalVariableAndWriteNode,
+          Prism::LocalVariableOperatorWriteNode,
+          Prism::LocalVariableOrWriteNode,
+          Prism::LocalVariableWriteNode,
+        )
+      end
+
+      class AssignNode
+        #: AssignType
+        attr_reader :node
+
+        #: Prism::Location
+        attr_reader :operator_loc
+
+        #: Prism::Node
+        attr_reader :value, :type
+
+        #: (AssignType, Prism::Location, Prism::Node, Prism::Node) -> void
+        def initialize(node, operator_loc, value, type)
+          @node = node
+          @operator_loc = operator_loc
+          @value = value
+          @type = type
+        end
+
+        #: -> String
+        def rbs_type
+          RBI::Type.parse_node(type).rbs_string
+        end
+      end
+
+      class Locator < Spoom::Visitor
+        ANNOTATION_METHODS = T.let([:let], T::Array[Symbol])
+
+        #: Array[AssignNode]
+        attr_reader :assigns
+
+        #: -> void
+        def initialize
+          super
+          @assigns = T.let([], T::Array[AssignNode])
+        end
+
+        #: (AssignType) -> void
+        def visit_assign(node)
+          call = node.value
+          return unless call.is_a?(Prism::CallNode) && t_annotation?(call)
+
+          # We do not support translating heredocs yet because the `#: ` would need to be added to the first line
+          # and it will requires us to adapt the annotation detection in Sorbet. But Sorbet desugars them into bare
+          # strings making them impossible to detect.
+          value = T.must(call.arguments&.arguments&.first)
+          return if contains_heredoc?(value)
+
+          operator_loc = case node
+          when Prism::ClassVariableOperatorWriteNode,
+                Prism::ConstantOperatorWriteNode,
+                Prism::ConstantPathOperatorWriteNode,
+                Prism::GlobalVariableOperatorWriteNode,
+                Prism::InstanceVariableOperatorWriteNode,
+                Prism::LocalVariableOperatorWriteNode
+            node.binary_operator_loc
+          else
+            node.operator_loc
+          end
+
+          @assigns << AssignNode.new(
+            node,
+            operator_loc,
+            value,
+            T.must(call.arguments&.arguments&.last),
+          )
+        end
+
+        alias_method(:visit_class_variable_and_write_node, :visit_assign)
+        alias_method(:visit_class_variable_operator_write_node, :visit_assign)
+        alias_method(:visit_class_variable_or_write_node, :visit_assign)
+        alias_method(:visit_class_variable_write_node, :visit_assign)
+
+        alias_method(:visit_constant_and_write_node, :visit_assign)
+        alias_method(:visit_constant_operator_write_node, :visit_assign)
+        alias_method(:visit_constant_or_write_node, :visit_assign)
+        alias_method(:visit_constant_write_node, :visit_assign)
+
+        alias_method(:visit_constant_path_and_write_node, :visit_assign)
+        alias_method(:visit_constant_path_operator_write_node, :visit_assign)
+        alias_method(:visit_constant_path_or_write_node, :visit_assign)
+        alias_method(:visit_constant_path_write_node, :visit_assign)
+
+        alias_method(:visit_global_variable_and_write_node, :visit_assign)
+        alias_method(:visit_global_variable_operator_write_node, :visit_assign)
+        alias_method(:visit_global_variable_or_write_node, :visit_assign)
+        alias_method(:visit_global_variable_write_node, :visit_assign)
+
+        alias_method(:visit_instance_variable_and_write_node, :visit_assign)
+        alias_method(:visit_instance_variable_operator_write_node, :visit_assign)
+        alias_method(:visit_instance_variable_or_write_node, :visit_assign)
+        alias_method(:visit_instance_variable_write_node, :visit_assign)
+
+        alias_method(:visit_local_variable_and_write_node, :visit_assign)
+        alias_method(:visit_local_variable_operator_write_node, :visit_assign)
+        alias_method(:visit_local_variable_or_write_node, :visit_assign)
+        alias_method(:visit_local_variable_write_node, :visit_assign)
+
+        alias_method(:visit_multi_write_node, :visit_assign)
+
+        # Is this node a `T` or `::T` constant?
+        #: (Prism::Node?) -> bool
+        def t?(node)
+          case node
+          when Prism::ConstantReadNode
+            node.name == :T
+          when Prism::ConstantPathNode
+            node.parent.nil? && node.name == :T
+          else
+            false
+          end
+        end
+
+        # Is this node a `T.let` or `T.cast`?
+        #: (Prism::CallNode) -> bool
+        def t_annotation?(node)
+          return false unless t?(node.receiver)
+          return false unless ANNOTATION_METHODS.include?(node.name)
+          return false unless node.arguments&.arguments&.size == 2
+
+          true
+        end
+
+        #: (Prism::Node) -> bool
+        def contains_heredoc?(node)
+          visitor = HeredocVisitor.new
+          visitor.visit(node)
+          visitor.contains_heredoc
+        end
+
+        class HeredocVisitor < Spoom::Visitor
+          #: bool
+          attr_reader :contains_heredoc
+
+          #: -> void
+          def initialize
+            @contains_heredoc = T.let(false, T::Boolean)
+
+            super
+          end
+
+          # @override
+          #: (Prism::Node?) -> void
+          def visit(node)
+            return if node.nil?
+
+            case node
+            when Prism::StringNode, Prism::InterpolatedStringNode
+              return @contains_heredoc = !!node.opening_loc&.slice&.match?(/<<~|<<-/)
+            end
+
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spoom/sorbet/config.rb

@@ -24,17 +24,15 @@ module Spoom
     # puts config.ignore  # "c"
     # ```
     class Config
-      extend T::Sig
-
       DEFAULT_ALLOWED_EXTENSIONS = T.let([".rb", ".rbi"].freeze, T::Array[String])
 
-      sig { returns(T::Array[String]) }
+      #: Array[String]
       attr_accessor :paths, :ignore, :allowed_extensions
 
-      sig { returns(T::Boolean) }
+      #: bool
       attr_accessor :no_stdlib
 
-      sig { void }
+      #: -> void
       def initialize
         @paths = T.let([], T::Array[String])
         @ignore = T.let([], T::Array[String])
@@ -42,7 +40,7 @@ module Spoom
         @no_stdlib = T.let(false, T::Boolean)
       end
 
-      sig { returns(Config) }
+      #: -> Config
       def copy
         new_config = Sorbet::Config.new
         new_config.paths.concat(@paths)
@@ -64,7 +62,7 @@ module Spoom
       #
       # puts config.options_string # "/foo /bar --ignore /baz --allowed-extension .rb"
       # ~~~
-      sig { returns(String) }
+      #: -> String
       def options_string
         opts = []
         opts.concat(paths.map { |p| "'#{p}'" })
@@ -75,14 +73,12 @@ module Spoom
       end
 
       class << self
-        extend T::Sig
-
-        sig { params(sorbet_config_path: String).returns(Spoom::Sorbet::Config) }
+        #: (String sorbet_config_path) -> Spoom::Sorbet::Config
         def parse_file(sorbet_config_path)
           parse_string(File.read(sorbet_config_path))
         end
 
-        sig { params(sorbet_config: String).returns(Spoom::Sorbet::Config) }
+        #: (String sorbet_config) -> Spoom::Sorbet::Config
         def parse_string(sorbet_config)
           config = Config.new
           state = T.let(nil, T.nilable(Symbol))
@@ -143,7 +139,7 @@ module Spoom
 
         private
 
-        sig { params(line: String).returns(String) }
+        #: (String line) -> String
         def parse_option(line)
           T.must(line.split("=").last).strip
         end