spoom 1.3.1 → 1.3.3

data/lib/spoom/model/model.rb

@@ -0,0 +1,328 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  class Model
+    extend T::Sig
+
+    class Error < Spoom::Error; end
+
+    # A Symbol is a uniquely named entity in the Ruby codebase
+    #
+    # A symbol can have multiple definitions, e.g. a class can be reopened.
+    # Sometimes a symbol can have multiple definitions of different types,
+    # e.g. `foo` method can be defined both as a method and as an attribute accessor.
+    class Symbol
+      extend T::Sig
+
+      # The full, unique name of this symbol
+      sig { returns(String) }
+      attr_reader :full_name
+
+      # The definitions of this symbol (where it exists in the code)
+      sig { returns(T::Array[SymbolDef]) }
+      attr_reader :definitions
+
+      sig { params(full_name: String).void }
+      def initialize(full_name)
+        @full_name = full_name
+        @definitions = T.let([], T::Array[SymbolDef])
+      end
+
+      # The short name of this symbol
+      sig { returns(String) }
+      def name
+        T.must(@full_name.split("::").last)
+      end
+
+      sig { returns(String) }
+      def to_s
+        @full_name
+      end
+    end
+
+    class UnresolvedSymbol < Symbol
+      sig { override.returns(String) }
+      def to_s
+        "<#{@full_name}>"
+      end
+    end
+
+    # A SymbolDef is a definition of a Symbol
+    #
+    # It can be a class, module, constant, method, etc.
+    # A SymbolDef has a location pointing to the actual code that defines the symbol.
+    class SymbolDef
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      # The symbol this definition belongs to
+      sig { returns(Symbol) }
+      attr_reader :symbol
+
+      # The enclosing namespace this definition belongs to
+      sig { returns(T.nilable(Namespace)) }
+      attr_reader :owner
+
+      # The actual code location of this definition
+      sig { returns(Location) }
+      attr_reader :location
+
+      sig { params(symbol: Symbol, owner: T.nilable(Namespace), location: Location).void }
+      def initialize(symbol, owner:, location:)
+        @symbol = symbol
+        @owner = owner
+        @location = location
+
+        symbol.definitions << self
+        owner.children << self if owner
+      end
+
+      # The full name of the symbol this definition belongs to
+      sig { returns(String) }
+      def full_name
+        @symbol.full_name
+      end
+
+      # The short name of the symbol this definition belongs to
+      sig { returns(String) }
+      def name
+        @symbol.name
+      end
+    end
+
+    # A class or module
+    class Namespace < SymbolDef
+      abstract!
+
+      sig { returns(T::Array[SymbolDef]) }
+      attr_reader :children
+
+      sig { returns(T::Array[Mixin]) }
+      attr_reader :mixins
+
+      sig { params(symbol: Symbol, owner: T.nilable(Namespace), location: Location).void }
+      def initialize(symbol, owner:, location:)
+        super(symbol, owner: owner, location: location)
+
+        @children = T.let([], T::Array[SymbolDef])
+        @mixins = T.let([], T::Array[Mixin])
+      end
+    end
+
+    class SingletonClass < Namespace; end
+
+    class Class < Namespace
+      sig { returns(T.nilable(String)) }
+      attr_accessor :superclass_name
+
+      sig do
+        params(
+          symbol: Symbol,
+          owner: T.nilable(Namespace),
+          location: Location,
+          superclass_name: T.nilable(String),
+        ).void
+      end
+      def initialize(symbol, owner:, location:, superclass_name: nil)
+        super(symbol, owner: owner, location: location)
+
+        @superclass_name = superclass_name
+      end
+    end
+
+    class Module < Namespace; end
+
+    class Constant < SymbolDef
+      sig { returns(String) }
+      attr_reader :value
+
+      sig { params(symbol: Symbol, owner: T.nilable(Namespace), location: Location, value: String).void }
+      def initialize(symbol, owner:, location:, value:)
+        super(symbol, owner: owner, location: location)
+
+        @value = value
+      end
+    end
+
+    # A method or an attribute accessor
+    class Property < SymbolDef
+      abstract!
+
+      sig { returns(Visibility) }
+      attr_reader :visibility
+
+      sig { returns(T::Array[Sig]) }
+      attr_reader :sigs
+
+      sig do
+        params(
+          symbol: Symbol,
+          owner: T.nilable(Namespace),
+          location: Location,
+          visibility: Visibility,
+          sigs: T::Array[Sig],
+        ).void
+      end
+      def initialize(symbol, owner:, location:, visibility:, sigs: [])
+        super(symbol, owner: owner, location: location)
+
+        @visibility = visibility
+        @sigs = sigs
+      end
+    end
+
+    class Method < Property; end
+
+    class Attr < Property
+      abstract!
+    end
+
+    class AttrReader < Attr; end
+    class AttrWriter < Attr; end
+    class AttrAccessor < Attr; end
+
+    class Visibility < T::Enum
+      enums do
+        Public = new("public")
+        Protected = new("protected")
+        Private = new("private")
+      end
+    end
+
+    # A mixin (include, prepend, extend) to a namespace
+    class Mixin
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      sig { returns(String) }
+      attr_reader :name
+
+      sig { params(name: String).void }
+      def initialize(name)
+        @name = name
+      end
+    end
+
+    class Include < Mixin; end
+    class Prepend < Mixin; end
+    class Extend < Mixin; end
+
+    # A Sorbet signature (sig block)
+    class Sig
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :string
+
+      sig { params(string: String).void }
+      def initialize(string)
+        @string = string
+      end
+    end
+
+    # Model
+
+    # All the symbols registered in this model
+    sig { returns(T::Hash[String, Symbol]) }
+    attr_reader :symbols
+
+    sig { returns(Poset[Symbol]) }
+    attr_reader :symbols_hierarchy
+
+    sig { void }
+    def initialize
+      @symbols = T.let({}, T::Hash[String, Symbol])
+      @symbols_hierarchy = T.let(Poset[Symbol].new, Poset[Symbol])
+    end
+
+    # Get a symbol by it's full name
+    #
+    # Raises an error if the symbol is not found
+    sig { params(full_name: String).returns(Symbol) }
+    def [](full_name)
+      symbol = @symbols[full_name]
+      raise Error, "Symbol not found: #{full_name}" unless symbol
+
+      symbol
+    end
+
+    # Register a new symbol by it's full name
+    #
+    # If the symbol already exists, it will be returned.
+    sig { params(full_name: String).returns(Symbol) }
+    def register_symbol(full_name)
+      @symbols[full_name] ||= Symbol.new(full_name)
+    end
+
+    sig { params(full_name: String, context: Symbol).returns(Symbol) }
+    def resolve_symbol(full_name, context:)
+      if full_name.start_with?("::")
+        full_name = full_name.delete_prefix("::")
+        return @symbols[full_name] ||= UnresolvedSymbol.new(full_name)
+      end
+
+      target = T.let(@symbols[full_name], T.nilable(Symbol))
+      return target if target
+
+      parts = context.full_name.split("::")
+      until parts.empty?
+        target = @symbols["#{parts.join("::")}::#{full_name}"]
+        return target if target
+
+        parts.pop
+      end
+
+      @symbols[full_name] = UnresolvedSymbol.new(full_name)
+    end
+
+    sig { params(symbol: Symbol).returns(T::Array[Symbol]) }
+    def supertypes(symbol)
+      poe = @symbols_hierarchy[symbol]
+      poe.ancestors
+    end
+
+    sig { params(symbol: Symbol).returns(T::Array[Symbol]) }
+    def subtypes(symbol)
+      poe = @symbols_hierarchy[symbol]
+      poe.descendants
+    end
+
+    sig { void }
+    def finalize!
+      compute_symbols_hierarchy!
+    end
+
+    private
+
+    sig { void }
+    def compute_symbols_hierarchy!
+      @symbols.dup.each do |_full_name, symbol|
+        symbol.definitions.each do |definition|
+          next unless definition.is_a?(Namespace)
+
+          @symbols_hierarchy.add_element(symbol)
+
+          if definition.is_a?(Class)
+            superclass_name = definition.superclass_name
+            if superclass_name
+              superclass = resolve_symbol(superclass_name, context: symbol)
+              @symbols_hierarchy.add_direct_edge(symbol, superclass)
+            end
+          end
+
+          definition.mixins.each do |mixin|
+            next if mixin.is_a?(Extend)
+
+            target = resolve_symbol(mixin.name, context: symbol)
+            @symbols_hierarchy.add_direct_edge(symbol, target)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spoom/model/namespace_visitor.rb

