spoom 1.3.2 → 1.3.3

data/lib/spoom/deadcode.rb

@@ -4,84 +4,15 @@
 require "erubi"
 require "prism"
 
-require_relative "deadcode/visitor"
+require_relative "visitor"
+require_relative "location"
+require_relative "parse"
+
 require_relative "deadcode/erb"
 require_relative "deadcode/index"
 require_relative "deadcode/indexer"
 
-require_relative "deadcode/location"
 require_relative "deadcode/definition"
-require_relative "deadcode/reference"
 require_relative "deadcode/send"
 require_relative "deadcode/plugins"
 require_relative "deadcode/remover"
-
-module Spoom
-  module Deadcode
-    class Error < Spoom::Error
-      extend T::Helpers
-
-      abstract!
-    end
-
-    class ParserError < Error; end
-
-    class IndexerError < Error
-      extend T::Sig
-
-      sig { params(message: String, parent: Exception).void }
-      def initialize(message, parent:)
-        super(message)
-        set_backtrace(parent.backtrace)
-      end
-    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 ParserError, message
-        end
-
-        result.value
-      end
-
-      sig do
-        params(
-          index: Index,
-          node: Prism::Node,
-          ruby: String,
-          file: String,
-          plugins: T::Array[Deadcode::Plugins::Base],
-        ).void
-      end
-      def index_node(index, node, ruby, file:, plugins: [])
-        visitor = Spoom::Deadcode::Indexer.new(file, ruby, index, plugins: plugins)
-        visitor.visit(node)
-      rescue => e
-        raise IndexerError.new("Error while indexing #{file} (#{e.message})", parent: e)
-      end
-
-      sig { params(index: Index, ruby: String, file: String, plugins: T::Array[Deadcode::Plugins::Base]).void }
-      def index_ruby(index, ruby, file:, plugins: [])
-        node = parse_ruby(ruby, file: file)
-        index_node(index, node, ruby, file: file, plugins: plugins)
-      end
-
-      sig { params(index: Index, erb: String, file: String, plugins: T::Array[Deadcode::Plugins::Base]).void }
-      def index_erb(index, erb, file:, plugins: [])
-        ruby = ERB.new(erb).src
-        index_ruby(index, ruby, file: file, plugins: plugins)
-      end
-    end
-  end
-end

data/lib/spoom/location.rb

@@ -0,0 +1,84 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  class Location
+    extend T::Sig
+
+    include Comparable
+
+    class LocationError < Spoom::Error; end
+
+    class << self
+      extend T::Sig
+
+      sig { params(location_string: String).returns(Location) }
+      def from_string(location_string)
+        file, rest = location_string.split(":", 2)
+        raise LocationError, "Invalid location string: #{location_string}" unless file && rest
+
+        start_line, rest = rest.split(":", 2)
+        raise LocationError, "Invalid location string: #{location_string}" unless start_line && rest
+
+        start_column, rest = rest.split("-", 2)
+        raise LocationError, "Invalid location string: #{location_string}" unless start_column && rest
+
+        end_line, end_column = rest.split(":", 2)
+        raise LocationError, "Invalid location string: #{location_string}" unless end_line && end_column
+
+        new(file, start_line.to_i, start_column.to_i, end_line.to_i, end_column.to_i)
+      end
+
+      sig { params(file: String, location: Prism::Location).returns(Location) }
+      def from_prism(file, location)
+        new(file, location.start_line, location.start_column, location.end_line, location.end_column)
+      end
+    end
+
+    sig { returns(String) }
+    attr_reader :file
+
+    sig { returns(Integer) }
+    attr_reader :start_line, :start_column, :end_line, :end_column
+
+    sig do
+      params(
+        file: String,
+        start_line: Integer,
+        start_column: Integer,
+        end_line: Integer,
+        end_column: Integer,
+      ).void
+    end
+    def initialize(file, start_line, start_column, end_line, end_column)
+      @file = file
+      @start_line = start_line
+      @start_column = start_column
+      @end_line = end_line
+      @end_column = end_column
+    end
+
+    sig { params(other: Location).returns(T::Boolean) }
+    def include?(other)
+      return false unless @file == other.file
+      return false if @start_line > other.start_line
+      return false if @start_line == other.start_line && @start_column > other.start_column
+      return false if @end_line < other.end_line
+      return false if @end_line == other.end_line && @end_column < other.end_column
+
+      true
+    end
+
+    sig { override.params(other: BasicObject).returns(T.nilable(Integer)) }
+    def <=>(other)
+      return unless Location === other
+
+      to_s <=> other.to_s
+    end
+
+    sig { returns(String) }
+    def to_s
+      "#{@file}:#{@start_line}:#{@start_column}-#{@end_line}:#{@end_column}"
+    end
+  end
+end

