sandy

Crates.iosandy
lib.rssandy
version0.2.7
sourcesrc
created_at2024-01-08 00:32:05.981827
updated_at2024-01-09 17:08:05.212251
descriptionA simple HTTP server and template rendering engine in Rust.
homepage
repositoryhttps://github.com/IceBytes/sandy
max_upload_size
id1092115
size23,798
(ArabShadows)

documentation

README

Sandy

Sandy is a Rust library that provides a simple HTTP server and a template rendering engine. It allows easy creation of HTTP servers and handling of different routes while enabling template rendering for web applications.

Table of Contents

Server Usage

You can create a new HTTP server using the Server::new() function:

use sandy::Server;

let mut server = Server::new();

You can run the HTTP server using the Server.run() function:

let ip = "127.0.0.1";
let port = "8080";
server.run(ip, port);

Routing with Slugs

To handle different routes, including slugs, use the route() method. You can define routes with slugs and their corresponding handler functions.

For instance, to handle a route with a slug:

server.route("/articles/:slug", |path, params, method, data| {
    if method == "GET" {
        let slug = params.get("slug").map_or_else(|| "".to_string(), |x| x.to_string());
        Ok(format!("HTTP/1.1 200 OK\n\nArticle content for slug: {}", slug))
    } else {
        Err("HTTP/1.1 405 METHOD NOT ALLOWED\n\nMethod Not Allowed".to_string())
    }
});

server.route("/articles", |path, params, method, data| {
    if method == "GET" {
        Ok(format!("HTTP/1.1 200 OK\n\nArticle content : Article1, ...."))
    } else {
        Err("HTTP/1.1 405 METHOD NOT ALLOWED\n\nMethod Not Allowed".to_string())
    }
});

Handling Different HTTP Request Types

GET Request

To handle a GET request, you can use slugs within the route:

server.route("/get/:param", |_, params, method, _| {
    if method == "GET" {
        let v = params.get("param").map_or_else(|| "".to_string(), |x| x.to_string());
        Ok(format!("HTTP/1.1 200 OK\n\n{}", v))
    } else {
        Err("HTTP/1.1 405 METHOD NOT ALLOWED\n\nMethod Not Allowed".to_string())
    }
});

POST Request

To handle a POST request, slugs can be used similarly:

server.route("/post/:data", |_, _, method, data| {
    if method == "POST" {
        let v = data.get("data").map_or_else(|| "".to_string(), |x| x.to_string());
        Ok(format!("HTTP/1.1 200 OK\n\n{}", v))
    } else {
        Err("HTTP/1.1 405 METHOD NOT ALLOWED\n\nMethod Not Allowed".to_string())
    }
});

Template Engine Usage

You can render templates using the TemplateEngine::render_template() function:

use sandy::TemplateEngine;
use std::collections::HashMap;

let mut context = HashMap::new();
context.insert("name", "Just Ice");

let rendered = TemplateEngine::render_template("template.html", &context);

The TemplateEngine::render() function renders templates from strings using a context:

let template = "<p>Hello, {{ name }}!</p>";
let rendered = TemplateEngine::render(template, &context);

Sitemap

To add a custom dynamic route to sitemap

The Server also supports generating and updating a sitemap for SEO purposes. You can add routes to the sitemap using add_route_to_sitemap():

let ip = "127.0.0.1";
let port = "8080";
server.add_route_to_sitemap("/about", true, "daily", 0.5, &format!("http://{}:{}", ip, port));

To add all static routes to sitemap

The Server also supports generating and updating a sitemap for SEO purposes. You can add routes to the sitemap using generate_sitemap():

server.add_route_to_sitemap("/", true, "daily", 0.8, "https://example.com");
server.add_route_to_sitemap("/about", true, "monthly", 0.5, "https://example.com");

server.generate_sitemap(true, true, "daily", 0.7, "https://example.com");

Static Routes

You can serve static content by defining static routes. For example, serving a static HTML file:

server.static_route("/", "<html><body><h1>Welcome to Sandy!</h1></body></html>");

Full Example

An example showcasing the use of slugs in routing:

use sandy::Server;
use sandy::TemplateEngine;
use std::collections::HashMap;

fn main() {
    let mut server = Server::new();

    server.route("/", |_, _, _, _| {
        Ok("HTTP/1.1 200 OK\n\nHello, Sandy!".to_string())
    });

    server.route("/get/:param", |_, params, method, _| {
        if method == "GET" {
            let v = params.get("param").map_or_else(|| "".to_string(), |x| x.to_string());
            Ok(format!("HTTP/1.1 200 OK\n\n{}", v))
        } else {
            Err("HTTP/1.1 405 METHOD NOT ALLOWED\n\nMethod Not Allowed".to_string())
        }
    });

    server.route("/post/:data", |_, _, method, data| {
        if method == "POST" {
            let v = data.get("data").map_or_else(|| "".to_string(), |x| x.to_string());
            Ok(format!("HTTP/1.1 200 OK\n\n{}", v))
        } else {
            Err("HTTP/1.1 405 METHOD NOT ALLOWED\n\nMethod Not Allowed".to_string())
        }
    });

    server.route("/render_template/:var", |_, _, _, _| {
        let context: HashMap<_, _> = [("var", "value")].iter().cloned().collect();
        match TemplateEngine::render_template("template.html", &context) {
            Ok(rendered) => Ok(format!("HTTP/1.1 200 OK\n\n{}", rendered)),
            Err(err) => Err(format!("HTTP/1.1 500 Internal Server Error\n\n{}", err)),
        }
    });

    server.route("/render/:var", |_, _, _, _| {
        let context: HashMap<_, _> = [("var", "value")].iter().cloned().collect();
        let template = "This is a {{ var }} template.";
        let rendered = TemplateEngine::render(template, &context);
        Ok(format!("HTTP/1.1 200 OK\n\n{}", rendered))
    });

    server.static_route("/", "<html><body><h1>Welcome to Sandy!</h1></body></html>");

    server.static_route("/about", "<html><body><h1>About Us</h1><p>This is the About Us page.</p></body></html>");

    server.run("0.0.0.0", "8080");
}
Commit count: 0

cargo fmt