rambl_rs 0.1.10

#![allow(unused_imports)]

//! A rust Web Framework for prototyping and small scale applications
//! 
//! ## Simple Hello World HTTP server
//! 
//! ```
//! use rambl_rs::{Context, HttpResponse, HttpServer, RequestType::Get, Responder};
//!
//! async fn index(res: Responder, _ctx: Context) {
//!     res.respond("<h1>Hello World</h1>").await.unwrap();
//! }
//!
//! #[tokio::main]
//! async fn main() {
//!     let server = HttpServer::new();
//!
//!     server.on(Get, "/", index);
//!
//!     server.listen("127.0.0.1:8000").await.unwrap();
//! }
//! ```
//! 
//! This shows that some applications don't need alot of code, so we go for minimun boilerplate.
//! 
//! ## Connection Counter
//! 
//! ```
//! use rambl_rs::{Context, HttpServer, RequestType::Get, Responder};
//!
//! async fn index(res: Responder, ctx: Context<i32>) {
//!     let mut guard = ctx.state.lock().await;
//!     let counter = guard.as_mut().unwrap();
//!
//!     *counter += 1;
//!
//!    res.respond(
//!         &format!("<h1>You are the {counter} person to view this content</h1>")
//!    ).await.unwrap();
//! }
//!
//! #[tokio::main]
//! async fn main() {
//!     let server = HttpServer::new();
//!
//!     server.manage(0);
//!     server.on(Get, "/", index);
//!
//!     server.listen("127.0.0.1:8000").await.unwrap();
//! }
//! ```
//! 
//! ## Real-Time application
//! 
//! this is where rambl_rs shines.
//! 
//! ```
//! use rambl_rs::RequestType::Post;
//! use rambl_rs::{Context, HttpServer, RequestType::Get, Responder};
//! use rambl_rs::{prelude::*, tokio, SSEResponse};
//! use tokio::sync::broadcast::{channel, Sender};
//! use std::sync::Arc;
//!
//! async fn messages(res: Responder, ctx: Context<Arc<Sender<String>>>) {
//!     let mut rx = Arc::clone(&ctx.state.unwrap_ref()).subscribe();
//!     let mut sse_res = SSEResponse::new();
//!
//!     while let Ok(message) = rx.recv().await {
//!         sse_res.body(message);
//!         res.respond(&sse_res).await.unwrap();
//!     }
//! }
//!
//! async fn send(res: Responder, ctx: Context<Arc<Sender<String>>>) {
//!     let tx = Arc::clone(&ctx.state.unwrap_ref());
//!     let message = ctx.request.body;
//!
//!     res.respond("").await.unwrap();
//!     let _ = tx.send(message);
//! }
//!
//! #[tokio::main]
//! async fn main() {
//!     let server = HttpServer::new();
//!     let (tx, _) = channel(1);
//!
//!     server.manage(Arc::new(tx));
//!     server.on(Get, "/messages", messages);
//!     server.on(Post, "/send", send);
//!
//!     server.listen("127.0.0.1:8000").await.unwrap();
//! }
//! ```

mod http_server;
mod io;
mod handler;
pub mod prelude;

pub use http_server::*;
pub use io::*;
pub use handler::*;
pub use tokio;