spoom 1.2.0 → 1.2.2

data/lib/spoom/file_collector.rb

@@ -0,0 +1,102 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Spoom
+  class FileCollector
+    extend T::Sig
+
+    sig { returns(T::Array[String]) }
+    attr_reader :files
+
+    # Initialize a new file collector
+    #
+    # 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: [], 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
+
+    sig { params(paths: T::Array[String]).void }
+    def visit_paths(paths)
+      paths.each { |path| visit_path(path) }
+    end
+
+    sig { params(path: String).void }
+    def visit_path(path)
+      path = clean_path(path)
+
+      return if excluded_path?(path)
+
+      if File.file?(path)
+        visit_file(path)
+      elsif File.directory?(path)
+        visit_directory(path)
+      else # rubocop:disable Style/EmptyElse
+        # Ignore aliases, sockets, etc.
+      end
+    end
+
+    private
+
+    sig { params(path: String).returns(String) }
+    def clean_path(path)
+      Pathname.new(path).cleanpath.to_s
+    end
+
+    sig { params(path: String).void }
+    def visit_file(path)
+      return if excluded_file?(path)
+
+      @files << path
+    end
+
+    sig { params(path: String).void }
+    def visit_directory(path)
+      visit_paths(Dir.glob("#{path}/*"))
+    end
+
+    sig { params(path: String).returns(T::Boolean) }
+    def excluded_file?(path)
+      return false if @allow_extensions.empty?
+
+      extension = File.extname(path)
+      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? 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/file_tree.rb

@@ -6,13 +6,9 @@ module Spoom
   class FileTree
     extend T::Sig
 
-    sig { returns(T.nilable(String)) }
-    attr_reader :strip_prefix
-
-    sig { params(paths: T::Enumerable[String], strip_prefix: T.nilable(String)).void }
-    def initialize(paths = [], strip_prefix: nil)
+    sig { params(paths: T::Enumerable[String]).void }
+    def initialize(paths = [])
       @roots = T.let({}, T::Hash[String, Node])
-      @strip_prefix = strip_prefix
       add_paths(paths)
     end
 
@@ -27,8 +23,6 @@ module Spoom
     # This will create all nodes until the root of `path`.
     sig { params(path: String).returns(Node) }
     def add_path(path)
-      prefix = @strip_prefix
-      path = path.delete_prefix("#{prefix}/") if prefix
       parts = path.split("/")
       if path.empty? || parts.size == 1
         return @roots[path] ||= Node.new(parent: nil, name: path)
@@ -49,43 +43,51 @@ module Spoom
     # All the nodes in this tree
     sig { returns(T::Array[Node]) }
     def nodes
-      all_nodes = []
-      @roots.values.each { |root| collect_nodes(root, all_nodes) }
-      all_nodes
+      v = CollectNodes.new
+      v.visit_tree(self)
+      v.nodes
     end
 
     # All the paths in this tree
     sig { returns(T::Array[String]) }
     def paths
-      nodes.collect(&:path)
+      nodes.map(&:path)
     end
 
-    sig do
-      params(
-        out: T.any(IO, StringIO),
-        show_strictness: T::Boolean,
-        colors: T::Boolean,
-        indent_level: Integer,
-      ).void
+    # Return a map of strictnesses for each node in the tree
+    sig { params(context: Context).returns(T::Hash[Node, T.nilable(String)]) }
+    def nodes_strictnesses(context)
+      v = CollectStrictnesses.new(context)
+      v.visit_tree(self)
+      v.strictnesses
     end
-    def print(out: $stdout, show_strictness: true, colors: true, indent_level: 0)
-      printer = TreePrinter.new(
-        tree: self,
-        out: out,
-        show_strictness: show_strictness,
-        colors: colors,
-        indent_level: indent_level,
-      )
-      printer.print_tree
+
+    # Return a map of typing scores for each node in the tree
+    sig { params(context: Context).returns(T::Hash[Node, Float]) }
+    def nodes_strictness_scores(context)
+      v = CollectScores.new(context)
+      v.visit_tree(self)
+      v.scores
     end
 
