spoom 1.2.1 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b116c81229f1eb09a9e8676643fd54bb3436f7fa2534b06275d657bcd995f0c4
-  data.tar.gz: 93431ed795ccdcb7aa3afcec9cd3bc468c5b1893bfac4f269c33df9f52e32055
+  metadata.gz: 5154e37a81129c70e93925cc2a545a0d7861fd645a3ec2422e6549efc0cb76b5
+  data.tar.gz: 30c9ecdc3599a37309180fea890a7888d53b430c8701e0970f503bf5731979f9
 SHA512:
-  metadata.gz: 826328b46d178109253dc01197f1cf80102c2174d7dc5b3ac1d52c142fee9785e7100e4b444c4bba71e5303fa711d15f8368cd173177b3614b54ce14c60c5b09
-  data.tar.gz: 60a28d2220e2507d9deaf12d7e3f51e5ea08418f79685c40aa469da5bc317dbddfded2c8d49cd0102035e5a990d9fa60693ae65a7d1e7538118768bea1140f7f
+  metadata.gz: a3246a42fa965e3ef75d0178ffe958a8cc5723812ecb86799b5e2e406d5da7487ffd738696ccb3f6d76ae140de281dab73dba3ec3d8af9fdef696820654ed869
+  data.tar.gz: ba4c8ab2d87ff4451f420e2d062c7cebdd19202bc91226fd131ff9ab9f838e7494fa43560ffa317fc0565d023ecceef184c02f762e215ba6451d3ec164e3c75a

data/Gemfile

@@ -7,7 +7,6 @@ gemspec
 
 group :development do
   gem "debug"
-  gem "ruby-lsp"
   gem "rubocop-shopify", require: false
   gem "rubocop-sorbet", require: false
   gem "tapioca", require: false

data/lib/spoom/context/bundle.rb

@@ -10,12 +10,18 @@ module Spoom
 
       requires_ancestor { Context }
 
-      # Read the `contents` of the Gemfile in this context directory
+      # Read the contents of the Gemfile in this context directory
       sig { returns(T.nilable(String)) }
       def read_gemfile
         read("Gemfile")
       end
 
+      # Read the contents of the Gemfile.lock in this context directory
+      sig { returns(T.nilable(String)) }
+      def read_gemfile_lock
+        read("Gemfile.lock")
+      end
+
       # Set the `contents` of the Gemfile in this context directory
       sig { params(contents: String, append: T::Boolean).void }
       def write_gemfile!(contents, append: false)
@@ -41,17 +47,20 @@ module Spoom
         bundle("exec #{command}", version: version, capture_err: capture_err)
       end
 
+      sig { returns(T::Hash[String, Bundler::LazySpecification]) }
+      def gemfile_lock_specs
+        return {} unless file?("Gemfile.lock")
+
+        parser = Bundler::LockfileParser.new(read_gemfile_lock)
+        parser.specs.map { |spec| [spec.name, spec] }.to_h
+      end
+
       # Get `gem` version from the `Gemfile.lock` content
       #
       # Returns `nil` if `gem` cannot be found in the Gemfile.
       sig { params(gem: String).returns(T.nilable(String)) }
       def gem_version_from_gemfile_lock(gem)
