spoom 1.8.7 → 1.8.8

data/lib/spoom/file_tree.rb

@@ -73,15 +73,27 @@ module Spoom
     end
 
     # A node representing either a file or a directory inside a FileTree
-    class Node < T::Struct
+    class Node
       # Node parent or `nil` if the node is a root one
-      const :parent, T.nilable(Node)
+      #: Node?
+      attr_reader :parent
 
       # File or dir name
-      const :name, String
+
+      #: String
+      attr_reader :name
 
       # Children of this node (if not empty, it means it's a dir)
-      const :children, T::Hash[String, Node], default: {}
+
+      #: Hash[String, Node]
+      attr_reader :children
+
+      #: (name: String, ?parent: Node?, ?children: Hash[String, Node]) -> void
+      def initialize(name:, parent: nil, children: {})
+        @parent = parent
+        @name = name
+        @children = children
+      end
 
       # Full path to this node from root
       #: -> String

data/lib/spoom/model/builder.rb

@@ -226,7 +226,7 @@ module Spoom
             current_namespace.mixins << Extend.new(arg.slice)
           end
         when :public, :private, :protected
-          @visibility_stack << Visibility.from_serialized(node.name.to_s)
+          @visibility_stack << Visibility.from_string(node.name.to_s)
           if node.arguments
             super
             @visibility_stack.pop

data/lib/spoom/model/model.rb

@@ -192,12 +192,34 @@ module Spoom
     class AttrWriter < Attr; end
     class AttrAccessor < Attr; end
 
-    class Visibility < T::Enum
-      enums do
-        Public = new("public")
-        Protected = new("protected")
-        Private = new("private")
+    class Visibility
+      class << self
+        #: (String) -> Visibility
+        def from_string(name)
+          case name
+          when "public" then Public
+          when "protected" then Protected
+          when "private" then Private
+          else
+            raise Error, "Invalid visibility: #{name}"
+          end
+        end
+      end
+
+      #: (String) -> void
+      def initialize(name)
+        @name = name
       end
+
+      # @override
+      #: -> String
+      def to_s
+        @name
+      end
+
+      Public = new("public") #: Visibility
+      Protected = new("protected") #: Visibility
+      Private = new("private") #: Visibility
     end
 
     # A mixin (include, prepend, extend) to a namespace

data/lib/spoom/model/reference.rb

@@ -7,12 +7,20 @@ module Spoom
     #
     # Constants could be classes, modules, or actual constants.
     # Methods could be accessors, instance or class methods, aliases, etc.
-    class Reference < T::Struct
-      class Kind < T::Enum
-        enums do
-          Constant = new("constant")
-          Method = new("method")
+    class Reference
+      class Kind
+        #: (String) -> void
+        def initialize(name)
+          @name = name
         end
+
+        #: -> String
+        def to_s
+          @name
+        end
+
+        Constant = new("constant") #: Kind
+        Method = new("method") #: Kind
       end
 
       class << self
@@ -27,9 +35,21 @@ module Spoom
         end
       end
 
-      const :kind, Kind
-      const :name, String
-      const :location, Spoom::Location
+      #: Kind
+      attr_reader :kind
+
+      #: String
+      attr_reader :name
+
+      #: Spoom::Location
+      attr_reader :location
+
+      #: (kind: Kind, name: String, location: Spoom::Location) -> void
+      def initialize(kind:, name:, location:)
+        @kind = kind
+        @name = name
+        @location = location
+      end
 
       #: -> bool
       def constant?

data/lib/spoom/sorbet/lsp/base.rb

@@ -4,7 +4,6 @@
 module Spoom
   module LSP
     # Base messaging
-    # We don't use T::Struct for those so we can subclass them
 
     # A general message as defined by JSON-RPC.
     #

data/lib/spoom/sorbet/lsp/structures.rb

@@ -13,11 +13,20 @@ module Spoom
       def accept_printer(printer) = raise NotImplementedError, "Abstract method called"
     end
 
-    class Position < T::Struct
+    class Position
       include PrintableSymbol
 
-      const :line, Integer
-      const :char, Integer
+      #: Integer
+      attr_reader :line
+
+      #: Integer
+      attr_reader :char
+
+      #: (line: Integer, char: Integer) -> void
+      def initialize(line:, char:)
+        @line = line
+        @char = char
+      end
 
       class << self
         #: (Hash[untyped, untyped] json) -> Position
@@ -41,18 +50,27 @@ module Spoom
       end
     end
 
