spoom 1.5.0 → 1.7.2

data/lib/spoom/poset.rb

@@ -7,22 +7,21 @@ 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]])
+      @elements = {} #: Hash[E, Element[E]]
     end
 
     # 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,30 +133,29 @@ 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]])
-        @tos = T.let(Set.new, T::Set[Element[E]])
-        @dfroms = T.let(Set.new, T::Set[Element[E]])
-        @froms = T.let(Set.new, T::Set[Element[E]])
+        @dtos = Set.new #: Set[Element[E]]
+        @tos = Set.new #: Set[Element[E]]
+        @dfroms = Set.new #: Set[Element[E]]
+        @froms = Set.new #: 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/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/config.rb

@@ -24,25 +24,23 @@ module Spoom
     # puts config.ignore  # "c"
     # ```
     class Config
-      extend T::Sig
+      DEFAULT_ALLOWED_EXTENSIONS = [".rb", ".rbi"].freeze #: Array[String]
 
-      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])
-        @allowed_extensions = T.let([], T::Array[String])
-        @no_stdlib = T.let(false, T::Boolean)
+        @paths = [] #: Array[String]
+        @ignore = [] #: Array[String]
+        @allowed_extensions = [] #: Array[String]
+        @no_stdlib = false #: bool
       end
 
-      sig { returns(Config) }
+      #: -> Config
       def copy
         new_config = Sorbet::Config.new
         new_config.paths.concat(@paths)
@@ -64,28 +62,26 @@ module Spoom
       #
       # puts config.options_string # "/foo /bar --ignore /baz --allowed-extension .rb"
       # ~~~
-      sig { returns(String) }
+      #: -> String
       def options_string
         opts = []
-        opts.concat(paths)
-        opts.concat(ignore.map { |p| "--ignore #{p}" })
-        opts.concat(allowed_extensions.map { |ext| "--allowed-extension #{ext}" })
+        opts.concat(paths.map { |p| "'#{p}'" })
+        opts.concat(ignore.map { |p| "--ignore '#{p}'" })
+        opts.concat(allowed_extensions.map { |ext| "--allowed-extension '#{ext}'" })
         opts << "--no-stdlib" if @no_stdlib
         opts.join(" ")
       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))
+          state = nil #: Symbol?
           sorbet_config.each_line do |line|
             line = line.strip
             case line
@@ -95,9 +91,6 @@ module Spoom
             when /^--allowed-extension=/
               config.allowed_extensions << parse_option(line)
               next
-            when /^--ignore=/
-              config.ignore << parse_option(line)
-              next
             when /^--ignore$/
               state = :ignore
               next
@@ -146,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

data/lib/spoom/sorbet/errors.rb

@@ -1,54 +1,76 @@
 # typed: strict
 # frozen_string_literal: true
 
+require "rexml/document"
+
 module Spoom
   module Sorbet
     module Errors
       DEFAULT_ERROR_URL_BASE = "https://srb.help/"
 
       class << self
-        extend T::Sig
-
-        sig { params(errors: T::Array[Error]).returns(T::Array[Error]) }
+        #: (Array[Error] errors) -> Array[Error]
         def sort_errors_by_code(errors)
           errors.sort_by { |e| [e.code, e.file, e.line, e.message] }
         end
+
+        #: (Array[Error]) -> REXML::Document
+        def to_junit_xml(errors)
+          testsuite_element = REXML::Element.new("testsuite")
+          testsuite_element.add_attributes(
+            "name" => "Sorbet",
+            "failures" => errors.size,
+          )
+
+          if errors.empty?
+            # Avoid creating an empty report when there are no errors so that
+            # reporting tools know that the type checking ran successfully.
+            testcase_element = testsuite_element.add_element("testcase")
+            testcase_element.add_attributes(
+              "name" => "Typecheck",
+              "tests" => 1,
+            )
+          else
+            errors.each do |error|
+              testsuite_element.add_element(error.to_junit_xml_element)
+            end
+          end
+
+          doc = REXML::Document.new
+          doc << REXML::XMLDecl.new
+          doc.add_element(testsuite_element)
+
+          doc
+        end
       end
       # Parse errors from Sorbet output
       class Parser
-        extend T::Sig
-
         class ParseError < Spoom::Error; end
 
-        HEADER = T.let(
-          [
-            "👋 Hey there! Heads up that this is not a release build of sorbet.",
-            "Release builds are faster and more well-supported by the Sorbet team.",
-            "Check out the README to learn how to build Sorbet in release mode.",
-            "To forcibly silence this error, either pass --silence-dev-message,",
-            "or set SORBET_SILENCE_DEV_MESSAGE=1 in your shell environment.",
-          ],
-          T::Array[String],
-        )
+        HEADER = [
+          "👋 Hey there! Heads up that this is not a release build of sorbet.",
+          "Release builds are faster and more well-supported by the Sorbet team.",
+          "Check out the README to learn how to build Sorbet in release mode.",
+          "To forcibly silence this error, either pass --silence-dev-message,",
+          "or set SORBET_SILENCE_DEV_MESSAGE=1 in your shell environment.",
+        ] #: Array[String]
 
         class << self
