# ๐๏ธ Garbage Code Hunter
[](https://www.rust-lang.org)
[](LICENSE)
[]()
A humorous Rust code quality detector that roasts your garbage code with style! ๐ฅ
```
Inspiration from https://github.com/Done-0/fuck-u-code.git
```
Unlike traditional linters that give you dry, boring warnings, Garbage Code Hunter delivers **sarcastic, witty, and brutally honest** feedback about your code quality. It's like having a sassy code reviewer who isn't afraid to hurt your feelings (in a good way).
## โจ Features
- ๐ญ **Humorous Code Analysis**: Get roasted with style while learning better coding practices
- ๐ **Multi-language Support**: Available in English and Chinese (more languages coming soon!)
- ๐ฏ **Smart Detection**: Identifies common code smells and anti-patterns
- ๐ **Professional Reports**: Generate detailed analysis reports in multiple formats
- ๐ง **Highly Configurable**: Customize output, filtering, and analysis depth
- ๐ **Markdown Export**: Perfect for documentation and CI/CD integration
- ๐ **Fast & Lightweight**: Built with Rust for maximum performance
## ๐ฏ Scoring System
Garbage Code Hunter includes a comprehensive **scientific scoring system** that evaluates your Rust code quality on a scale of **0-100**, where:
- **Lower scores = Better code quality** ๐
- **Higher scores = More problematic code** ๐
### ๐ Score Ranges & Quality Levels
| 0-20 | Excellent | ๐ | Outstanding code quality with minimal issues |
| 21-40 | Good | ๐ | Good code quality with minor improvements needed |
| 41-60 | Average | ๐ | Average code quality with room for improvement |
| 61-80 | Poor | ๐ | Poor code quality, refactoring recommended |
| 81-100 | Terrible | ๐ | Critical code quality issues, rewrite urgently needed |
### ๐งฎ Scoring Algorithm
The scoring system uses a **multi-factor algorithm** that considers:
#### 1. **Base Score Calculation**
Each detected issue contributes to the base score using:
```
Issue Score = Rule Weight ร Severity Weight
```
#### 2. **Rule Weights** (Impact Factor)
Different types of issues have different weights based on their impact:
| **Safety Critical** | `unsafe-abuse` | 5.0 | Memory safety violations |
| **FFI Critical** | `ffi-abuse` | 4.5 | Foreign function interface risks |
| **Runtime Critical** | `unwrap-abuse` | 4.0 | Potential panic sources |
| **Architecture** | `lifetime-abuse` | 3.5 | Complex lifetime management |
| **Async/Concurrency** | `async-abuse` | 3.5 | Async pattern misuse |
| **Complexity** | `deep-nesting` | 3.0 | Code maintainability |
| **Performance** | `unnecessary-clone` | 2.0 | Runtime efficiency |
| **Readability** | `terrible-naming` | 2.0 | Code comprehension |
#### 3. **Severity Weights**
Issues are classified by severity with corresponding multipliers:
- **Nuclear** (๐ฅ): 10.0ร - Critical issues that can cause crashes or security vulnerabilities
- **Spicy** (๐ถ๏ธ): 5.0ร - Serious issues affecting maintainability or performance
- **Mild** (๐): 2.0ร - Minor issues with style or best practices
#### 4. **Density Penalties**
Additional penalties based on issue concentration:
- **Issue Density**: Problems per 1000 lines of code
- \>50 issues/1000 lines: +25 penalty
- \>30 issues/1000 lines: +15 penalty
- \>20 issues/1000 lines: +10 penalty
- \>10 issues/1000 lines: +5 penalty
- **File Complexity**: Average issues per file
- \>20 issues/file: +15 penalty
- \>10 issues/file: +10 penalty
- \>5 issues/file: +5 penalty
#### 5. **Severity Distribution Penalties**
Extra penalties for problematic patterns:
- **Nuclear Issues**: First nuclear issue +20, each additional +5
- **Spicy Issues**: After 5 spicy issues, each additional +2
- **Mild Issues**: After 20 mild issues, each additional +0.5
### ๐ Metrics Included
The scoring system provides detailed metrics:
- **Total Score**: Overall code quality score (0-100)
- **Category Scores**: Breakdown by issue categories
- **Issue Density**: Problems per 1000 lines of code
- **Severity Distribution**: Count of nuclear/spicy/mild issues
- **File Count**: Number of analyzed Rust files
- **Total Lines**: Total lines of code analyzed
### ๐ฏ Interpretation Guide
**For Excellent Code (0-20):**
- Minimal issues detected
- Strong adherence to Rust best practices
- Good architecture and safety patterns
**For Good Code (21-40):**
- Few minor issues
- Generally well-structured
- Minor optimizations possible
**For Average Code (41-60):**
- Moderate number of issues
- Some refactoring beneficial
- Focus on complexity reduction
**For Poor Code (61-80):**
- Significant issues present
- Refactoring strongly recommended
- Address safety and complexity concerns
**For Terrible Code (81-100):**
- Critical issues requiring immediate attention
- Consider rewriting problematic sections
- Focus on safety, correctness, and maintainability
### ๐ฌ Scientific Approach
The scoring system is designed to be:
- **Objective**: Based on measurable code metrics
- **Weighted**: Critical issues have higher impact
- **Contextual**: Considers code size and complexity
- **Actionable**: Provides specific improvement areas
- **Consistent**: Reproducible results across runs
## ๐ช What It Detects
### Naming Disasters
- Terrible variable names (`data`, `temp`, `info`, `obj`)
- Single-letter variables (except common loop counters)
- Generic meaningless identifiers
### Code Structure Issues
- Deep nesting (Russian doll syndrome)
- Overly long functions
- Complex conditional logic
### Rust-Specific Anti-patterns
- `unwrap()` abuse (panic bombs ๐ฃ)
- Unnecessary `clone()` calls (memory waste)
- Poor error handling patterns
## ๐ Installation
### From Source
```bash
git clone https://github.com/yourusername/garbage-code-hunter.git
cd garbage-code-hunter
make install
```
### Using Cargo
```bash
cargo install garbage-code-hunter
```
## ๐ Usage
### Basic Usage
```bash
# Analyze current directory
garbage-code-hunter
# Analyze specific file or directory
garbage-code-hunter src/main.rs
garbage-code-hunter src/
```
### Language Options
```bash
# Chinese output (default)
garbage-code-hunter --lang zh-CN src/
# English output
garbage-code-hunter --lang en-US src/
```
### Advanced Options
```bash
# Verbose analysis with top 3 problematic files
garbage-code-hunter --verbose --top 3 --issues 5 src/
# Only show summary
garbage-code-hunter --summary src/
# Generate Markdown report
garbage-code-hunter --markdown src/ > code-quality-report.md
# Exclude files/directories
garbage-code-hunter --exclude "test_*" --exclude "target/*" src/
# Show only serious issues
garbage-code-hunter --harsh src/
```
## ๐จ Sample Output
### English Mode
```
๐๏ธ Garbage Code Hunter ๐๏ธ
Preparing to roast your code...
๐ Code Quality Report
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
Found some areas for improvement:
๐ Issue Statistics:
2 ๐ฅ Nuclear Issues (fix immediately)
5 ๐ถ๏ธ Spicy Issues (should fix)
3 ๐ Mild Issues (can ignore)
10 ๐ Total
๐ main.rs
๐ฅ Line 15:1 - This variable name is more abstract than my programming skills
๐ถ๏ธ Line 23:5 - Another unwrap()! Are you trying to make the program explode in production?
๐ Line 8:9 - Single letter variable? Are you writing math formulas or torturing code readers?
```
### Chinese Mode
```
๐๏ธ ๅๅพไปฃ็ ็ไบบ ๐๏ธ
ๆญฃๅจๅๅคๅๆงฝไฝ ็ไปฃ็ ...
๐ ๅๅพไปฃ็ ๆฃๆตๆฅๅ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
ๅ็ฐไบไธไบ้่ฆๆน่ฟ็ๅฐๆน๏ผ
๐ ้ฎ้ข็ป่ฎก:
2 ๐ฅ ๆ ธๅผน็บง้ฎ้ข (้่ฆ็ซๅณไฟฎๅค)
5 ๐ถ๏ธ ่พฃ็ผ็้ฎ้ข (ๅปบ่ฎฎไฟฎๅค)
3 ๐ ่ฝปๅพฎ้ฎ้ข (ๅฏไปฅๅฟฝ็ฅ)
10 ๐ ๆป่ฎก
๐ main.rs
๐ฅ 15:1 ่ฟไธชๅ้ๅๆฏๆ็็ผ็จๆ่ฝ่ฟ่ฆๆฝ่ฑก
๐ถ๏ธ 23:5 ๅไธไธช unwrap()๏ผไฝ ๆฏๆณ่ฎฉ็จๅบๅจ็ไบง็ฏๅข้็็ธๅ๏ผ
๐ 8:9 ๅๅญๆฏๅ้๏ผไฝ ๆฏๅจๅๆฐๅญฆๅ
ฌๅผ่ฟๆฏๅจๆ็ฃจ่ฏปไปฃ็ ็ไบบ๏ผ
```
## ๐ ๏ธ Command Line Options
| `--help` | `-h` | Show help message |
| `--verbose` | `-v` | Show detailed analysis report |
| `--top N` | `-t N` | Show top N files with most issues (default: 5) |
| `--issues N` | `-i N` | Show N issues per file (default: 5) |
| `--summary` | `-s` | Only show summary conclusion |
| `--markdown` | `-m` | Output Markdown format report |
| `--lang LANG` | `-l LANG` | Output language (zh-CN, en-US) |
| `--exclude PATTERN` | `-e PATTERN` | Exclude file/directory patterns |
| `--harsh` | | Show only the worst offenders |
## ๐ง Development
### Prerequisites
- Rust 1.70 or later
- Cargo
### Building
```bash
# Debug build
make build
# Release build
make release
# Run tests
make test
# Format code
make fmt
# Run linter
make clippy
```
### Running Demo
```bash
make demo
```
This creates a sample file with intentionally bad code and runs the analyzer on it.
## ๐ฏ Examples
### CI/CD Integration
```yaml
# GitHub Actions example
- name: Code Quality Check
run: |
cargo install garbage-code-hunter
garbage-code-hunter --markdown --lang en-US src/ > quality-report.md
# Upload report as artifact or comment on PR
```
### Pre-commit Hook
```bash
#!/bin/bash
# .git/hooks/pre-commit
garbage-code-hunter --harsh --summary src/
if [ $? -ne 0 ]; then
echo "Code quality issues detected. Please fix before committing."
exit 1
fi
```
## ๐ค Contributing
We welcome contributions! Here's how you can help:
1. **Add New Rules**: Implement additional code smell detection
2. **Language Support**: Add translations for more languages
3. **Improve Messages**: Make the roasts even funnier (but still helpful)
4. **Documentation**: Help improve docs and examples
5. **Bug Reports**: Found a bug? Let us know!
### Adding New Detection Rules
1. Create a new rule in `src/rules/`
2. Implement the `Rule` trait
3. Add humorous messages in `src/i18n.rs`
4. Add tests
5. Submit a PR!
## ๐ License
This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
## ๐ Acknowledgments
- Inspired by the need for more entertaining code reviews
- Built with โค๏ธ and a lot of โ
- Thanks to all the developers who write garbage code (we've all been there!)
## ๐ Links
- [Documentation](https://docs.rs/garbage-code-hunter)
- [Crates.io](https://crates.io/crates/garbage-code-hunter)
- [GitHub Repository](https://github.com/yourusername/garbage-code-hunter)
- [Issue Tracker](https://github.com/yourusername/garbage-code-hunter/issues)
---
**Remember**: The goal isn't to shame developers, but to make code quality improvement fun and memorable. Happy coding! ๐