-        return nil unless file?("Gemfile.lock")
-
-        content = read("Gemfile.lock").match(/^    #{gem} \(.*(\d+\.\d+\.\d+).*\)/)
-        return nil unless content
-
-        content[1]
+        gemfile_lock_specs[gem]&.version&.to_s
       end
     end
   end

data/lib/spoom/context/file_system.rb

@@ -43,6 +43,23 @@ module Spoom
         glob("*")
       end
 
+      sig do
+        params(
+          allow_extensions: T::Array[String],
+          allow_mime_types: T::Array[String],
+          exclude_patterns: T::Array[String],
+        ).returns(T::Array[String])
+      end
+      def collect_files(allow_extensions: [], allow_mime_types: [], exclude_patterns: [])
+        collector = FileCollector.new(
+          allow_extensions: allow_extensions,
+          allow_mime_types: allow_mime_types,
+          exclude_patterns: exclude_patterns,
+        )
+        collector.visit_path(absolute_path)
+        collector.files.map { |file| file.delete_prefix("#{absolute_path}/") }
+      end
+
       # Does `relative_path` point to an existing file in this context directory?
       sig { params(relative_path: String).returns(T::Boolean) }
       def file?(relative_path)

data/lib/spoom/context/git.rb

@@ -63,8 +63,18 @@ module Spoom
         git("checkout #{ref}")
       end
 
+      # Run `git checkout -b <branch-name> <ref>` in this context directory
+      sig { params(branch_name: String, ref: T.nilable(String)).returns(ExecResult) }
+      def git_checkout_new_branch!(branch_name, ref: nil)
+        if ref
+          git("checkout -b #{branch_name} #{ref}")
+        else
+          git("checkout -b #{branch_name}")
+        end
+      end
+
       # Run `git add . && git commit` in this context directory
-      sig { params(message: String, time: Time, allow_empty: T::Boolean).void }
+      sig { params(message: String, time: Time, allow_empty: T::Boolean).returns(ExecResult) }
       def git_commit!(message: "message", time: Time.now.utc, allow_empty: false)
         git("add --all")
 
@@ -106,6 +116,12 @@ module Spoom
         git("log #{arg.join(" ")}")
       end
 
+      # Run `git push <remote> <ref>` in this context directory
+      sig { params(remote: String, ref: String, force: T::Boolean).returns(ExecResult) }
+      def git_push!(remote, ref, force: false)
+        git("push #{force ? "-f" : ""} #{remote} #{ref}")
+      end
+
       sig { params(arg: String).returns(ExecResult) }
       def git_show(*arg)
         git("show #{arg.join(" ")}")

data/lib/spoom/context/sorbet.rb

@@ -69,7 +69,24 @@ module Spoom
         allowed_extensions = Spoom::Sorbet::Config::DEFAULT_ALLOWED_EXTENSIONS if allowed_extensions.empty?
         allowed_extensions -= [".rbi"] unless include_rbis
 
-        excluded_patterns = config.ignore.map { |string| File.join("**", string, "**") }
+        excluded_patterns = config.ignore.map do |string|
+          # We need to simulate the behavior of Sorbet's `--ignore` flag.
+          #
+          # From Sorbet docs on `--ignore`:
+          # > Ignores input files that contain the given string in their paths (relative to the input path passed to
+          # > Sorbet). Strings beginning with / match against the prefix of these relative paths; others are substring
+          # > matchs. Matches must be against whole folder and file names, so `foo` matches `/foo/bar.rb` and
+          # > `/bar/foo/baz.rb` but not `/foo.rb` or `/foo2/bar.rb`.
+          string = if string.start_with?("/")
+            # Strings beginning with / match against the prefix of these relative paths
+            File.join(absolute_path, string)
+          else
+            # Others are substring matchs
+            File.join(absolute_path, "**", string)
+          end
+          # Matches must be against whole folder and file names
+          "#{string.delete_suffix("/")}{,/**}"
+        end
 
         collector = FileCollector.new(allow_extensions: allowed_extensions, exclude_patterns: excluded_patterns)
         collector.visit_paths(config.paths.map { |path| absolute_path_to(path) })

data/lib/spoom/deadcode/definition.rb

@@ -0,0 +1,98 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    # A definition is a class, module, method, constant, etc. being defined in the code
+    class Definition < T::Struct
+      extend T::Sig
+
+      class Kind < T::Enum
+        enums do
+          AttrReader = new("attr_reader")
+          AttrWriter = new("attr_writer")
+          Class = new("class")
+          Constant = new("constant")
+          Method = new("method")
+          Module = new("module")
+        end
+      end
+
+      class Status < T::Enum
+        enums do
+          # A definition is marked as `ALIVE` if it has at least one reference with the same name
+          ALIVE = new
+          # A definition is marked as `DEAD` if it has no reference with the same name
+          DEAD = new
+          # A definition can be marked as `IGNORED` if it is not relevant for the analysis
+          IGNORED = new
+        end
+      end
+
+      const :kind, Kind
+      const :name, String
+      const :full_name, String
+      const :location, Location
+      const :status, Status, default: Status::DEAD
+
+      # Kind
+
+      sig { returns(T::Boolean) }
+      def attr_reader?
+        kind == Kind::AttrReader
+      end
+
+      sig { returns(T::Boolean) }
+      def attr_writer?
+        kind == Kind::AttrWriter
+      end
+
+      sig { returns(T::Boolean) }
+      def class?
+        kind == Kind::Class
+      end
+
+      sig { returns(T::Boolean) }
+      def constant?
+        kind == Kind::Constant
+      end
+
+      sig { returns(T::Boolean) }
+      def method?
+        kind == Kind::Method
+      end
+
+      sig { returns(T::Boolean) }
+      def module?
+        kind == Kind::Module
+      end
+
+      # Status
+
+      sig { returns(T::Boolean) }
+      def alive?
+        status == Status::ALIVE
+      end
+
+      sig { void }
+      def alive!
+        @status = Status::ALIVE
+      end
+
+      sig { returns(T::Boolean) }
+      def dead?
+        status == Status::DEAD
+      end
+
+      sig { returns(T::Boolean) }
+      def ignored?
+        status == Status::IGNORED
+      end
+
+      sig { void }
+      def ignored!
+        @status = Status::IGNORED
+      end
+    end
+  end
+end

data/lib/spoom/deadcode/erb.rb

@@ -0,0 +1,103 @@
+# typed: true
+# frozen_string_literal: true
+
+# Copied from https://github.com/rails/rails/blob/main/actionview/lib/action_view/template/handlers/erb/erubi.rb.
+#
+# Copyright (c) David Heinemeier Hansson
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+module Spoom
+  module Deadcode
+    # Custom engine to handle ERB templates as used by Rails
+    class ERB < ::Erubi::Engine
+      extend T::Sig
+
+      sig { params(input: T.untyped, properties: T.untyped).void }
+      def initialize(input, properties = {})
+        @newline_pending = 0
+
+        properties = Hash[properties]
+        properties[:bufvar]     ||= "@output_buffer"
+        properties[:preamble]   ||= ""
+        properties[:postamble]  ||= "#{properties[:bufvar]}.to_s"
+        properties[:escapefunc] = ""
+
+        super
+      end
+
+      private
+
+      sig { params(text: T.untyped).void }
+      def add_text(text)
+        return if text.empty?
+
+        if text == "\n"
+          @newline_pending += 1
+        else
+          src << bufvar << ".safe_append='"
+          src << "\n" * @newline_pending if @newline_pending > 0
+          src << text.gsub(/['\\]/, '\\\\\&')
+          src << "'.freeze;"
+
+          @newline_pending = 0
+        end
+      end
+
+      BLOCK_EXPR = /\s*((\s+|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/
+
+      sig { params(indicator: T.untyped, code: T.untyped).void }
+      def add_expression(indicator, code)
+        flush_newline_if_pending(src)
+
+        src << bufvar << if (indicator == "==") || @escape
+          ".safe_expr_append="
+        else
+          ".append="
+        end
+
+        if BLOCK_EXPR.match?(code)
+          src << " " << code
+        else
+          src << "(" << code << ");"
+        end
+      end
+
+      sig { params(code: T.untyped).void }
+      def add_code(code)
+        flush_newline_if_pending(src)
+        super
+      end
+
+      sig { params(_: T.untyped).void }
+      def add_postamble(_)
+        flush_newline_if_pending(src)
+        super
+      end
+
+      sig { params(src: T.untyped).void }
+      def flush_newline_if_pending(src)
+        if @newline_pending > 0
+          src << bufvar << ".safe_append='#{"\n" * @newline_pending}'.freeze;"
+          @newline_pending = 0
+        end
+      end
+    end
+  end
+end

data/lib/spoom/deadcode/index.rb

@@ -0,0 +1,61 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    class Index
+      extend T::Sig
+
+      sig { returns(T::Hash[String, T::Array[Definition]]) }
+      attr_reader :definitions
+
+      sig { returns(T::Hash[String, T::Array[Reference]]) }
+      attr_reader :references
+
+      sig { void }
+      def initialize
+        @definitions = T.let({}, T::Hash[String, T::Array[Definition]])
+        @references = T.let({}, T::Hash[String, T::Array[Reference]])
+      end
+
+      # Indexing
+
+      sig { params(definition: Definition).void }
+      def define(definition)
+        (@definitions[definition.name] ||= []) << definition
+      end
+
+      sig { params(reference: Reference).void }
+      def reference(reference)
+        (@references[reference.name] ||= []) << reference
+      end
+
+      # Mark all definitions having a reference of the same name as `alive`
+      #
+      # To be called once all the files have been indexed and all the definitions and references discovered.
+      sig { void }
+      def finalize!
+        @references.keys.each do |name|
+          definitions_for_name(name).each(&:alive!)
+        end
+      end
+
+      # Utils
+
+      sig { params(name: String).returns(T::Array[Definition]) }
+      def definitions_for_name(name)
+        @definitions[name] || []
+      end
+
+      sig { returns(T::Array[Definition]) }
+      def all_definitions
+        @definitions.values.flatten
+      end
+
+      sig { returns(T::Array[Reference]) }
+      def all_references
+        @references.values.flatten
+      end
+    end
+  end
+end

data/lib/spoom/deadcode/indexer.rb

@@ -0,0 +1,394 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    class Indexer < SyntaxTree::Visitor
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :path, :file_name
+
+      sig { returns(Index) }
+      attr_reader :index
+
+      sig { params(path: String, source: String, index: Index).void }
+      def initialize(path, source, index)
+        super()
+
+        @path = path
+        @file_name = T.let(File.basename(path), String)
+        @source = source
+        @index = index
+        @previous_node = T.let(nil, T.nilable(SyntaxTree::Node))
+        @names_nesting = T.let([], T::Array[String])
+        @nodes_nesting = T.let([], T::Array[SyntaxTree::Node])
+        @in_const_field = T.let(false, T::Boolean)
+        @in_opassign = T.let(false, T::Boolean)
+        @in_symbol_literal = T.let(false, T::Boolean)
+      end
+
+      # Visit
+
+      sig { override.params(node: T.nilable(SyntaxTree::Node)).void }
+      def visit(node)
+        return unless node
+
+        @nodes_nesting << node
+        super
+        @nodes_nesting.pop
+        @previous_node = node
+      end
+
+      sig { override.params(node: SyntaxTree::AliasNode).void }
+      def visit_alias(node)
+        reference_method(node_string(node.right), node)
+      end
+
+      sig { override.params(node: SyntaxTree::ARef).void }
+      def visit_aref(node)
+        super
+
+        reference_method("[]", node)
+      end
+
+      sig { override.params(node: SyntaxTree::ARefField).void }
+      def visit_aref_field(node)
+        super
+
+        reference_method("[]=", node)
+      end
+
+      sig { override.params(node: SyntaxTree::ArgBlock).void }
+      def visit_arg_block(node)
+        value = node.value
+
+        case value
+        when SyntaxTree::SymbolLiteral
+          # If the block call is something like `x.select(&:foo)`, we need to reference the `foo` method
+          reference_method(symbol_string(value), node)
+        when SyntaxTree::VCall
+          # If the block call is something like `x.select { ... }`, we need to visit the block
+          super
+        end
+      end
+
+      sig { override.params(node: SyntaxTree::Binary).void }
+      def visit_binary(node)
+        super
+
+        op = node.operator
+
+        # Reference the operator itself
+        reference_method(op.to_s, node)
+
+        case op
+        when :<, :>, :<=, :>=
+          # For comparison operators, we also reference the `<=>` method
+          reference_method("<=>", node)
+        end
+      end
+
+      sig { override.params(node: SyntaxTree::CallNode).void }
+      def visit_call(node)
+        visit_send(
+          Send.new(
+            node: node,
+            name: node_string(node.message),
+            recv: node.receiver,
+            args: call_args(node.arguments),
+          ),
+        )
+      end
+
+      sig { override.params(node: SyntaxTree::ClassDeclaration).void }
+      def visit_class(node)
+        const_name = node_string(node.constant)
+        @names_nesting << const_name
+        define_class(T.must(const_name.split("::").last), @names_nesting.join("::"), node)
+
+        # We do not call `super` here because we don't want to visit the `constant` again
+        visit(node.superclass) if node.superclass
+        visit(node.bodystmt)
+
+        @names_nesting.pop
+      end
+
+      sig { override.params(node: SyntaxTree::Command).void }
+      def visit_command(node)
+        visit_send(
+          Send.new(
+            node: node,
+            name: node_string(node.message),
+            args: call_args(node.arguments),
+            block: node.block,
+          ),
+        )
+      end
+
+      sig { override.params(node: SyntaxTree::CommandCall).void }
+      def visit_command_call(node)
+        visit_send(
+          Send.new(
+            node: node,
+            name: node_string(node.message),
+            recv: node.receiver,
+            args: call_args(node.arguments),
+            block: node.block,
+          ),
+        )
+      end
+
+      sig { override.params(node: SyntaxTree::Const).void }
+      def visit_const(node)
+        reference_constant(node.value, node) unless @in_symbol_literal
+      end
+
+      sig { override.params(node: SyntaxTree::ConstPathField).void }
+      def visit_const_path_field(node)
+        # We do not call `super` here because we don't want to visit the `constant` again
+        visit(node.parent)
+
+        name = node.constant.value
+        full_name = [*@names_nesting, node_string(node.parent), name].join("::")
+        define_constant(name, full_name, node)
+      end
+
+      sig { override.params(node: SyntaxTree::DefNode).void }
+      def visit_def(node)
+        super
+
+        name = node_string(node.name)
+        define_method(name, [*@names_nesting, name].join("::"), node)
+      end
+
+      sig { override.params(node: SyntaxTree::Field).void }
+      def visit_field(node)
+        visit(node.parent)
+
+        name = node.name
+        case name
+        when SyntaxTree::Const
+          name = name.value
+          full_name = [*@names_nesting, node_string(node.parent), name].join("::")
+          define_constant(name, full_name, node)
+        when SyntaxTree::Ident
+          reference_method(name.value, node) if @in_opassign
+          reference_method("#{name.value}=", node)
+        end
+      end
+
+      sig { override.params(node: SyntaxTree::ModuleDeclaration).void }
+      def visit_module(node)
+        const_name = node_string(node.constant)
+        @names_nesting << const_name
+        define_module(T.must(const_name.split("::").last), @names_nesting.join("::"), node)
+
+        # We do not call `super` here because we don't want to visit the `constant` again
+        visit(node.bodystmt)
+
+        @names_nesting.pop
+      end
+
+      sig { override.params(node: SyntaxTree::OpAssign).void }
+      def visit_opassign(node)
+        # Both `FOO = x` and `FOO += x` yield a VarField node, but the former is a constant definition and the latter is
+        # a constant reference. We need to distinguish between the two cases.
+        @in_opassign = true
+        super
+        @in_opassign = false
+      end
+
+      sig { params(send: Send).void }
+      def visit_send(send)
+        visit(send.recv)
+
+        case send.name
+        when "attr_reader"
+          send.args.each do |arg|
+            next unless arg.is_a?(SyntaxTree::SymbolLiteral)
+
+            name = symbol_string(arg)
+            define_attr_reader(name, [*@names_nesting, name].join("::"), arg)
+          end
+        when "attr_writer"
+          send.args.each do |arg|
+            next unless arg.is_a?(SyntaxTree::SymbolLiteral)
+
+            name = symbol_string(arg)
+            define_attr_writer("#{name}=", "#{[*@names_nesting, name].join("::")}=", arg)
+          end
+        when "attr_accessor"
+          send.args.each do |arg|
+            next unless arg.is_a?(SyntaxTree::SymbolLiteral)
+
+            name = symbol_string(arg)
+            full_name = [*@names_nesting, name].join("::")
+            define_attr_reader(name, full_name, arg)
+            define_attr_writer("#{name}=", "#{full_name}=", arg)
+          end
+        else
+          reference_method(send.name, send.node)
+          visit_all(send.args)
+          visit(send.block)
+        end
+      end
+
+      sig { override.params(node: SyntaxTree::SymbolLiteral).void }
+      def visit_symbol_literal(node)
+        # Something like `:FOO` will yield a Const node but we do not want to treat it as a constant reference.
+        # So we need to distinguish between the two cases.
+        @in_symbol_literal = true
+        super
+        @in_symbol_literal = false
+      end
+
+      sig { override.params(node: SyntaxTree::TopConstField).void }
+      def visit_top_const_field(node)
+        define_constant(node.constant.value, node.constant.value, node)
+      end
+
+      sig { override.params(node: SyntaxTree::VarField).void }
+      def visit_var_field(node)
+        value = node.value
+        case value
+        when SyntaxTree::Const
+          if @in_opassign
+            reference_constant(value.value, node)
+          else
+            name = value.value
+            define_constant(name, [*@names_nesting, name].join("::"), node)
+          end
+        when SyntaxTree::Ident
+          reference_method(value.value, node) if @in_opassign
+          reference_method("#{value.value}=", node)
+        end
+      end
+
+      sig { override.params(node: SyntaxTree::VCall).void }
+      def visit_vcall(node)
+        visit_send(Send.new(node: node, name: node_string(node.value)))
+      end
+
+      private
+
+      # Definition indexing
+
+      sig { params(name: String, full_name: String, node: SyntaxTree::Node).void }
+      def define_attr_reader(name, full_name, node)
+        definition = Definition.new(
+          kind: Definition::Kind::AttrReader,
+          name: name,
+          full_name: full_name,
+          location: node_location(node),
+        )
+        @index.define(definition)
+      end
+
+      sig { params(name: String, full_name: String, node: SyntaxTree::Node).void }
+      def define_attr_writer(name, full_name, node)
+        definition = Definition.new(
+          kind: Definition::Kind::AttrWriter,
+          name: name,
+          full_name: full_name,
+          location: node_location(node),
+        )
+        @index.define(definition)
+      end
+
+      sig { params(name: String, full_name: String, node: SyntaxTree::Node).void }
+      def define_class(name, full_name, node)
+        definition = Definition.new(
+          kind: Definition::Kind::Class,
+          name: name,
+          full_name: full_name,
+          location: node_location(node),
+        )
+        @index.define(definition)
+      end
+
+      sig { params(name: String, full_name: String, node: SyntaxTree::Node).void }
+      def define_constant(name, full_name, node)
+        definition = Definition.new(
+          kind: Definition::Kind::Constant,
+          name: name,
+          full_name: full_name,
+          location: node_location(node),
+        )
+        @index.define(definition)
+      end
+
+      sig { params(name: String, full_name: String, node: SyntaxTree::Node).void }
+      def define_method(name, full_name, node)
+        definition = Definition.new(
+          kind: Definition::Kind::Method,
+          name: name,
+          full_name: full_name,
+          location: node_location(node),
+        )
+        @index.define(definition)
+      end
+
+      sig { params(name: String, full_name: String, node: SyntaxTree::Node).void }
+      def define_module(name, full_name, node)
+        definition = Definition.new(
+          kind: Definition::Kind::Module,
+          name: name,
+          full_name: full_name,
+          location: node_location(node),
+        )
+        @index.define(definition)
+      end
+
+      # Reference indexing
+
+      sig { params(name: String, node: SyntaxTree::Node).void }
+      def reference_constant(name, node)
+        @index.reference(Reference.new(name: name, kind: Reference::Kind::Constant, location: node_location(node)))
+      end
+
+      sig { params(name: String, node: SyntaxTree::Node).void }
+      def reference_method(name, node)
+        @index.reference(Reference.new(name: name, kind: Reference::Kind::Method, location: node_location(node)))
+      end
+
+      # Node utils
+
+      sig { params(node: T.any(Symbol, SyntaxTree::Node)).returns(String) }
+      def node_string(node)
+        case node
+        when Symbol
+          node.to_s
+        else
+          T.must(@source[node.location.start_char...node.location.end_char])
+        end
+      end
+
+      sig { params(node: SyntaxTree::Node).returns(Location) }
+      def node_location(node)
+        Location.from_syntax_tree(@path, node.location)
+      end
+
+      sig { params(node: SyntaxTree::Node).returns(String) }
+      def symbol_string(node)
+        node_string(node).delete_prefix(":")
+      end
+
+      sig do
+        params(
+          node: T.any(SyntaxTree::Args, SyntaxTree::ArgParen, SyntaxTree::ArgsForward, NilClass),
+        ).returns(T::Array[SyntaxTree::Node])
+      end
+      def call_args(node)
+        case node
+        when SyntaxTree::ArgParen
+          call_args(node.arguments)
+        when SyntaxTree::Args
+          node.parts
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/lib/spoom/deadcode/location.rb

@@ -0,0 +1,58 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    class Location
+      extend T::Sig
+
+      include Comparable
+
+      class LocationError < Spoom::Error; end
+
+      class << self
+        extend T::Sig
+
+        sig { params(file: String, location: SyntaxTree::Location).returns(Location) }
+        def from_syntax_tree(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 { override.params(other: BasicObject).returns(T.nilable(Integer)) }
+      def <=>(other)
+        return nil 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
+end

data/lib/spoom/deadcode/reference.rb

@@ -0,0 +1,34 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    # A reference is a call to a method or a constant
+    class Reference < T::Struct
+      extend T::Sig
+
+      class Kind < T::Enum
+        enums do
+          Constant = new
+          Method = new
+        end
+      end
+
+      const :kind, Kind
+      const :name, String
+      const :location, Location
+
+      # Kind
+
+      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/deadcode/send.rb

@@ -0,0 +1,18 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  module Deadcode
+    # An abstraction to simplify handling of SyntaxTree::CallNode, SyntaxTree::Command, SyntaxTree::CommandCall and
+    # SyntaxTree::VCall nodes.
+    class Send < T::Struct
+      extend T::Sig
+
+      const :node, SyntaxTree::Node
+      const :name, String
+      const :recv, T.nilable(SyntaxTree::Node), default: nil
+      const :args, T::Array[SyntaxTree::Node], default: []
+      const :block, T.nilable(SyntaxTree::Node), default: nil
+    end
+  end
+end

data/lib/spoom/deadcode.rb

@@ -0,0 +1,55 @@
+# typed: strict
+# frozen_string_literal: true
+
+require "erubi"
+require "syntax_tree"
+
+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"
+
+module Spoom
+  module Deadcode
+    class Error < Spoom::Error
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      sig { params(message: String, parent: Exception).void }
+      def initialize(message, parent:)
+        super(message)
+        set_backtrace(parent.backtrace)
+      end
+    end
+
+    class ParserError < Error; end
+    class IndexerError < Error; end
+
+    class << self
+      extend T::Sig
+
+      sig { params(index: Index, ruby: String, file: String).void }
+      def index_ruby(index, ruby, file:)
+        node = SyntaxTree.parse(ruby)
+        visitor = Spoom::Deadcode::Indexer.new(file, ruby, index)
+        visitor.visit(node)
+      rescue SyntaxTree::Parser::ParseError => e
+        raise ParserError.new("Error while parsing #{file} (#{e.message} at #{e.lineno}:#{e.column})", parent: e)
+      rescue => e
+        raise IndexerError.new("Error while indexing #{file} (#{e.message})", parent: e)
+      end
+
+      sig { params(index: Index, erb: String, file: String).void }
+      def index_erb(index, erb, file:)
+        ruby = ERB.new(erb).src
+        index_ruby(index, ruby, file: file)
+      end
+    end
+  end
+end

data/lib/spoom/file_collector.rb

@@ -12,15 +12,21 @@ module Spoom
     #
     # If `allow_extensions` is empty, all files are collected.
     # If `allow_extensions` is an array of extensions, only files with one of these extensions are collected.
+    #
+    # If `allow_mime_types` is empty, all files are collected.
+    # If `allow_mime_types` is an array of mimetypes, files without an extension are collected if their mimetype is in
+    # the list.
     sig do
       params(
         allow_extensions: T::Array[String],
+        allow_mime_types: T::Array[String],
         exclude_patterns: T::Array[String],
       ).void
     end
-    def initialize(allow_extensions: [], exclude_patterns: [])
+    def initialize(allow_extensions: [], allow_mime_types: [], exclude_patterns: [])
       @files = T.let([], T::Array[String])
       @allow_extensions = allow_extensions
+      @allow_mime_types = allow_mime_types
       @exclude_patterns = exclude_patterns
     end
 
@@ -68,12 +74,29 @@ module Spoom
       return false if @allow_extensions.empty?
 
       extension = File.extname(path)
-      @allow_extensions.none? { |allowed| extension == allowed }
+      if extension.empty?
+        return true if @allow_mime_types.empty?
+
+        mime = mime_type_for(path)
+        @allow_mime_types.none? { |allowed| mime == allowed }
+      else
+        @allow_extensions.none? { |allowed| extension == allowed }
+      end
     end
 
     sig { params(path: String).returns(T::Boolean) }
     def excluded_path?(path)
-      @exclude_patterns.any? { |pattern| File.fnmatch?(pattern, path) }
+      @exclude_patterns.any? do |pattern|
+        # Use `FNM_PATHNAME` so patterns do not match directory separators
+        # Use `FNM_EXTGLOB` to allow file globbing through `{a,b}`
+        File.fnmatch?(pattern, path, File::FNM_PATHNAME | File::FNM_EXTGLOB)
+      end
+    end
+
+    sig { params(path: String).returns(T.nilable(String)) }
+    def mime_type_for(path)
+      # The `file` command appears to be hanging on MacOS for some files so we timeout after 1s.
+      %x{timeout 1s file --mime-type -b '#{path}'}.split("; ").first&.strip
     end
   end
 end

data/lib/spoom/printer.rb

@@ -10,8 +10,6 @@ module Spoom
 
     include Colorize
 
-    abstract!
-
     sig { returns(T.any(IO, StringIO)) }
     attr_accessor :out
 

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

@@ -12,9 +12,6 @@ module Spoom
     class Message
       extend T::Sig
 
-      sig { returns(String) }
-      attr_reader :jsonrpc
-
       sig { void }
       def initialize
         @jsonrpc = T.let("2.0", String)
@@ -43,9 +40,6 @@ module Spoom
       sig { returns(Integer) }
       attr_reader :id
 
-      sig { returns(String) }
-      attr_reader :method
-
       sig { returns(T::Hash[T.untyped, T.untyped]) }
       attr_reader :params
 

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

@@ -310,7 +310,7 @@ module Spoom
       extend T::Sig
 
       sig { returns(T::Set[Integer]) }
-      attr_accessor :seen
+      attr_reader :seen
 
       sig { returns(T.nilable(String)) }
       attr_accessor :prefix

data/lib/spoom/sorbet/sigils.rb

@@ -28,7 +28,7 @@ module Spoom
         T::Array[String],
       )
 
-      SIGIL_REGEXP = T.let(/^#[\ t]*typed[\ t]*:[ \t]*(\w*)[ \t]*/.freeze, Regexp)
+      SIGIL_REGEXP = T.let(/^#[\ t]*typed[\ t]*:[ \t]*(\w*)[ \t]*/, Regexp)
 
       class << self
         extend T::Sig

data/lib/spoom/version.rb

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

data/lib/spoom.rb

@@ -15,6 +15,7 @@ end
 require "spoom/file_collector"
 require "spoom/context"
 require "spoom/colors"
+require "spoom/deadcode"
 require "spoom/sorbet"
 require "spoom/cli"
 require "spoom/version"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spoom
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.2.2
 platform: ruby
 authors:
 - Alexandre Terrasa
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-03-31 00:00:00.000000000 Z
+date: 2023-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -66,6 +66,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 13.0.1
+- !ruby/object:Gem::Dependency
+  name: erubi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.10.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.10.0
 - !ruby/object:Gem::Dependency
   name: sorbet
   requirement: !ruby/object:Gem::Requirement
@@ -94,6 +108,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.5.9204
+- !ruby/object:Gem::Dependency
+  name: syntax_tree
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.1.1
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -143,6 +171,14 @@ files:
 - lib/spoom/coverage/d3/timeline.rb
 - lib/spoom/coverage/report.rb
 - lib/spoom/coverage/snapshot.rb
+- lib/spoom/deadcode.rb
+- lib/spoom/deadcode/definition.rb
+- lib/spoom/deadcode/erb.rb
+- lib/spoom/deadcode/index.rb
+- lib/spoom/deadcode/indexer.rb
+- lib/spoom/deadcode/location.rb
+- lib/spoom/deadcode/reference.rb
+- lib/spoom/deadcode/send.rb
 - lib/spoom/file_collector.rb
 - lib/spoom/file_tree.rb
 - lib/spoom/printer.rb
@@ -173,14 +209,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.0
+      version: 3.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.9
+rubygems_version: 3.4.14
 signing_key: 
 specification_version: 4
 summary: Useful tools for Sorbet enthusiasts.