-          extend T::Sig
-
-          sig { params(output: String, error_url_base: String).returns(T::Array[Error]) }
+          #: (String output, ?error_url_base: String) -> Array[Error]
           def parse_string(output, error_url_base: DEFAULT_ERROR_URL_BASE)
             parser = Spoom::Sorbet::Errors::Parser.new(error_url_base: error_url_base)
             parser.parse(output)
           end
         end
 
-        sig { params(error_url_base: String).void }
+        #: (?error_url_base: String) -> void
         def initialize(error_url_base: DEFAULT_ERROR_URL_BASE)
-          @errors = T.let([], T::Array[Error])
-          @error_line_match_regex = T.let(error_line_match_regexp(error_url_base), Regexp)
-          @current_error = T.let(nil, T.nilable(Error))
+          @errors = [] #: Array[Error]
+          @error_line_match_regex = error_line_match_regexp(error_url_base) #: Regexp
+          @current_error = nil #: Error?
         end
 
-        sig { params(output: String).returns(T::Array[Error]) }
+        #: (String output) -> Array[Error]
         def parse(output)
           output.each_line do |line|
             break if /^No errors! Great job\./.match?(line)
@@ -71,7 +93,7 @@ module Spoom
 
         private
 
-        sig { params(error_url_base: String).returns(Regexp) }
+        #: (String error_url_base) -> Regexp
         def error_line_match_regexp(error_url_base)
           url = Regexp.escape(error_url_base)
           %r{
@@ -88,7 +110,7 @@ module Spoom
           }x
         end
 
-        sig { params(line: String).returns(T.nilable(Error)) }
+        #: (String line) -> Error?
         def match_error_line(line)
           match = line.match(@error_line_match_regex)
           return unless match
@@ -97,14 +119,14 @@ module Spoom
           Error.new(file, line&.to_i, message, code&.to_i)
         end
 
-        sig { params(error: Error).void }
+        #: (Error error) -> void
         def open_error(error)
           raise ParseError, "Error: Already parsing an error!" if @current_error
 
           @current_error = error
         end
 
-        sig { void }
+        #: -> void
         def close_error
           raise ParseError, "Error: Not already parsing an error!" unless @current_error
 
@@ -112,7 +134,7 @@ module Spoom
           @current_error = nil
         end
 
-        sig { params(line: String).void }
+        #: (String line) -> void
         def append_error(line)
           raise ParseError, "Error: Not already parsing an error!" unless @current_error
 
@@ -126,51 +148,71 @@ module Spoom
 
       class Error
         include Comparable
-        extend T::Sig
 
-        sig { returns(T.nilable(String)) }
+        #: String?
         attr_reader :file, :message
 
-        sig { returns(T.nilable(Integer)) }
+        #: Integer?
         attr_reader :line, :code
 
-        sig { returns(T::Array[String]) }
+        #: Array[String]
         attr_reader :more
 
         # Other files associated with the error
-        sig { returns(T::Set[String]) }
+        #: Set[String]
         attr_reader :files_from_error_sections
 
-        sig do
-          params(
-            file: T.nilable(String),
-            line: T.nilable(Integer),
-            message: T.nilable(String),
-            code: T.nilable(Integer),
-            more: T::Array[String],
-          ).void
-        end
+        #: (String? file, Integer? line, String? message, Integer? code, ?Array[String] more) -> void
         def initialize(file, line, message, code, more = [])
           @file = file
           @line = line
           @message = message
           @code = code
           @more = more
-          @files_from_error_sections = T.let(Set.new, T::Set[String])
+          @files_from_error_sections = Set.new #: Set[String]
         end
 
         # By default errors are sorted by location
-        sig { params(other: T.untyped).returns(Integer) }
+        #: (untyped other) -> Integer
         def <=>(other)
           return 0 unless other.is_a?(Error)
 
           [file, line, code, message] <=> [other.file, other.line, other.code, other.message]
         end
 
-        sig { returns(String) }
+        #: -> String
         def to_s
           "#{file}:#{line}: #{message} (#{code})"
         end
+
+        #: -> REXML::Element
+        def to_junit_xml_element
+          testcase_element = REXML::Element.new("testcase")
+          # Unlike traditional test suites, we can't report all tests
+          # regardless of outcome; we only have errors to report. As a
+          # result we reinterpret the definitions of the test properties
+          # bit: the error message becomes the test name and the full error
+          # info gets plugged into the failure body along with file/line
+          # information (displayed in Jenkins as the "Stacktrace" for the
+          # error).
+          testcase_element.add_attributes(
+            "name" => message,
+            "file" => file,
+            "line" => line,
+          )
+          failure_element = testcase_element.add_element("failure")
+          failure_element.add_attributes(
+            "type" => code,
+          )
+          explanation_text = [
+            "In file #{file}:\n",
+            *more,
+          ].join.chomp
+          # Use CDATA so that parsers know the whitespace is significant.
+          failure_element.add(REXML::CData.new(explanation_text))
+
+          testcase_element
+        end
       end
     end
   end