deadweight_rails 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8f891d7c0bea2ab0c695d2a967320a65fd7a217ee60ef61afb11aae767626c56
+  data.tar.gz: 2295aae3602c2a1b502e60b733fbf200f612ad0fcdcb691a94ae662b76507d54
+SHA512:
+  metadata.gz: '08ced7803426dce07aac21d80ad7bb4350b51d354c80d9342c8cac78bb1ec71676a70a6f1d2e7e40217da0bceb700eb131acd547a1484b1130bef18f5a7b6a63'
+  data.tar.gz: 20ffa08067e5998bf8d3636f48e81fd089462cdcfe341723756dafb410124c83fd3f78bf61a468f680478725b52235faa2f48de3893488a28dfdc3c481296b09

data/.github/workflows/rubyonrails.yaml

@@ -0,0 +1,26 @@
+name: Ruby CI
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@78c01b705fd9d5ad960d432d3a0cfa341d50e410 # v1.179.1
+        with:
+          ruby-version: 3.2.0
+          bundler-cache: true
+
+      - name: Install dependencies
+        run: bundle install
+
+      - name: Run RSpec tests
+        run: bundle exec rspec

data/.ruby-version

@@ -0,0 +1 @@
+3.2.0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 mrmalvi
+
+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.

data/README.md