-    class Range < T::Struct
+    class Range
       include PrintableSymbol
 
-      const :start, Position
-      const :end, Position
+      #: Position
+      attr_reader :start_pos
+
+      #: Position
+      attr_reader :end_pos
+
+      #: (start_pos: Position, end_pos: Position) -> void
+      def initialize(start_pos:, end_pos:)
+        @start_pos = start_pos
+        @end_pos = end_pos
+      end
 
       class << self
         #: (Hash[untyped, untyped] json) -> Range
         def from_json(json)
           Range.new(
-            start: Position.from_json(json["start"]),
-            end: Position.from_json(json["end"]),
+            start_pos: Position.from_json(json["start"]),
+            end_pos: Position.from_json(json["end"]),
           )
         end
       end
@@ -60,22 +78,31 @@ module Spoom
       # @override
       #: (SymbolPrinter printer) -> void
       def accept_printer(printer)
-        printer.print_object(start)
+        printer.print_object(start_pos)
         printer.print_colored("-", Color::LIGHT_BLACK)
-        printer.print_object(self.end)
+        printer.print_object(end_pos)
       end
 
       #: -> String
       def to_s
-        "#{start}-#{self.end}"
+        "#{start_pos}-#{end_pos}"
       end
     end
 
-    class Hover < T::Struct
+    class Hover
       include PrintableSymbol
 
-      const :contents, String
-      const :range, T.nilable(Range)
+      #: String
+      attr_reader :contents
+
+      #: Range?
+      attr_reader :range
+
+      #: (contents: String, ?range: Range?) -> void
+      def initialize(contents:, range: nil)
+        @contents = contents
+        @range = range
+      end
 
       class << self
         #: (Hash[untyped, untyped] json) -> Hover
@@ -100,11 +127,20 @@ module Spoom
       end
     end
 
-    class Location < T::Struct
+    class Location
       include PrintableSymbol
 
-      const :uri, String
-      const :range, LSP::Range
+      #: String
+      attr_reader :uri
+
+      #: LSP::Range
+      attr_reader :range
+
+      #: (uri: String, range: LSP::Range) -> void
+      def initialize(uri:, range:)
+        @uri = uri
+        @range = range
+      end
 
       class << self
         #: (Hash[untyped, untyped] json) -> Location
@@ -129,12 +165,26 @@ module Spoom
       end
     end
 
-    class SignatureHelp < T::Struct
+    class SignatureHelp
       include PrintableSymbol
 
-      const :label, T.nilable(String)
-      const :doc, Object # TODO
-      const :params, T::Array[T.untyped] # TODO
+      #: String?
+      attr_reader :label
+
+      # TODO
+      #: Object
+      attr_reader :doc
+
+      # TODO
+      #: Array[untyped]
+      attr_reader :params
+
+      #: (doc: Object, params: Array[untyped], ?label: String?) -> void
+      def initialize(doc:, params:, label: nil)
+        @label = label
+        @doc = doc
+        @params = params
+      end
 
       class << self
         #: (Hash[untyped, untyped] json) -> SignatureHelp
@@ -162,13 +212,28 @@ module Spoom
       end
     end
 
-    class Diagnostic < T::Struct
+    class Diagnostic
       include PrintableSymbol
 
-      const :range, LSP::Range
-      const :code, Integer
-      const :message, String
-      const :information, Object
+      #: LSP::Range
+      attr_reader :range
+
+      #: Integer
+      attr_reader :code
+
+      #: String
+      attr_reader :message
+
+      #: Object
+      attr_reader :information
+
+      #: (range: LSP::Range, code: Integer, message: String, information: Object) -> void
+      def initialize(range:, code:, message:, information:)
+        @range = range
+        @code = code
+        @message = message
+        @information = information
+      end
 
       class << self
         #: (Hash[untyped, untyped] json) -> Diagnostic
@@ -194,15 +259,43 @@ module Spoom
       end
     end
 
-    class DocumentSymbol < T::Struct
+    class DocumentSymbol
       include PrintableSymbol
 