-    private
+    # Return a map of typing scores for each path in the tree
+    sig { params(context: Context).returns(T::Hash[String, Float]) }
+    def paths_strictness_scores(context)
+      nodes_strictness_scores(context).map { |node, score| [node.path, score] }.to_h
+    end
 
-    sig { params(node: FileTree::Node, collected_nodes: T::Array[Node]).returns(T::Array[Node]) }
-    def collect_nodes(node, collected_nodes = [])
-      collected_nodes << node
-      node.children.values.each { |child| collect_nodes(child, collected_nodes) }
-      collected_nodes
+    sig { params(out: T.any(IO, StringIO), colors: T::Boolean).void }
+    def print(out: $stdout, colors: true)
+      printer = Printer.new({}, out: out, colors: colors)
+      printer.visit_tree(self)
+    end
+
+    sig { params(context: Context, out: T.any(IO, StringIO), colors: T::Boolean).void }
+    def print_with_strictnesses(context, out: $stdout, colors: true)
+      strictnesses = nodes_strictnesses(context)
+
+      printer = Printer.new(strictnesses, out: out, colors: colors)
+      printer.visit_tree(self)
     end
 
     # A node representing either a file or a directory inside a FileTree
@@ -111,77 +113,160 @@ module Spoom
       end
     end
 
+    # An abstract visitor for FileTree
+    class Visitor
+      extend T::Sig
+      extend T::Helpers
+
+      abstract!
+
+      sig { params(tree: FileTree).void }
+      def visit_tree(tree)
+        visit_nodes(tree.roots)
+      end
+
+      sig { params(node: FileTree::Node).void }
+      def visit_node(node)
+        visit_nodes(node.children.values)
+      end
+
+      sig { params(nodes: T::Array[FileTree::Node]).void }
+      def visit_nodes(nodes)
+        nodes.each { |node| visit_node(node) }
+      end
+    end
+
+    # A visitor that collects all the nodes in a tree
+    class CollectNodes < Visitor
+      extend T::Sig
+
+      sig { returns(T::Array[FileTree::Node]) }
+      attr_reader :nodes
+
+      sig { void }
+      def initialize
+        super()
+        @nodes = T.let([], T::Array[FileTree::Node])
+      end
+
+      sig { override.params(node: FileTree::Node).void }
+      def visit_node(node)
+        @nodes << node
+        super
+      end
+    end
+
+    # A visitor that collects the strictness of each node in a tree
+    class CollectStrictnesses < Visitor
+      extend T::Sig
+
+      sig { returns(T::Hash[Node, T.nilable(String)]) }
+      attr_reader :strictnesses
+
+      sig { params(context: Context).void }
+      def initialize(context)
+        super()
+        @context = context
+        @strictnesses = T.let({}, T::Hash[Node, T.nilable(String)])
+      end
+
+      sig { override.params(node: FileTree::Node).void }
+      def visit_node(node)
+        path = node.path
+        @strictnesses[node] = @context.read_file_strictness(path) if @context.file?(path)
+
+        super
+      end
+    end
+
+    # A visitor that collects the typing score of each node in a tree
+    class CollectScores < CollectStrictnesses
+      extend T::Sig
+
+      sig { returns(T::Hash[Node, Float]) }
+      attr_reader :scores
+
+      sig { params(context: Context).void }
+      def initialize(context)
+        super
+        @context = context
+        @scores = T.let({}, T::Hash[Node, Float])
+      end
+
+      sig { override.params(node: FileTree::Node).void }
+      def visit_node(node)
+        super
+
+        @scores[node] = node_score(node)
+      end
+
+      private
+
+      sig { params(node: Node).returns(Float) }
+      def node_score(node)
+        if @context.file?(node.path)
+          strictness_score(@strictnesses[node])
+        else
+          node.children.values.sum { |child| @scores.fetch(child, 0.0) } / node.children.size.to_f
+        end
+      end
+
+      sig { params(strictness: T.nilable(String)).returns(Float) }
+      def strictness_score(strictness)
+        case strictness
+        when "true", "strict", "strong"
+          1.0
+        else
+          0.0
+        end
+      end
+    end
+
     # An internal class used to print a FileTree
     #
     # See `FileTree#print`
-    class TreePrinter < Spoom::Printer
+    class Printer < Visitor
       extend T::Sig
 
