Roa-body

An extension crate for roa. This module provides a context extension PowerBody.

Read/write body in a easier way.

The roa_core provides several methods to read/write body.

```rust use roacore::{Context, Result}; use futures::AsyncReadExt; use futures::io::BufReader; use asyncstd::fs::File;

async fn get(mut ctx: Context<()>) -> Result { // roacore::Body implements futures::AsyncRead. let mut data = String::new(); ctx.reqmut().body().readtostring(&mut data).await?; println!("data: {}", data);

ctx.resp_mut()
   // write object implementing futures::AsyncRead
   .write(File::open("assets/author.txt").await?)
   // write `impl ToString`
   .write_str("I am Roa.")
   // write `impl Into<Vec<u8>>`
   .write_bytes(b"Hey Roa.".as_ref());
Ok(())

} ```

These methods are useful, but they do not deal with headers, especially Content-* headers.

The PowerBody provides more powerful methods to handle it.

```rust use roacore::{Context, Result}; use roabody::{PowerBody, DispositionType::*}; use serde::{Serialize, Deserialize}; use askama::Template; use async_std::fs::File; use futures::io::BufReader;

[derive(Debug, Serialize, Deserialize, Template)]

[template(path = "user.html")]

struct User { id: u64, name: String, }

async fn get(mut ctx: Context<()>) -> Result { // deserialize as json. let mut user: User = ctx.read_json().await?;

// deserialize as x-form-urlencoded.
user = ctx.read_form().await?;

// serialize object and write it to body,
// set "Content-Type"
ctx.write_json(&user)?;

// open file and write it to body,
// set "Content-Type" and "Content-Disposition"
ctx.write_file("assets/welcome.html", Inline).await?;

// write text,
// set "Content-Type"
ctx.write_text("Hello, World!")?;

// write object implementing AsyncRead,
// set "Content-Type"
ctx.write_octet(File::open("assets/author.txt").await?)?;

// render html template, based on [askama](https://github.com/djc/askama).
// set "Content-Type"
ctx.render(&user)?;
Ok(())

} ```