antifragile 0.0.1

Antifragile is a Rust library implementing concepts from Nassim Nicholas Taleb's antifragility theory. The library provides a trait-based system for analyzing how systems respond to stress and volatility, classifying them into three categories: Fragile (harmed by volatility), Robust (unaffected), and Antifragile (benefits from volatility)
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187

# Contributing to antifragile

Thank you for your interest in contributing to antifragile!
This document provides guidelines and instructions for contributing.

- [Contributing to antifragile](#contributing-to-antifragile)
  - [Development Setup](#development-setup)
  - [Building and Testing](#building-and-testing)
    - [Run all tests](#run-all-tests)
    - [Run specific test suites](#run-specific-test-suites)
    - [Check code formatting](#check-code-formatting)
    - [Run linter](#run-linter)
    - [Build documentation](#build-documentation)
  - [Making Changes](#making-changes)
    - [Code Style](#code-style)
    - [Testing](#testing)
    - [Documentation](#documentation)
  - [Pull Request Process](#pull-request-process)
    - [PR Requirements](#pr-requirements)
  - [Feature Flags](#feature-flags)
  - [Commit Message Format](#commit-message-format)
  - [Release Process](#release-process)
  - [Getting Help](#getting-help)
  - [Code of Conduct](#code-of-conduct)
  - [License](#license)

## Development Setup

**Note:** This project uses Rust edition 2024.

1. Clone the repository:
```bash
git clone https://github.com/minikin/antifragile.git
cd antifragile
   ```
2. Install development dependencies:
   ```bash
   rustup component add rustfmt clippy
   ```

## Building and Testing

### Run all tests
```bash
cargo test --all-features
```

### Run specific test suites
```bash
# Run only integration tests
cargo test --tests --all-features

# Run only unit tests
cargo test --lib

# Run a specific test file
cargo test --test basic_tests
```

### Check code formatting
```bash
cargo fmt --all -- --check
```

### Run linter
```bash
cargo clippy --all-targets --all-features -- -D warnings
```

### Build documentation
```bash
cargo doc --all-features --no-deps --open
```

## Making Changes

### Code Style

- Follow Rust's official [style guidelines](https://doc.rust-lang.org/1.0.0/style/)
- Run `cargo fmt` before committing
- Ensure `cargo clippy` produces no warnings
- Write clear, descriptive commit messages

### Testing

- Add tests for all new functionality
- Ensure all existing tests pass
- Integration tests go in the `tests/` directory
- Unit tests go in the same file as the code they test

### Documentation

- Document all public APIs with doc comments
- Include examples in doc comments where appropriate
- Update README.md if adding major features

## Pull Request Process

1. Fork the repository
2. Create a feature branch (`git checkout -b feature/amazing-feature`)
3. Make your changes
4. Add tests for your changes
5. Run the full test suite: `cargo test --all-features`
6. Run formatting and linting:
   ```bash
   cargo fmt --all
   cargo clippy --all-targets --all-features -- -D warnings
   ```
7. Commit your changes with a descriptive message
8. Push to your fork
9. Open a Pull Request against the `main` branch

### PR Requirements

- All CI checks must pass
- Code must be formatted with `rustfmt`
- No `clippy` warnings
- All tests must pass on Linux, macOS, and Windows
- Code coverage should not decrease
- Documentation is updated if needed

## Feature Flags

The project uses feature flags for optional functionality:

- `serde`: Serialization/deserialization support

When adding new features:
- Make them optional via feature flags when appropriate
- Test with and without the feature enabled
- Document the feature in README.md

## Commit Message Format

Use conventional commits format:

```
type(scope): subject

body

footer
```

Types:
- `feat`: New feature
- `fix`: Bug fix
- `docs`: Documentation changes
- `test`: Adding or updating tests
- `refactor`: Code refactoring
- `perf`: Performance improvements
- `chore`: Maintenance tasks

Examples:
```
feat(core): add new is_nullish method
fix(serde): correct deserialization of absent fields
docs(readme): update usage examples
test(conversion): add tests for from_nullable
```

## Release Process

Releases are managed by maintainers:

1. Update version in `Cargo.toml`
2. Update CHANGELOG.md
3. Create a git tag: `git tag -a v0.x.y -m "Release v0.x.y"`
4. Push tag: `git push origin v0.x.y`
5. GitHub Actions will automatically publish to crates.io

## Getting Help

- **Found a bug or have a feature request?** Please submit a Pull Request directly.
The Issues tab is not available on this repository as we don't have the capacity to manage incoming issues at this time.
- For questions or ideas, feel free to open a PR with your proposed changes or improvements.

## Code of Conduct

- Be respectful and inclusive
- Provide constructive feedback
- Focus on the code, not the person
- Help create a welcoming environment for all contributors

## License

This project is licensed under the MIT License - see the LICENSE file for details.