-      sig { returns(FileTree) }
-      attr_reader :tree
-
       sig do
         params(
-          tree: FileTree,
+          strictnesses: T::Hash[FileTree::Node, T.nilable(String)],
           out: T.any(IO, StringIO),
-          show_strictness: T::Boolean,
           colors: T::Boolean,
-          indent_level: Integer,
         ).void
       end
-      def initialize(tree:, out: $stdout, show_strictness: true, colors: true, indent_level: 0)
-        super(out: out, colors: colors, indent_level: indent_level)
-        @tree = tree
-        @show_strictness = show_strictness
+      def initialize(strictnesses, out: $stdout, colors: true)
+        super()
+        @strictnesses = strictnesses
+        @colors = colors
+        @printer = T.let(Spoom::Printer.new(out: out, colors: colors), Spoom::Printer)
       end
 
-      sig { void }
-      def print_tree
-        print_nodes(tree.roots)
-      end
-
-      sig { params(node: FileTree::Node).void }
-      def print_node(node)
-        printt
+      sig { override.params(node: FileTree::Node).void }
+      def visit_node(node)
+        @printer.printt
         if node.children.empty?
-          if @show_strictness
-            strictness = node_strictness(node)
-            if @colors
-              print_colored(node.name, strictness_color(strictness))
-            elsif strictness
-              print("#{node.name} (#{strictness})")
-            else
-              print(node.name.to_s)
-            end
+          strictness = @strictnesses[node]
+          if @colors
+            @printer.print_colored(node.name, strictness_color(strictness))
+          elsif strictness
+            @printer.print("#{node.name} (#{strictness})")
           else
-            print(node.name.to_s)
+            @printer.print(node.name.to_s)
           end
-          print("\n")
+          @printer.print("\n")
         else
-          print_colored(node.name, Color::BLUE)
-          print("/")
-          printn
-          indent
-          print_nodes(node.children.values)
-          dedent
+          @printer.print_colored(node.name, Color::BLUE)
+          @printer.print("/")
+          @printer.printn
+          @printer.indent
+          super
+          @printer.dedent
         end
       end
 
-      sig { params(nodes: T::Array[FileTree::Node]).void }
-      def print_nodes(nodes)
-        nodes.each { |node| print_node(node) }
-      end
-
       private
 
-      sig { params(node: FileTree::Node).returns(T.nilable(String)) }
-      def node_strictness(node)
-        path = node.path
-        prefix = tree.strip_prefix
-        path = "#{prefix}/#{path}" if prefix
-        Spoom::Sorbet::Sigils.file_strictness(path)
-      end
-
       sig { params(strictness: T.nilable(String)).returns(Color) }
       def strictness_color(strictness)
         case strictness

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/config.rb

@@ -26,8 +26,10 @@ module Spoom
     class Config
       extend T::Sig
 
+      DEFAULT_ALLOWED_EXTENSIONS = T.let([".rb", ".rbi"].freeze, T::Array[String])
+
       sig { returns(T::Array[String]) }
-      attr_reader :paths, :ignore, :allowed_extensions
+      attr_accessor :paths, :ignore, :allowed_extensions
 
       sig { returns(T::Boolean) }
       attr_accessor :no_stdlib

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
@@ -85,21 +85,6 @@ module Spoom
             change_sigil_in_file(path, new_strictness)
           end
         end
-
-        # finds all files in the specified directory with the passed strictness
-        sig do
-          params(
-            directory: T.any(String, Pathname),
-            strictness: String,
-            extension: String,
-          ).returns(T::Array[String])
-        end
-        def files_with_sigil_strictness(directory, strictness, extension: ".rb")
-          paths = Dir.glob("#{File.expand_path(directory)}/**/*#{extension}").sort.uniq
-          paths.filter do |path|
-            file_strictness(path) == strictness
-          end
-        end
       end
     end
   end

data/lib/spoom/version.rb

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

data/lib/spoom.rb

@@ -12,8 +12,10 @@ module Spoom
   class Error < StandardError; end
 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.0
+  version: 1.2.2
 platform: ruby
 authors:
 - Alexandre Terrasa
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-03-30 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,15 @@ 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
 - lib/spoom/sorbet.rb
@@ -172,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.