## Project Overview

This crate is the core deboa HTTP client library, providing foundational HTTP request and response handling with support for modern async runtimes like Tokio and Smol.

## Installing

Add this to your `Cargo.toml`:

```toml
[dependencies]
deboa = "0.0.9"
```

## Usage

```rust
use deboa::{
    Deboa, Result, request::get
};
use deboa_extras::http::{self, serde::json::JsonBody};

#[derive(Debug, serde::Deserialize)]
pub struct Post {
    pub id: u64,
    pub title: String,
    pub body: String,
}

#[tokio::main]
async fn main() -> Result<()> {
    let mut client = Deboa::new();

    let posts: Vec<Post> = get("https://jsonplaceholder.typicode.com/posts")?
      .send_with(client)
      .await?
      .body_as(JsonBody)
      .await?;

    println!("posts: {:#?}", posts);

    Ok(())
}
```

## Available Features

The following features are available in `deboa`:

- `tokio`: Enable Tokio runtime support
- `smol`: Enable Smol runtime support

## Coding guidelines

- Follow Rust best practices and idioms
- Use descriptive variable and function names
- Write comprehensive documentation for public APIs
- Include examples in documentation where appropriate
- Maintain backward compatibility when possible

## Documentation instructions

- Keep documentation up to date with code changes
- Use clear and concise language
- Include code examples where appropriate

## Testing instructions

- Find the CI plan in the `.github/workflows` folder.
- From the crate root you can just call `cargo test`. The commit should pass all tests before you merge.

## PR instructions

- Title format: [<crate_name>] <Title>
- Always run `cargo fmt` and `cargo test` before committing.
- Keep changes focused and small.
- Include a brief description of the changes in the PR.
- Reference any related issues or discussions.
- Ensure all tests pass and code is properly formatted.
- Follow the existing code style and conventions.
- Add tests for new functionality when appropriate.
- Update documentation if needed.
- Keep commit messages clear and descriptive.
- Squash commits when appropriate for cleaner history.
- Request review from a maintainer before merging.
- Ensure CI checks pass before merging.
- Follow semantic versioning for releases.