@@ -0,0 +1,124 @@
+# DeadweightRails
+
+[![Gem Version](https://badge.fury.io/rb/deadweight_rails.svg)](https://badge.fury.io/rb/deadweight_rails)
+
+DeadweightRails scans your Rails project for **unused assets and Ruby code**, helping you reduce bundle size, improve performance, and clean your codebase.
+
+---
+
+## Features
+
+- Detect **unused CSS and JS** in Rails asset pipeline
+- Detect **unused Ruby methods**
+- Generate a **report** in terminal with colored output
+- Works with standard Rails directories (`app/assets`, `app/views`, `app/models`)
+- Simple Rake task integration
+
+---
+
+## Installation
+
+Add this line to your Gemfile:
+
+```ruby
+gem 'deadweight_rails'
+```
+
+Then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself:
+
+```bash
+gem install deadweight_rails
+```
+
+---
+
+## Usage
+
+### 1. Rake task
+
+Add this task to `lib/tasks/deadweight.rake`:
+
+```ruby
+require "rake"
+require "deadweight_rails"
+
+namespace :deadweight do
+  desc "Scan Rails project for unused assets and Ruby code"
+  task :scan do
+    DeadweightRails.run
+  end
+end
+```
+
+Run the task:
+
+```bash
+bundle exec rake deadweight:scan
+```
+
+---
+
+### 2. Programmatically
+
+```ruby
+require "deadweight_rails"
+
+# Scan current Rails project
+DeadweightRails.run
+
+# Or scan a specific path
+DeadweightRails.run(path: "/path/to/project")
+```
+
+---
+
+## Example Output
+
+```
+🔎 DEADWEIGHTRAILS REPORT
+
+--- Assets ---
+Unused CSS: old.css
+Unused JS:  legacy.js
+
+--- Ruby ---
+Unused Methods: old_helper
+```
+
+---
+
+## Development
+
+After checking out the repo, run:
+
+```bash
+bin/setup
+rake spec
+bin/console
+```
+
+To install the gem locally:
+
+```bash
+bundle exec rake install
+```
+
+To release a new version:
+
+```bash
+bundle exec rake release
+```
+
+---
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub:
+gem "deadweight_rails", path: "../deadweight_rails"
+https://github.com/[USERNAME]/deadwe

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/deadweight_rails/asset_analyzer.rb

@@ -0,0 +1,114 @@
+require "fileutils"
+
+module DeadweightRails
+  class AssetAnalyzer
+    MANIFEST_CSS = ["application.css", "application.scss", "application.sass"].freeze
+    MANIFEST_JS  = ["application.js"].freeze
+
+    def initialize(path)
+      @path = path
+    end
+
+    def scan
+      views = Dir[File.join(@path, "app/views/**/*.{erb,haml,slim}")].map { |f| File.read(f) }
+
+      css_files = Dir[File.join(@path, "app/assets/stylesheets/**/*.{css,scss,sass}")]
+      js_files  = Dir[File.join(@path, "app/assets/javascripts/**/*.js")]
+
+      used_css = track_used_css(css_files, views)
+      used_js  = track_used_js(js_files, views)
+
+      unused_css = css_files.reject do |f|
+        MANIFEST_CSS.include?(File.basename(f)) ||
+          used_css.include?(File.basename(f, ".*"))
+      end
+
+      unused_js = js_files.reject do |f|
+        MANIFEST_JS.include?(File.basename(f)) ||
+          used_js.include?(File.basename(f, ".js"))
+      end
+
+      { unused_css: unused_css, unused_js: unused_js }
+    end
+
+    private
+
+    # Recursively track used CSS via @import and views
+    def track_used_css(files, views)
+      used = []
+      processed = []
+
+      traverse = lambda do |file|
+        return if file.nil? || processed.include?(file)
+        processed << file
+
+        content  = File.read(file)
+        basename = File.basename(file, ".*")
+
+        # Mark as used if selectors match a view
+        used << basename if views.any? { |v| content_match_views?(content, v) }
+
+        # Follow imports
+        imports = content.scan(/@import\s+["']([\w\/-]+)["']/).flatten
+        imports.each do |import_name|
+          import_file = files.find { |f| File.basename(f, ".*") == import_name }
+          next unless import_file
+
+          used << File.basename(import_file, ".*")
+          traverse.call(import_file)
+
+          used << basename
+        end
+      end
+
+      # Always start from manifest files if they exist
+      manifest_files = files.select { |f| MANIFEST_CSS.include?(File.basename(f)) }
+      if manifest_files.any?
+        manifest_files.each { |f| traverse.call(f) }
+      else
+        files.each { |f| traverse.call(f) }
+      end
+
+      used.uniq
+    end
+
+
+    # Recursively track used JS via //= require and views
+    def track_used_js(files, views)
+      used = []
+      processed = []
+
+      traverse = lambda do |file|
+        return if file.nil? || processed.include?(file)
+        processed << file
+
+        content  = File.read(file)
+        basename = File.basename(file, ".js")
+        used << basename
+
+        # Follow requires
+        requires = content.scan(/\/\/=\s*require\s+([\w\/-]+)/).flatten
+        requires.each do |req_name|
+          req_file = files.find { |f| File.basename(f, ".js") == req_name }
+          traverse.call(req_file)
+        end
+      end
+
+      # Always start from manifest files
+      manifest_files = files.select { |f| MANIFEST_JS.include?(File.basename(f)) }
+      manifest_files.each { |f| traverse.call(f) }
+
+      # Also check files referenced in views
+      files.each do |f|
+        traverse.call(f) if views.any? { |v| v.include?(File.basename(f, ".js")) }
+      end
+
+      used.uniq
+    end
+
+    def content_match_views?(content, view)
+      selectors = content.scan(/\.(\w[\w-]*)/).flatten
+      selectors.any? { |s| view.include?(s) }
+    end
+  end
+end

data/lib/deadweight_rails/css_class_analyzer.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module DeadweightRails
+  class CSSClassAnalyzer
+    # Returns a hash of { "filename.css" => [unused_class1, unused_class2] }
+    def initialize(path)
+      @path = path
+    end
+
+    def scan
+      css_files = Dir[File.join(@path, "app/assets/stylesheets/**/*.{css,scss,sass}")]
+      views     = Dir[File.join(@path, "app/views/**/*.{erb,haml,slim}")].map { |f| File.read(f) }
+
+      unused_classes = {}
+
+      css_files.each do |file|
+        content = File.read(file)
+        classes = content.scan(/\.(\w[\w-]*)/).flatten
+
+        unused = (classes || []).reject do |cls|
+          views.any? { |view| view.include?(cls) }
+        end
+
+        unused_classes[File.basename(file)] = unused unless unused.empty?
+      end
+
+      unused_classes
+    end
+  end
+end

data/lib/deadweight_rails/report.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "colorize"
+
+module DeadweightRails
+  class Report
+    def initialize(asset_results, ruby_results, css_classes = {})
+      @assets = asset_results || {}
+      @ruby   = ruby_results || {}
+      @css_classes = css_classes || {} # optional: per-file unused CSS classes
+    end
+
+    def print
+      print_assets
+      print_css_classes
+      print_ruby_methods
+    end
+
+    private
+
+    def print_assets
+      puts "\n--- Assets ---".colorize(:green)
+
+      unused_css = (@assets[:unused_css] || []).map { |f| File.basename(f) }
+      unused_js  = (@assets[:unused_js] || []).map { |f| File.basename(f) }
+
+      puts "Unused CSS Files: #{unused_css.join(", ")}"
+      puts "Unused JS Files:  #{unused_js.join(", ")}"
+    end
+
+    def print_css_classes
+      return if @css_classes.empty?
+
+      puts "\n--- Unused CSS Classes ---".colorize(:green)
+      @css_classes.each do |file, classes|
+        next if classes.nil? || classes.empty?
+
+        puts "#{file}: #{classes.join(", ")}"
+      end
+    end
+
+    def print_ruby_methods
+      unused_methods = @ruby[:unused_methods] || {}
+
+      return if unused_methods.empty?
+
+      puts "\n--- Ruby ---".colorize(:green)
+      unused_methods.each do |klass, methods|
+        next if methods.nil? || methods.empty?
+
+        puts "#{klass}: #{methods.join(", ")}"
+      end
+    end
+  end
+end

data/lib/deadweight_rails/ruby_analyzer.rb

@@ -0,0 +1,92 @@
+require "parser/current"
+
+module DeadweightRails
+  class RubyAnalyzer
+    def initialize(path)
+      @path = path
+      @defined_methods = Hash.new { |h, k| h[k] = [] }
+      @called_methods  = Hash.new { |h, k| h[k] = [] }
+    end
+
+    def scan
+      ruby_files = Dir[File.join(@path, "{app,lib}/**/*.rb")]
+
+      ruby_files.each do |file|
+        next unless File.file?(file)
+        next if File.basename(file).to_s.include? "controller.rb"
+        content = File.read(file)
+
+        # 🧭 Debug: stop when analyzing company.rb
+        begin
+          ast = Parser::CurrentRuby.parse(content)
+          walk(ast)
+        rescue Parser::SyntaxError => e
+          warn "⚠️ Skipping #{file}: #{e.message}"
+        end
+      end
+
+      # Compute unused methods per class
+      result = {}
+      @defined_methods.each do |klass, methods|
+        used = @called_methods[klass] || []
+        unused = methods - used
+        result[klass] = unused if unused.any?
+      end
+
+      puts "\n✅ Final detected methods:"
+      pp @defined_methods
+
+      result
+    end
+
+    private
+
+    def walk(node, current_class = nil)
+      return unless node.is_a?(Parser::AST::Node)
+
+      case node.type
+      when :class, :module
+        const_node = node.children[0]
+        class_name = extract_const_name(const_node)
+        body = node.children[2]
+        walk(body, class_name)
+
+      when :def
+        method_name = node.children[0]
+        if current_class
+          @defined_methods[current_class] << method_name
+          puts "🟢 Found instance method #{method_name} in #{current_class}"
+        else
+          puts "⚪ Found method #{method_name} outside any class"
+        end
+
+      when :defs
+        method_name = node.children[1]
+        if current_class
+          @defined_methods["#{current_class}.self"] << method_name
+          puts "🔵 Found class method #{method_name} in #{current_class}"
+        end
+      end
+
+      node.children.each do |child|
+        walk(child, current_class) if child.is_a?(Parser::AST::Node)
+      end
+    end
+
+    def extract_const_name(node)
+      return nil unless node
+
+      case node.type
+      when :const
+        parent_node, name_sym = node.children
+        parent_name = extract_const_name(parent_node)
+        name = name_sym.to_s
+        parent_name ? "#{parent_name}::#{name}" : name
+      when :cbase
+        "" # Handles leading ::
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/deadweight_rails/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module DeadweightRails
+  VERSION = "0.1.0"
+end

data/lib/deadweight_rails.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "deadweight_rails/version"
+require "deadweight_rails/asset_analyzer"
+require "deadweight_rails/ruby_analyzer"
+require "deadweight_rails/css_class_analyzer"
+require "deadweight_rails/report"
+
+module DeadweightRails
+  def self.run(path: Dir.pwd)
+    puts "\n🔎 DEADWEIGHTRAILS REPORT".upcase.colorize(:cyan)
+    asset_results     = AssetAnalyzer.new(path).scan
+    ruby_results      = RubyAnalyzer.new(path).scan
+    css_class_results = CSSClassAnalyzer.new(path).scan # NEW
+
+    Report.new(asset_results, ruby_results, css_class_results).print
+  end
+end

data/sig/deadweight_rails.rbs

@@ -0,0 +1,4 @@
+module DeadweightRails
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: deadweight_rails
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- mrmalvi
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: set
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.0'
+description: DeadweightRails scans your Rails project for dead assets and unused Ruby
+  code.
+email:
+- malviyak00@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".github/workflows/rubyonrails.yaml"
+- ".ruby-version"
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/deadweight_rails.rb
+- lib/deadweight_rails/asset_analyzer.rb
+- lib/deadweight_rails/css_class_analyzer.rb
+- lib/deadweight_rails/report.rb
+- lib/deadweight_rails/ruby_analyzer.rb
+- lib/deadweight_rails/version.rb
+- sig/deadweight_rails.rbs
+homepage: https://github.com/mrmalvi/deadweight_rails
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Detect unused CSS/JS assets and Ruby methods/classes in Rails apps
+test_files: []