Contributing to Stringy#

git clone https://github.com/EvilBit-Labs/StringyMcStringFace
cd StringyMcStringFace

# Install development dependencies
cargo build
cargo test

# Code formatting
rustup component add rustfmt

# Linting
rustup component add clippy

# Documentation
cargo install mdbook

# Test runner (optional but recommended)
cargo install cargo-nextest

# Coverage (optional)
cargo install cargo-llvm-cov

src/
├── main.rs # CLI entry point
├── lib.rs # Library root and public API
├── types.rs # Core data structures
├── container/ # Binary format parsers
│ ├── mod.rs # Format detection
│ ├── elf.rs # ELF parser
│ ├── pe.rs # PE parser
│ └── macho.rs # Mach-O parser
├── extraction/ # String extraction
├── classification/ # Semantic analysis
└── output/ # Output formatting

tests/
├── integration/ # End-to-end tests
├── fixtures/ # Test binary files
└── unit/ # Module-specific tests

docs/
├── src/ # mdbook documentation
└── book.toml # Documentation config

git checkout -b feature/your-feature-name
# or
git checkout -b fix/issue-description

# Format code
cargo fmt

# Check for issues
cargo clippy -- -D warnings

# Run tests
cargo test
# or with nextest
cargo nextest run

# Unit tests
cargo test --lib

# Integration tests
cargo test --test integration

# Documentation tests
cargo test --doc

# Manual testing
cargo run -- test_binary.exe

# Update API docs
cargo doc --open

# Update user documentation
cd docs
mdbook serve --open

use crate::types::{Result, StringyError};

fn parse_something() -> Result<ParsedData> {
    // Use ? operator for error propagation
    let data = read_file(path)?;

    // Create specific errors when needed
    if data.is_empty() {
        return Err(StringyError::ParseError("Empty file".to_string()));
    }

    Ok(ParsedData::new(data))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_basic_functionality() {
        let input = create_test_input();
        let result = function_under_test(input);
        assert_eq!(result.unwrap(), expected_output());
    }

    #[test]
    fn test_error_conditions() {
        let invalid_input = create_invalid_input();
        let result = function_under_test(invalid_input);
        assert!(result.is_err());
    }
}

/// Extracts strings from the given binary data.
///
/// This function analyzes the binary format and applies appropriate
/// extraction strategies based on the detected format and sections.
///
/// # Arguments
///
/// * `data` - The binary data to analyze
/// * `config` - Extraction configuration options
///
/// # Returns
///
/// A vector of extracted strings with metadata, or an error if
/// the binary format is unsupported or corrupted.
///
/// # Examples
///
/// ```
/// use stringy::{extract_strings, ExtractionConfig};
///
/// let data = std::fs::read("binary.exe")?;
/// let config = ExtractionConfig::default();
/// let strings = extract_strings(&data, &config)?;
/// ```
pub fn extract_strings(data: &[u8], config: &ExtractionConfig) -> Result<Vec<FoundString>> {
    // Implementation
}

# Add to tests/fixtures/
tests/fixtures/
├── elf/
│ ├── simple_hello_world
│ └── complex_application
├── pe/
│ ├── hello.exe
│ └── complex.dll
└── macho/
    ├── hello_macos
    └── framework.dylib

#[cfg(test)]
mod benchmarks {
    use super::*;
    use criterion::{Criterion, black_box, criterion_group, criterion_main};

    fn bench_string_extraction(c: &mut Criterion) {
        let data = load_test_binary();

        c.bench_function("extract_strings", |b| {
            b.iter(|| extract_strings(black_box(&data), &ExtractionConfig::default()))
        });
    }

    criterion_group!(benches, bench_string_extraction);
    criterion_main!(benches);
}

## Description
Brief description of the changes.

## Type of Change
- [ ] Bug fix
- [ ] New feature
- [ ] Breaking change
- [ ] Documentation update

## Testing
- [ ] Unit tests pass
- [ ] Integration tests pass
- [ ] Manual testing completed

## Checklist
- [ ] Code follows project style guidelines
- [ ] Self-review completed
- [ ] Documentation updated
- [ ] Tests added for new functionality