data/lib/spoom/model/builder.rb

@@ -0,0 +1,246 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  class Model
+    # Populate a Model by visiting the nodes from a Ruby file
+    class Builder < NamespaceVisitor
+      extend T::Sig
+
+      sig { params(model: Model, file: String).void }
+      def initialize(model, file)
+        super()
+
+        @model = model
+        @file = file
+        @namespace_nesting = T.let([], T::Array[Namespace])
+        @visibility_stack = T.let([Visibility::Public], T::Array[Visibility])
+        @last_sigs = T.let([], T::Array[Sig])
+      end
+
+      # Classes
+
+      sig { override.params(node: Prism::ClassNode).void }
+      def visit_class_node(node)
+        @namespace_nesting << Class.new(
+          @model.register_symbol(@names_nesting.join("::")),
+          owner: @namespace_nesting.last,
+          location: node_location(node),
+          superclass_name: node.superclass&.slice,
+        )
+        @visibility_stack << Visibility::Public
+        super
+        @visibility_stack.pop
+        @namespace_nesting.pop
+        @last_sigs.clear
+      end
+
+      sig { override.params(node: Prism::SingletonClassNode).void }
+      def visit_singleton_class_node(node)
+        @namespace_nesting << SingletonClass.new(
+          @model.register_symbol(@names_nesting.join("::")),
+          owner: @namespace_nesting.last,
+          location: node_location(node),
+        )
+        @visibility_stack << Visibility::Public
+        super
+        @visibility_stack.pop
+        @namespace_nesting.pop
+        @last_sigs.clear
+      end
+
+      # Modules
+
+      sig { override.params(node: Prism::ModuleNode).void }
+      def visit_module_node(node)
+        @namespace_nesting << Module.new(
+          @model.register_symbol(@names_nesting.join("::")),
+          owner: @namespace_nesting.last,
+          location: node_location(node),
+        )
+        @visibility_stack << Visibility::Public
+        super
+        @visibility_stack.pop
+        @namespace_nesting.pop
+        @last_sigs.clear
+      end
+
+      # Constants
+
+      sig { override.params(node: Prism::ConstantPathWriteNode).void }
+      def visit_constant_path_write_node(node)
+        @last_sigs.clear
+
+        name = node.target.slice
+        full_name = if name.start_with?("::")
+          name.delete_prefix("::")
+        else
+          [*@names_nesting, name].join("::")
+        end
+
+        Constant.new(
+          @model.register_symbol(full_name),
+          owner: @namespace_nesting.last,
+          location: node_location(node),
+          value: node.value.slice,
+        )
+
+        super
+      end
+
+      sig { override.params(node: Prism::ConstantWriteNode).void }
+      def visit_constant_write_node(node)
+        @last_sigs.clear
+
+        Constant.new(
+          @model.register_symbol([*@names_nesting, node.name.to_s].join("::")),
+          owner: @namespace_nesting.last,
+          location: node_location(node),
+          value: node.value.slice,
+        )
+
+        super
+      end
+
+      sig { override.params(node: Prism::MultiWriteNode).void }
+      def visit_multi_write_node(node)
+        @last_sigs.clear
+
+        node.lefts.each do |const|
+          case const
+          when Prism::ConstantTargetNode, Prism::ConstantPathTargetNode
+            Constant.new(
+              @model.register_symbol([*@names_nesting, const.slice].join("::")),
+              owner: @namespace_nesting.last,
+              location: node_location(const),
+              value: node.value.slice,
+            )
+          end
+        end
+
+        super
+      end
+
+      # Methods
+
+      sig { override.params(node: Prism::DefNode).void }
+      def visit_def_node(node)
+        recv = node.receiver
+
+        if !recv || recv.is_a?(Prism::SelfNode)
+          Method.new(
+            @model.register_symbol([*@names_nesting, node.name.to_s].join("::")),
+            owner: @namespace_nesting.last,
+            location: node_location(node),
+            visibility: current_visibility,
+            sigs: collect_sigs,
+          )
+        end
+
+        super
+      end
+
+      # Accessors
+
+      sig { override.params(node: Prism::CallNode).void }
+      def visit_call_node(node)
+        return if node.receiver && !node.receiver.is_a?(Prism::SelfNode)
+
+        current_namespace = @namespace_nesting.last
+
+        case node.name
+        when :attr_accessor
+          sigs = collect_sigs
+          node.arguments&.arguments&.each do |arg|
+            next unless arg.is_a?(Prism::SymbolNode)
+
+            AttrAccessor.new(
+              @model.register_symbol([*@names_nesting, arg.slice.delete_prefix(":")].join("::")),
+              owner: current_namespace,
+              location: node_location(arg),
+              visibility: current_visibility,
+              sigs: sigs,
+            )
+          end
+        when :attr_reader
+          sigs = collect_sigs
+          node.arguments&.arguments&.each do |arg|
+            next unless arg.is_a?(Prism::SymbolNode)
+
+            AttrReader.new(
+              @model.register_symbol([*@names_nesting, arg.slice.delete_prefix(":")].join("::")),
+              owner: current_namespace,
+              location: node_location(arg),
+              visibility: current_visibility,
+              sigs: sigs,
+            )
+          end
+        when :attr_writer
+          sigs = collect_sigs
+          node.arguments&.arguments&.each do |arg|
+            next unless arg.is_a?(Prism::SymbolNode)
+
+            AttrWriter.new(
+              @model.register_symbol([*@names_nesting, arg.slice.delete_prefix(":")].join("::")),
+              owner: current_namespace,
+              location: node_location(arg),
+              visibility: current_visibility,
+              sigs: sigs,
+            )
+          end
+        when :include
+          node.arguments&.arguments&.each do |arg|
+            next unless arg.is_a?(Prism::ConstantReadNode) || arg.is_a?(Prism::ConstantPathNode)
+            next unless current_namespace
+
+            current_namespace.mixins << Include.new(arg.slice)
+          end
+        when :prepend
+          node.arguments&.arguments&.each do |arg|
+            next unless arg.is_a?(Prism::ConstantReadNode) || arg.is_a?(Prism::ConstantPathNode)
+            next unless current_namespace
+
+            current_namespace.mixins << Prepend.new(arg.slice)
+          end
+        when :extend
+          node.arguments&.arguments&.each do |arg|
+            next unless arg.is_a?(Prism::ConstantReadNode) || arg.is_a?(Prism::ConstantPathNode)
+            next unless current_namespace
+
+            current_namespace.mixins << Extend.new(arg.slice)
+          end
+        when :public, :private, :protected
+          @visibility_stack << Visibility.from_serialized(node.name.to_s)
+          if node.arguments
+            super
+            @visibility_stack.pop
+          end
+        when :sig
+          @last_sigs << Sig.new(node.slice)
+        else
+          @last_sigs.clear
+          super
+        end
+      end
+
+      private
+
+      sig { returns(Visibility) }
+      def current_visibility
+        T.must(@visibility_stack.last)
+      end
+
+      sig { returns(T::Array[Sig]) }
+      def collect_sigs
+        sigs = @last_sigs
+        @last_sigs = []
+        sigs
+      end
+
+      sig { params(node: Prism::Node).returns(Location) }
+      def node_location(node)
+        Location.from_prism(@file, node.location)
+      end
+    end
+  end
+end