-      const :name, String
-      const :detail, T.nilable(String)
-      const :kind, Integer
-      const :location, T.nilable(Location)
-      const :range, T.nilable(Range)
-      const :children, T::Array[DocumentSymbol]
+      #: String
+      attr_reader :name
+
+      #: String?
+      attr_reader :detail
+
+      #: Integer
+      attr_reader :kind
+
+      #: Location?
+      attr_reader :location
+
+      #: LSP::Range?
+      attr_reader :range
+
+      #: Array[DocumentSymbol]
+      attr_reader :children
+
+      #: (
+      #|   name: String,
+      #|   kind: Integer,
+      #|   children: Array[DocumentSymbol],
+      #|   ?detail: String?,
+      #|   ?location: Location?,
+      #|   ?range: LSP::Range?
+      #| ) -> void
+      def initialize(name:, kind:, children:, detail: nil, location: nil, range: nil)
+        @name = name
+        @detail = detail
+        @kind = kind
+        @location = location
+        @range = range
+        @children = children
+      end
 
       class << self
         #: (Hash[untyped, untyped] json) -> DocumentSymbol
@@ -221,10 +314,7 @@ module Spoom
       # @override
       #: (SymbolPrinter printer) -> void
       def accept_printer(printer)
-        h = serialize.hash
-        return if printer.seen.include?(h)
-
-        printer.seen.add(h)
+        return unless printer.seen.add?(deduplication_key)
 
         printer.printt
         printer.print(kind_string)
@@ -256,6 +346,28 @@ module Spoom
         SYMBOL_KINDS[kind] || "<unknown:#{kind}>"
       end
 
