main.rs

use std::collections::HashMap;
mod ares;

fn main() {
    
    let mut content = HashMap::new();
    content.insert(
        "title",
        "index page",
    );
    content.insert(
        "data1",
        "10000",
    );

    let _ = ares::Router::new("index", Some(content));
    
}

### フレームワーク側
ares.rs

use std::fs;
use std::io;
use std::io::prelude::*;
use std::net::{TcpListener, TcpStream};
use std::collections::HashMap;

pub struct Router;

impl Router {
    pub fn new(path: &str, content: Option<HashMap<&str, &str>>) {

        let mut routes = HashMap::new();
        let temp_path = format!("./templates/{}.html", path);
        let mut html = fs::read_to_string(temp_path).unwrap();

        match content {
            Some(data) => {
                for (key, value) in data {
                    let k = format!("{{{{ {} }}}}", key);
                    html = html.replace(&k, value);
                }
            },
            None => {},
        }
        let route_path = format!("/{}", path);
        routes.insert(
            route_path, html,
        );
        println!("{:?}", routes);


        let listenr = TcpListener::bind("192.168.33.10:8000").unwrap();
        for stream in listenr.incoming() {
            match stream {
                Ok(stream) => {
                    let _ = handle_connection(stream, routes.clone());
                }
                Err(e) => {
                    println!("Connection failed: {}", e);
                }
            }
        }
    }
}

fn handle_connection(mut stream: TcpStream, routes: HashMap<String, String>)  {
    let mut buffer = [0; 1024];
    stream.read(&mut buffer).unwrap();
 
    let request = String::from_utf8_lossy(&buffer);
    let request_line = request.lines().next().unwrap_or("");
    println!("Received request:\n{}", request);
 
    let path = request_line
         .split_whitespace()
         .nth(1)
         .unwrap_or("/");
    
    let response_body = routes.get(path)
         .cloned()
         .unwrap_or_else(|| "<h1>404 Not Found</h1>".to_string());
 
    let response = http_response(200, "text/html", &response_body);
 
    stream.write_all(response.as_bytes()).unwrap();
    stream.flush().unwrap();
 }
 
 fn http_response(status_code: u16, content_type: &str, body: &str) -> String {
    format!(
        "HTTP/1.1 {} {}\r\nContent-Type: {}\r\nContent-Length: {}\r\n\r\n{}",
        status_code,
        get_status_text(status_code),
        content_type,
        body.len(),
        body
    )
 }
 
 fn get_status_text(code: u16) -> &'static str {
    match code {
        200 => "OK",
        404 => "Not Found",
        _ => "Unknown",
    }
 }

複数パスに対応できるようにしたい。

### 複数パスに対応
hashmapにパスとコンテンツを追加するように実装する

use std::collections::HashMap;
mod ares;

fn main() {
    let mut router = ares::Router::new();

    let mut content1 = HashMap::new();
    content1.insert(
        "title",
        "index page",
    );

    let mut content2 = HashMap::new();
    content2.insert(
        "title",
        "this is title",
    );

    router.add("index", Some(content1));
    router.add("hello", None);
    router.add("world", Some(content2));

    router.up("192.168.33.10:8000");   
}

pub struct Router {
    route: HashMap<String, String>,
}

impl Router {

    pub fn new() -> Self {
        Router {
            route: HashMap::new(),
        }
    }

    pub fn add(&mut self, path: &str, content: Option<HashMap<&str, &str>>){
        let temp_path = format!("./templates/{}.html", path);
        let mut html = fs::read_to_string(temp_path).unwrap();

        match content {
            Some(data) => {
                for (key, value) in data {
                    let k = format!("{{{{ {} }}}}", key);
                    html = html.replace(&k, value);
                }
            },
            None => {},
        }
        let route_path = format!("/{}", path);
        self.route.insert(route_path, html);
    }

    pub fn up(&self, ip: &str) {
        let listenr = TcpListener::bind(ip).unwrap();
        for stream in listenr.incoming() {
            match stream {
                Ok(stream) => {
                    let _ = handle_connection(stream, self.route.clone());
                }
                Err(e) => {
                    println!("Connection failed: {}", e);
                }
            }
        }
    }
}

MVCモデルにしたい…

templatesというディレクトリに、ルート名と同じファイル名でhtmlファイルを作成するというルールにする。

fn main() {

   let address = "192.168.33.10:8000";

   let mut routes = HashMap::new();

   let mut paths: Vec<&str> = Vec::new();
   paths.push("index");
   paths.push("hello");

   for path in paths {
        let temp_path = format!("./templates/{}.html", path);
        let content = fs::read_to_string(temp_path).unwrap();

        let route_path = format!("/{}", path);
        routes.insert(
            route_path, content,
        );
   }
   println!("{:?}", routes);
}

{“/index”: “

Hello from Rust!

“, “/hello”: “

Welcome to the Rust server!

“}

teraの場合は、tera.renderとして、任意のファイル名を指定できるようにしている。これも、hashmapで、ルート名とファイル名をkey, valueで持っていれば、問題なくできそうでる。

### テンプレートエンジンの変数の扱い
hashmapでkeyとvalueを格納して、htmlの{{ @name }} とkeyが一致したものをvalueに変換すればできそうである。。

let mut context = tera::Context::new();
context.insert("title", "Index page");

{{title}}

### Rustで{{ }}を置換するように実装

    let mut content = HashMap::new();
    content.insert(
        "title",
        "index page",
    );
    let mut data = HashMap::new();
    for (key, value) in content {
        let k = format!("{{{{ {} }}}}", key);
        data.insert(
            k, value,
        );
    };
    println!("{:?}", data);

    let mut str = "<h1>Welcome to the {{ title }} server!</h1>";

    for (key, value) in data {
        let s = &str.replace(&key, value);
        println!("{}", s);
    };

### テンプレートに引き渡す変数がある時
pathにhashmapで変数のセットを紐づけて、後で置換するようにする。

let mut content = HashMap::new();
    content.insert(
        "title",
        "index page",
    );
    let mut data = HashMap::new();
    for (key, value) in content {
        let k = format!("{{{{ {} }}}}", key);
        data.insert(
            k, value,
        );
    };

    let mut str = "<h1>Welcome to the {{ title }} server!</h1>";
    
    let mut paths: Vec<(&str, Option<HashMap<String, &str>>)> = Vec::new();
    paths.push(("index", Some(data)));
    paths.push(("hello", None));

    println!("{:?}", paths);

Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.33s
Running `target/debug/ares`
[(“index”, Some({“{{ title }}”: “index page”})), (“hello”, None)]

### 全部繋げる

let mut paths: Vec<(&str, Option<HashMap<String, &str>>)> = Vec::new();

    let mut content = HashMap::new();
    content.insert(
        "title",
        "index page",
    );
    content.insert(
        "data1",
        "10000",
    );
    let mut data = HashMap::new();
    for (key, value) in content {
        let k = format!("{{{{ {} }}}}", key);
        data.insert(
            k, value,
        );
    };

    paths.push(("index", Some(data)));
    paths.push(("hello", None));

    let mut routes = HashMap::new();

    for (path, v) in paths {
        let temp_path = format!("./templates/{}.html", path);
        let mut content = fs::read_to_string(temp_path).unwrap();
        match v {
            Some(data) => 
                for (key, value) in data {
                    content = content.replace(&key, value);
                },
            None => {},
        }
        let route_path = format!("/{}", path);
        routes.insert(
            route_path, content,
        );
    };
    println!("{:?}", routes);

{“/index”: “

Hello from Rust! title:index page

“, “/hello”: “

Welcome to the Rust server!

“}