hashing 0.1.8

A robust, production-ready hashing library and CLI tool supporting multiple algorithms
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

# Contributing to Hashing

Thank you for your interest in contributing to the Hashing project! We welcome contributions from everyone.

## Getting Started

1. Fork the repository
2. Clone your fork:
   ```bash
   git clone https://github.com/YOUR_USERNAME/hashing
   cd hashing
   ```
3. Create a new branch:
   ```bash
   git checkout -b feature/your-feature-name
   ```

## Development Setup

### Prerequisites
- Rust 1.70 or later
- Cargo (comes with Rust)

### Building
```bash
cargo build
```

### Running Tests
```bash
# Run all tests
cargo test

# Run tests with output
cargo test -- --nocapture

# Run specific test
cargo test test_name
```

### Running Benchmarks
```bash
cargo bench
```

### Running Examples
```bash
cargo run --example basic
cargo run --example file_integrity
cargo run --example batch_processing
```

## Code Style

- Follow the official Rust style guide
- Use `rustfmt` to format code:
  ```bash
  cargo fmt
  ```
- Run `clippy` for linting:
  ```bash
  cargo clippy -- -D warnings
  ```

## Adding New Hash Algorithms

To add a new hash algorithm:

1. Add the dependency to `Cargo.toml`
2. Add the algorithm variant to the `Algorithm` enum in `src/lib.rs`
3. Implement the algorithm in `hash_bytes()` and `hash_file()` functions
4. Add the algorithm name to `Algorithm::name()` and `Algorithm::from_str()`
5. Add tests for the new algorithm
6. Update documentation

## Testing Guidelines

- Write tests for all new features
- Ensure all tests pass before submitting PR
- Add integration tests for new functionality
- Include edge cases in tests
- Test with various input sizes

## Documentation

- Add doc comments for all public APIs
- Include examples in doc comments
- Update README.md if needed
- Add entries to CHANGELOG.md

## Pull Request Process

1. Update documentation and tests
2. Ensure all tests pass
3. Run `cargo fmt` and `cargo clippy`
4. Update CHANGELOG.md with your changes
5. Submit pull request with clear description
6. Wait for review and address feedback

## Code Review

All submissions require review. We use GitHub pull requests for this purpose.

## Reporting Bugs

Please use GitHub Issues to report bugs. Include:
- Description of the bug
- Steps to reproduce
- Expected behavior
- Actual behavior
- System information (OS, Rust version)
- Relevant logs or error messages

## Feature Requests

We welcome feature requests! Please use GitHub Issues and include:
- Clear description of the feature
- Use cases and motivation
- Example usage (if applicable)

## Questions?

Feel free to open an issue for questions or reach out to the maintainer at cumulus13@gmail.com

## License

By contributing, you agree that your contributions will be licensed under the same license as the project (MIT OR Apache-2.0).