+      protected
+
+      #: -> Array[untyped]
+      def deduplication_key
+        symbol_location = location
+        [
+          name,
+          detail,
+          kind,
+          symbol_location && [symbol_location.uri, range_key(symbol_location.range)],
+          range_key(range),
+          children.map { |child| child.deduplication_key },
+        ]
+      end
+
+      #: (LSP::Range?) -> Array[Integer]?
+      def range_key(range)
+        return unless range
+
+        [range.start_pos.line, range.start_pos.char, range.end_pos.line, range.end_pos.char]
+      end
+
       SYMBOL_KINDS = {
         1 => "file",
         2 => "module",
@@ -287,7 +399,7 @@ module Spoom
     end
 
     class SymbolPrinter < Printer
-      #: Set[Integer]
+      #: Set[Array[untyped]]
       attr_reader :seen
 
       #: String?
@@ -296,7 +408,7 @@ module Spoom
       #: (?out: (IO | StringIO), ?colors: bool, ?indent_level: Integer, ?prefix: String?) -> void
       def initialize(out: $stdout, colors: true, indent_level: 0, prefix: nil)
         super(out: out, colors: colors, indent_level: indent_level)
-        @seen = Set.new #: Set[Integer]
+        @seen = Set.new #: Set[Array[untyped]]
         @out = out
         @colors = colors
         @indent_level = indent_level

data/lib/spoom/sorbet/translate/rbs_comments_to_sorbet_sigs/base_translator.rb

@@ -231,12 +231,10 @@ module Spoom
               node.expression.location.end_offset
             end
 
-            # Only translate (and `extend T::Helpers`) when there's at least one *known* class
+            # Only translate (and `extend ::T::Helpers`) when there's at least one *known* class
             # annotation. A node with only unknown annotations (e.g. `@private`) is left untouched.
             if comments.class_annotations.any?
-              unless already_extends?(node, /^(::)?T::Helpers$/)
-                extend_with("T::Helpers", into: node, at: insert_pos)
-              end
+              extend_with("::T::Helpers", into: node, at: insert_pos)
 
               comments.annotations.reverse_each do |annotation|
                 content = case annotation.string
@@ -286,9 +284,7 @@ module Spoom
                   next
                 end
 
-                unless already_extends?(node, /^(::)?T::Generic$/)
-                  extend_with("T::Generic", into: node, at: insert_pos)
-                end
+                extend_with("::T::Generic", into: node, at: insert_pos)
 
                 type_params.each do |type_param|
                   type_member = "#{type_param.name} = type_member"
@@ -395,22 +391,6 @@ module Spoom
           #: (String mixin_name, into: PrismTypes::anyScopeNode, at: Integer) -> void
           def extend_with(mixin_name, into:, at:) = raise
 
-          #: (PrismTypes::anyScopeNode, Regexp) -> bool
-          def already_extends?(node, constant_regex)
-            node.child_nodes.any? do |c|
-              next false unless c.is_a?(Prism::CallNode)
-              next false unless c.message == "extend"
-              next false unless c.receiver.nil? || c.receiver.is_a?(Prism::SelfNode)
-              next false unless c.arguments&.arguments&.size == 1
-
-              arg = c.arguments&.arguments&.first
-              next false unless arg.is_a?(Prism::ConstantPathNode)
-              next false unless arg.slice.match?(constant_regex)
-
-              true
-            end
-          end
-
           #: (Array[Prism::Comment]) -> Array[Spoom::RBS::TypeAlias]
           def collect_type_aliases(comments)
             type_aliases = [] #: Array[Spoom::RBS::TypeAlias]

data/lib/spoom/sorbet/translate/rbs_comments_to_sorbet_sigs.rb

@@ -19,25 +19,23 @@ module Spoom
           RBS_REWRITE_PATTERN = Regexp.union(["#:", "#|", *RBS_ANNOTATION_MARKERS]).freeze #: Regexp
           private_constant :RBS_ANNOTATION_MARKERS, :RBS_REWRITE_PATTERN
 
-          #: (String source) -> bool
-          def contains_rbs_syntax?(source)
-            Sigils.contains_valid_sigil?(source) && source.match?(RBS_REWRITE_PATTERN)
-          end
-
           #: (
           #|   String ruby_contents,
           #|   file: String,
           #|   ?max_line_length: Integer?,
           #|   ?overloads_strategy: Symbol,
-          #|   ?erase_generic_types: bool) -> String
+          #|   ?erase_generic_types: bool,
+          #|   ?force: bool) -> String
           def rewrite_if_needed(
             ruby_contents,
             file:,
             max_line_length: nil,
             overloads_strategy: :translate_all,
-            erase_generic_types: false
+            erase_generic_types: false,
+            force: false
           )
-            return ruby_contents unless contains_rbs_syntax?(ruby_contents)
+            return ruby_contents unless ruby_contents.match?(RBS_REWRITE_PATTERN) &&
+              (force || Sigils.contains_valid_sigil?(ruby_contents))
 
             options = Options.new(
               overloads_strategy:,

data/lib/spoom/sorbet/translate/sorbet_sigs_to_rbs_comments.rb

@@ -67,6 +67,7 @@ module Spoom
         #: (Prism::DefNode) -> void
         def visit_def_node(node)
           last_sigs = collect_last_sigs
+          last_sigs.reject! { |_, sig| sig.is_abstract } unless @translate_abstract_methods
           return if last_sigs.empty?
 
           apply_member_annotations(last_sigs)
@@ -77,8 +78,6 @@ module Spoom
           rbi_node = builder.tree.nodes.first #: as RBI::Method
 
           last_sigs.each do |node, sig|
-            next if sig.is_abstract && !@translate_abstract_methods
-
             preserve_multiline_signatures = !!(@preserve_multiline_signatures && sig.loc&.multiline?)
 
             out = rbs_print(
@@ -90,7 +89,7 @@ module Spoom
             @rewriter << Source::Replace.new(node.location.start_offset, node.location.end_offset, out)
           end
 
-          if @translate_abstract_methods && last_sigs.any? { |_, sig| sig.is_abstract }
+          if last_sigs.any? { |_, sig| sig.is_abstract }
             @rewriter << Source::Replace.new(
               node.rparen_loc&.end_offset || node.name_loc.end_offset,
               node.location.end_offset - 1,
@@ -299,7 +298,7 @@ module Spoom
             @rewriter << Source::Insert.new(insert_pos, "# @final\n#{indent}")
           end
 
-          if sigs.any? { |_, sig| sig.is_abstract } && @translate_abstract_methods
+          if sigs.any? { |_, sig| sig.is_abstract }
             @rewriter << Source::Insert.new(insert_pos, "# @abstract\n#{indent}")
           end
 

data/lib/spoom/sorbet/translate.rb

@@ -60,15 +60,16 @@ module Spoom
         # Converts all the RBS comments in the given Ruby code to `sig` nodes.
         # It also handles type members and class annotations.
         #: (String ruby_contents, file: String, ?max_line_length: Integer?,
-        #| ?overloads_strategy: Symbol, ?erase_generic_types: bool) -> String
+        #| ?overloads_strategy: Symbol, ?erase_generic_types: bool, ?force: bool) -> String
         def rbs_comments_to_sorbet_sigs(ruby_contents, file:, max_line_length: nil, overloads_strategy: :translate_all,
-          erase_generic_types: false)
+          erase_generic_types: false, force: false)
           RBSCommentsToSorbetSigs.rewrite_if_needed(
             ruby_contents,
             file: file,
             max_line_length: max_line_length,
             overloads_strategy: overloads_strategy,
             erase_generic_types: erase_generic_types,
+            force: force,
           )
         end
 

data/lib/spoom/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Spoom
-  VERSION = "1.8.7"
+  VERSION = "1.8.8"
 end