vial 0.0.10

a micro micro-framework
Documentation

~ vial: a micro micro-framework ~

Vial is a small web "framework" for making small web sites.

It only includes a few basics:

  • Parsing and routing HTTP requests
  • Handling POST requests
  • Serving static files (css, js)

Everything else... well, that's up to you.

The goal is an as-few-as-possible-dependencies web library you can use to test out an idea quickly or get a personal project rolling. Single file, server side apps? You bet! Fast compilation? Yes please! À la carte dependencies? Now you're talkin'!

It's sort of like a picnic where the playlist is all 90s music and you have to bring your own beverages. And food.

Status: Vial is currently in early development. It is being developed alongside deadwiki, but that is strictly for personal use. Proceed with caution.

To get started, just add vial to your Cargo.toml:

[dependencies]
vial = "*"

~ hello world ~

As is tradition:

vial::routes! {
    GET "/" => |_| "Hello, world!";
}

fn main() {
    vial::run!().unwrap();
}

For a bit more sanity, you can route to functions directly:

use vial::prelude::*;

routes! {
    GET "/echo" => echo;
    POST "/echo" => post;
}

fn echo(_: Request) -> &'static str {
    "<form method='POST'>
        <input type='text' name='echo'/>
        <input type='submit'/>
    </form>"
}

fn post(req: Request) -> String {
    format!(
        "<h1>{}</h1>",
        req.form("echo").unwrap_or("You didn't say anything!")
    )
}

fn main() {
    vial::run!().unwrap();
}

To really break the mold, you can split your site into different modules:

use vial;

mod wiki;
mod blog;

mod index {
    use vial::prelude::*;
    routes! {
        GET "/" => |_| Response::from_file("index.html")
    }
}

fn main() {
    // The order matters here - if `wiki` and `blog` both define "/",
    // the `mod index` version will match first and get run.
    vial::run!(index, wiki, blog);
}

But hey, who wants to putz around with HTML when you can be writing Rust? Enable the horror feature and you're on your way:

use vial::prelude::*;

routes! {
    GET "/" => |_| html! {
        p {
            : "You're looking for this: ";
            a(href="/echo") { : "echo" }
        }
    };
    GET "/echo" => echo;
    POST "/echo" => post;
}

fn echo(_: Request) -> impl Responder {
    html! {
        form(method="POST") {
            p {
            : "Type something: ";
                input(type="text", name="echo");
                input(type="submit");
            }
        }
    }
}

fn post(req: Request) -> impl Responder {
    owned_html! {
        h1: req.form("echo")
            .unwrap_or("You didn't say anything!");
    }
}

fn main() {
    vial::run!().unwrap();
}

~ hot reloading ~

Install cargo-watch:

$ cargo install cargo-watch
$ cargo watch -x 'run --example hello_world'

~ bonus features ~

vial doesn't come with JSON or a template engine or any of that fancy stuff by default, but there are a few compile-time --features you can activate for enhanced productivity:

  • state: Global State
  • horror: Small & fast macro-based HTML builder, via horrowshow.
  • cookies: Cookie monster!
  • sessions: Session support
  • multipart: Multipart form data (file uploads)
  • log: Access logging
  • json: to_json and from_json powers, via Serde.

Please note: The list above is a work-in-progress.

~ T0D0 ~

  • tests
  • before_filter

~ testing ~

Tests can be found in tests/main.rs. You can run them on a recent version of stable Rust with make test.

~ license ~

Vial is licensed under either of the following, at your option: