Prototype web server

Author: thirdtruck

src/bin/server.rs

@@ -0,0 +1,217 @@
+#[macro_use] extern crate rocket;
+
+use rocket::fs::{FileServer, relative};
+use rocket::State;
+use rocket_dyn_templates::{Template};
+use serde::Serialize;
+
+use fennec::prelude::*;
+
+#[derive(Clone, Serialize)]
+struct AppContext<'a> {
+    title: &'a str,
+    appname: &'a str,
+}
+
+#[derive(Clone, Serialize)]
+struct DefinitionsContext<'a> {
+    app: AppContext<'a>,
+    entries: Vec<DictionaryEntry>,
+}
+
+#[derive(Clone, Serialize)]
+struct SnippetsContext<'a> {
+    app: AppContext<'a>,
+    snippets: Vec<SnippetRow>,
+}
+
+#[derive(Clone, Serialize)]
+struct RootContext<'a> {
+    app: AppContext<'a>,
+    dictionary: Dictionary,
+    notebook: Notebook,
+}
+
+#[derive(Clone, Serialize)]
+struct SnippetRow {
+    source: String,
+    description: String,
+    transcribed: bool,
+    notes: Vec<Note>,
+    words: Vec<WordRow>,
+}
+
+#[derive(Clone, Serialize)]
+struct WordRow {
+    word_type: String,
+    is_tunic: bool,
+    is_english: bool,
+    has_definition: bool,
+    text: String,
+    glyphs: Vec<Glyph>,
+    has_border: bool,
+    colored: bool,
+}
+
+#[derive(Clone, Serialize)]
+struct DictionaryEntry {
+    glyphs: Vec<Glyph>,
+    definition: String,
+    notes: Vec<String>,
+}
+
+#[get("/")]
+fn index(state: &State<RootContext>) -> Template {
+    Template::render("index", state.app.clone())
+}
+
+#[get("/snippets")]
+fn snippets(state: &State<RootContext>) -> Template {
+    let snippets: Vec<SnippetRow> = state
+        .notebook
+        .snippets
+        .iter()
+        .map(|snip| {
+            let source = match &snip.source {
+                Some(Source::ManualPageNumber(page_number)) => format!("/media/manual_pages/page{:0>2}.jpg", page_number),
+                Some(Source::ScreenshotFilename(file)) => format!("/media/screenshots/{file}"),
+                Some(Source::Other(_)) => "/media/404".to_owned(),
+                None => "/media/404".to_owned(),
+            };
+
+            let description = snip.description.clone();
+
+            let transcribed = snip.transcribed;
+
+            let notes = snip.notes.clone();
+
+            let words: Vec<WordRow> = snip
+                .words
+                .iter()
+                .map(|word| {
+                    match &word.word_type {
+                        WordType::English(english_word) => WordRow {
+                            word_type: "English".to_owned(),
+                            is_tunic: false,
+                            is_english: true,
+                            has_definition: true,
+                            text: english_word.text(),
+                            glyphs: vec![],
+                            has_border: false,
+                            colored: false,
+                        },
+                        WordType::Tunic(tunic_word) => {
+                            let (has_definition, definition) = state
+                                .dictionary
+                                .get(&tunic_word.into())
+                                .map(|entry| {
+                                    let definition = match entry.definition() {
+                                        Definition::Undefined => "[Undefined]".to_owned(),
+                                        Definition::Tentative(text) => text.clone(),
+                                        Definition::Confirmed(text) => text.clone(),
+                                    };
+
+                                    (true, definition)
+                                })
+                                .unwrap_or((false, "".to_owned()));
+
+                            WordRow {
+                                word_type: "Tunic".to_owned(),
+                                is_tunic: true,
+                                is_english: false,
+                                has_definition,
+                                text: definition,
+                                glyphs: tunic_word.glyphs(),
+                                has_border: tunic_word.has_border(),
+                                colored: tunic_word.colored(),
+                            }
+                        }
+                    }
+                })
+                .collect();
+
+            SnippetRow {
+                source,
+                description,
+                transcribed,
+                notes,
+                words,
+            }
+        })
+        .collect();
+
+    let context = SnippetsContext {
+        app: state.app.clone(),
+        snippets,
+    };
+
+    Template::render("snippets", context)
+}
+
+#[get("/definitions")]
+fn definitions(state: &State<RootContext>) -> Template {
+    let context = DefinitionsContext {
+        app: state.app.clone(),
+        entries: to_dictionary_entries(&state.dictionary),
+    };
+
+    Template::render("definitions", context)
+}
+
+fn to_dictionary_entries(dictionary: &Dictionary) -> Vec<DictionaryEntry> {
+     dictionary
+        .entries()
+        .iter()
+        .map(|(word, entry)| {
+            let glyphs = word.glyphs();
+            let definition =  match entry.definition() {
+                Definition::Undefined => "[Undefined]".to_owned(),
+                Definition::Tentative(text) => text.clone(),
+                Definition::Confirmed(text) => text.clone(),
+            };
+            let notes: Vec<String> = entry
+                .notes()
+                .iter()
+                .map(|n| n.into())
+                .collect();
+
+            DictionaryEntry {
+                glyphs,
+                definition,
+                notes,
+            }
+        })
+        .collect()
+}
+
+#[launch]
+fn rocket() -> _ {
+    let (notebook, _yaml) = notebook_from_yaml_file(DEFAULT_NOTEBOOK_FILE)
+        .unwrap_or_else(|error| {
+            println!("Unable to load notebook file: {}", DEFAULT_NOTEBOOK_FILE);
+            println!("{:?}", error);
+            panic!("Search aborted");
+        });
+
+    let (dictionary, _yaml) = dictionary_from_yaml_file(DEFAULT_DICTIONARY_FILE)
+        .unwrap_or_else(|error| {
+            println!("Unable to load dictionary file: {}", DEFAULT_NOTEBOOK_FILE);
+            println!("{:?}", error);
+            panic!("Search aborted");
+        });
+
+    let root_context = RootContext {
+        app: AppContext {
+            title: "Fennec",
+            appname: "Fennec",
+        },
+        notebook,
+        dictionary,
+    };
+
+    rocket::build()
+        .mount("/", routes![index, definitions, snippets])
+        .mount("/media", FileServer::from(relative!("sources")))
+        .manage(root_context)
+        .attach(Template::fairing())
+}

