spoom 1.2.1 → 1.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b116c81229f1eb09a9e8676643fd54bb3436f7fa2534b06275d657bcd995f0c4
-  data.tar.gz: 93431ed795ccdcb7aa3afcec9cd3bc468c5b1893bfac4f269c33df9f52e32055
+  metadata.gz: 8e7ef8ebef70bc8827cdcb4b2c0e49ed6c53686e0db409908354f3762ad07c10
+  data.tar.gz: a6adb405f0379cbe040e743f177e758e2bdaadcdea13ee9c7f75d84f764434b1
 SHA512:
-  metadata.gz: 826328b46d178109253dc01197f1cf80102c2174d7dc5b3ac1d52c142fee9785e7100e4b444c4bba71e5303fa711d15f8368cd173177b3614b54ce14c60c5b09
-  data.tar.gz: 60a28d2220e2507d9deaf12d7e3f51e5ea08418f79685c40aa469da5bc317dbddfded2c8d49cd0102035e5a990d9fa60693ae65a7d1e7538118768bea1140f7f
+  metadata.gz: 86d74bc7d9554d67c1421908116bbab7615d77e9cb096d461f7885429d495f2b02f19d6024117f7083423cfe7c48165b18918c143f29574896bfbb76a4fb651f
+  data.tar.gz: 754d41e8f26425a42288388879fe1658214adea03002421495297486343a827d6dc79a395e895553ed15f67cdc766a16f4a174aab2a3671bd2455e305a8c6f13

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/cli/coverage.rb

@@ -187,7 +187,7 @@ module Spoom
 
       no_commands do
         def parse_time(string, option)
-          return nil unless string
+          return unless string
 
           Time.parse(string)
         rescue ArgumentError

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

@@ -13,7 +13,7 @@ module Spoom
         sig { params(string: String).returns(T.nilable(Commit)) }
         def parse_line(string)
           sha, epoch = string.split(" ", 2)
-          return nil unless sha && epoch
+          return unless sha && epoch
 
           time = Time.strptime(epoch, "%s")
           Commit.new(sha: sha, time: time)
@@ -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")
 
@@ -78,7 +88,7 @@ module Spoom
       sig { returns(T.nilable(String)) }
       def git_current_branch
         res = git("branch --show-current")
-        return nil unless res.status
+        return unless res.status
 
         res.out.strip
       end
@@ -93,10 +103,10 @@ module Spoom
       sig { params(short_sha: T::Boolean).returns(T.nilable(Spoom::Git::Commit)) }
       def git_last_commit(short_sha: true)
         res = git_log("HEAD --format='%#{short_sha ? "h" : "H"} %at' -1")
-        return nil unless res.status
+        return unless res.status
 
         out = res.out.strip
-        return nil if out.empty?
+        return if out.empty?
 
         Spoom::Git::Commit.parse_line(out)
       end
@@ -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

@@ -52,7 +52,7 @@ module Spoom
           sorbet_bin: sorbet_bin,
           capture_err: capture_err,
         )
-        return nil unless file?(metrics_file)
+        return unless file?(metrics_file)
 
         metrics_path = absolute_path_to(metrics_file)
         metrics = Spoom::Sorbet::MetricsParser.parse_file(metrics_path)
@@ -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) })
@@ -92,7 +109,7 @@ module Spoom
       sig { params(arg: String, sorbet_bin: T.nilable(String), capture_err: T::Boolean).returns(T.nilable(String)) }
       def srb_version(*arg, sorbet_bin: nil, capture_err: true)
         res = T.unsafe(self).srb_tc("--no-config", "--version", *arg, sorbet_bin: sorbet_bin, capture_err: capture_err)
-        return nil unless res.status
+        return unless res.status
 
         res.out.split(" ")[2]
       end
@@ -130,10 +147,10 @@ module Spoom
       sig { returns(T.nilable(Spoom::Git::Commit)) }
       def sorbet_intro_commit
         res = git_log("--diff-filter=A --format='%h %at' -1 -- sorbet/config")
-        return nil unless res.status
+        return unless res.status
 
         out = res.out.strip
-        return nil if out.empty?
+        return if out.empty?
 
         Spoom::Git::Commit.parse_line(out)
       end
@@ -142,10 +159,10 @@ module Spoom
       sig { returns(T.nilable(Spoom::Git::Commit)) }
       def sorbet_removal_commit
         res = git_log("--diff-filter=D --format='%h %at' -1 -- sorbet/config")
-        return nil unless res.status
+        return unless res.status
 
         out = res.out.strip
-        return nil if out.empty?
+        return if out.empty?
 
         Spoom::Git::Commit.parse_line(out)
       end

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