@@ -0,0 +1,50 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  class Model
+    class NamespaceVisitor < Visitor
+      extend T::Helpers
+
+      abstract!
+
+      sig { void }
+      def initialize
+        super()
+
+        @names_nesting = T.let([], T::Array[String])
+      end
+
+      sig { override.params(node: T.nilable(Prism::Node)).void }
+      def visit(node)
+        case node
+        when Prism::ClassNode, Prism::ModuleNode
+          constant_path = node.constant_path.slice
+
+          if constant_path.start_with?("::")
+            full_name = constant_path.delete_prefix("::")
+
+            # We found a top level definition such as `class ::A; end`, we need to reset the name nesting
+            old_nesting = @names_nesting.dup
+            @names_nesting.clear
+            @names_nesting << full_name
+
+            super
+
+            # Restore the name nesting once we finished visited the class
+            @names_nesting.clear
+            @names_nesting = old_nesting
+          else
+            @names_nesting << constant_path
+
+            super
+
+            @names_nesting.pop
+          end
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/spoom/model/reference.rb

@@ -0,0 +1,49 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  class Model
+    # A reference to something that looks like a constant or a method
+    #
+    # Constants could be classes, modules, or actual constants.
+    # Methods could be accessors, instance or class methods, aliases, etc.
+    class Reference < T::Struct
+      extend T::Sig
+
+      class Kind < T::Enum
+        enums do
+          Constant = new("constant")
+          Method = new("method")
+        end
+      end
+
+      class << self
+        extend T::Sig
+
+        sig { params(name: String, location: Spoom::Location).returns(Reference) }
+        def constant(name, location)
+          new(name: name, kind: Kind::Constant, location: location)
+        end
+
+        sig { params(name: String, location: Spoom::Location).returns(Reference) }
+        def method(name, location)
+          new(name: name, kind: Kind::Method, location: location)
+        end
+      end
+
+      const :kind, Kind
+      const :name, String
+      const :location, Spoom::Location
+
+      sig { returns(T::Boolean) }
+      def constant?
+        kind == Kind::Constant
+      end
+
+      sig { returns(T::Boolean) }
+      def method?
+        kind == Kind::Method
+      end
+    end
+  end
+end