templates/definitions.html.hbs

@@ -0,0 +1,40 @@
+<!doctype html>
+
+<head>
+  <meta charset="utf-8">
+  <title>{{title}} - Definitions</title>
+</head>
+
+<body>
+
+<table>
+  <thead>
+    <tr>
+      <th>Word</th>
+      <th>Definition</th>
+      <th>Notes</th>
+    </tr>
+  </thead>
+  <tbody>
+    {{#each entries}}
+      <tr>
+        <td>
+          [{{#each this.glyphs}}{{this}} {{/each}}]
+        </td>
+        <td><b>{{this.definition}}<b></td>
+        <td>
+          <ul>
+            {{#each this.notes}}
+              <li>{{this}}</li>
+            {{/each}}
+          </ul>
+        </td>
+      </tr>
+    {{/each}}
+  </tbody>
+</table>
+
+</body>
+
+</html>
+

templates/index.html.hbs

@@ -0,0 +1,15 @@
+<!doctype html>
+
+<head>
+  <meta charset="utf-8">
+  <title>{{title}}</title>
+</head>
+
+<body>
+
+  <p>Welcome to {{appname}}!</p>
+
+</body>
+
+</html>
+

templates/snippets.html.hbs

@@ -0,0 +1,67 @@
+<!doctype html>
+
+<head>
+  <meta charset="utf-8">
+  <title>{{title}} - Snippets</title>
+</head>
+
+<body>
+
+<table>
+  <thead>
+    <tr>
+      <th>Source</th>
+      <th>Snippets</th>
+    </tr>
+  </thead>
+  <tbody>
+    {{#each snippets as |snippet|}}
+      <tr>
+        <td style="border: 1px solid grey; padding: 10px;">
+          <div><h3>{{snippet.description}}<h3></div>
+          <div>
+            <img height="400px" src="{{snippet.source}}" alt="{{snippet.source}}"/>
+          </div>
+          <div style="width: 400px">
+            {{#each snippet.words as |word|}}
+              <span>
+                {{#if word.is_english}}
+                  {{word.text}}
+                {{/if}}
+                {{#if word.is_tunic}}
+                  {{#if word.has_definition}}
+                    <span style="text-decoration: underline;" title="[{{#each word.glyphs as |glyph|}} {{glyph}} {{/each}}]">{{word.text}}</span>
+                  {{else}}
+                    <span style="background-color: #C9E5EA; margin-right: 5px;">
+                    [
+                    {{#each word.glyphs as |glyph|}}
+                      {{glyph}}
+                    {{/each}}
+                    ]
+                    </span>
+                  {{/if}}
+                {{/if}}
+              </span>
+            {{/each}}
+          </div>
+        </td>
+        <td>
+          <div><h3>Transcribed?</h3>{{snippet.transcribed}}</span></div>
+          <div>
+            <h3>Notes:</h3>
+            <ul>
+              {{#each snippet.notes as |note|}}
+                <li>{{note}}</li>
+              {{/each}}
+            </ul>
+          <div>
+        </td>
+      </tr>
+    {{/each}}
+  </tbody>
+</table>
+
+</body>
+
+</html>
+