data/lib/spoom/model/references_visitor.rb

@@ -0,0 +1,200 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  class Model
+    # Visit a file to collect all the references to constants and methods
+    class ReferencesVisitor < Visitor
+      extend T::Sig
+
+      sig { returns(T::Array[Reference]) }
+      attr_reader :references
+
+      sig { params(file: String).void }
+      def initialize(file)
+        super()
+
+        @file = file
+        @references = T.let([], T::Array[Reference])
+      end
+
+      sig { override.params(node: Prism::AliasMethodNode).void }
+      def visit_alias_method_node(node)
+        reference_method(node.old_name.slice, node)
+      end
+
+      sig { override.params(node: Prism::AndNode).void }
+      def visit_and_node(node)
+        reference_method(node.operator_loc.slice, node)
+        super
+      end
+
+      sig { override.params(node: Prism::BlockArgumentNode).void }
+      def visit_block_argument_node(node)
+        expression = node.expression
+        case expression
+        when Prism::SymbolNode
+          reference_method(expression.unescaped, expression)
+        else
+          visit(expression)
+        end
+      end
+
+      sig { override.params(node: Prism::CallAndWriteNode).void }
+      def visit_call_and_write_node(node)
+        visit(node.receiver)
+        reference_method(node.read_name.to_s, node)
+        reference_method(node.write_name.to_s, node)
+        visit(node.value)
+      end
+
+      sig { override.params(node: Prism::CallOperatorWriteNode).void }
+      def visit_call_operator_write_node(node)
+        visit(node.receiver)
+        reference_method(node.read_name.to_s, node)
+        reference_method(node.write_name.to_s, node)
+        visit(node.value)
+      end
+
+      sig { override.params(node: Prism::CallOrWriteNode).void }
+      def visit_call_or_write_node(node)
+        visit(node.receiver)
+        reference_method(node.read_name.to_s, node)
+        reference_method(node.write_name.to_s, node)
+        visit(node.value)
+      end
+
+      sig { override.params(node: Prism::CallNode).void }
+      def visit_call_node(node)
+        visit(node.receiver)
+
+        name = node.name.to_s
+        reference_method(name, node)
+
+        case name
+        when "<", ">", "<=", ">="
+          # For comparison operators, we also reference the `<=>` method
+          reference_method("<=>", node)
+        end
+
+        visit(node.arguments)
+        visit(node.block)
+      end
+
+      sig { override.params(node: Prism::ClassNode).void }
+      def visit_class_node(node)
+        visit(node.superclass) if node.superclass
+        visit(node.body)
+      end
+
+      sig { override.params(node: Prism::ConstantAndWriteNode).void }
+      def visit_constant_and_write_node(node)
+        reference_constant(node.name.to_s, node)
+        visit(node.value)
+      end
+
+      sig { override.params(node: Prism::ConstantOperatorWriteNode).void }
+      def visit_constant_operator_write_node(node)
+        reference_constant(node.name.to_s, node)
+        visit(node.value)
+      end
+
+      sig { override.params(node: Prism::ConstantOrWriteNode).void }
+      def visit_constant_or_write_node(node)
+        reference_constant(node.name.to_s, node)
+        visit(node.value)
+      end
+
+      sig { override.params(node: Prism::ConstantPathNode).void }
+      def visit_constant_path_node(node)
+        visit(node.parent)
+        reference_constant(node.name.to_s, node)
+      end
+
+      sig { override.params(node: Prism::ConstantPathWriteNode).void }
+      def visit_constant_path_write_node(node)
+        visit(node.target.parent)
+        visit(node.value)
+      end
+
+      sig { override.params(node: Prism::ConstantReadNode).void }
+      def visit_constant_read_node(node)
+        reference_constant(node.name.to_s, node)
+      end
+
+      sig { override.params(node: Prism::ConstantWriteNode).void }
+      def visit_constant_write_node(node)
+        visit(node.value)
+      end
+
+      sig { override.params(node: Prism::LocalVariableAndWriteNode).void }
+      def visit_local_variable_and_write_node(node)
+        name = node.name.to_s
+        reference_method(name, node)
+        reference_method("#{name}=", node)
+        visit(node.value)
+      end
+
+      sig { override.params(node: Prism::LocalVariableOperatorWriteNode).void }
+      def visit_local_variable_operator_write_node(node)
+        name = node.name.to_s
+        reference_method(name, node)
+        reference_method("#{name}=", node)
+        visit(node.value)
+      end
+
+      sig { override.params(node: Prism::LocalVariableOrWriteNode).void }
+      def visit_local_variable_or_write_node(node)
+        name = node.name.to_s
+        reference_method(name, node)
+        reference_method("#{name}=", node)
+        visit(node.value)
+      end
+
+      sig { override.params(node: Prism::LocalVariableWriteNode).void }
+      def visit_local_variable_write_node(node)
+        reference_method("#{node.name}=", node)
+        visit(node.value)
+      end
+
+      sig { override.params(node: Prism::ModuleNode).void }
+      def visit_module_node(node)
+        visit(node.body)
+      end
+
+      sig { override.params(node: Prism::MultiWriteNode).void }
+      def visit_multi_write_node(node)
+        node.lefts.each do |const|
+          case const
+          when Prism::LocalVariableTargetNode
+            reference_method("#{const.name}=", node)
+          end
+        end
+        visit(node.value)
+      end
+
+      sig { override.params(node: Prism::OrNode).void }
+      def visit_or_node(node)
+        reference_method(node.operator_loc.slice, node)
+        super
+      end
+
+      private
+
+      sig { params(name: String, node: Prism::Node).void }
+      def reference_constant(name, node)
+        @references << Reference.constant(name, node_location(node))
+      end
+
+      sig { params(name: String, node: Prism::Node).void }
+      def reference_method(name, node)
+        @references << Reference.method(name, node_location(node))
+      end
+
+      sig { params(node: Prism::Node).returns(Location) }
+      def node_location(node)
+        Location.from_prism(@file, node.location)
+      end
+    end
+  end
+end

data/lib/spoom/model.rb

@@ -0,0 +1,10 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative "location"
+require_relative "parse"
+require_relative "model/model"
+require_relative "model/namespace_visitor"
+require_relative "model/builder"
+require_relative "model/reference"
+require_relative "model/references_visitor"

data/lib/spoom/parse.rb

@@ -0,0 +1,28 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "spoom/visitor"
+
+module Spoom
+  class ParseError < Error; end
+
+  class << self
+    extend T::Sig
+
+    sig { params(ruby: String, file: String).returns(Prism::Node) }
+    def parse_ruby(ruby, file:)
+      result = Prism.parse(ruby)
+      unless result.success?
+        message = +"Error while parsing #{file}:\n"
+
+        result.errors.each do |e|
+          message << "- #{e.message} (at #{e.location.start_line}:#{e.location.start_column})\n"
+        end
+
+        raise ParseError, message
+      end
+
+      result.value
+    end
+  end
+end