Documentation Site on GitHub Pages (#2376)

* Add initial documentations

* Update documentation for Basic Client and add WebSocket section

* feat: add a static site generator with multi-language support

- Introduced a new Rust-based static site generator in the `docs-gen` directory.
- Implemented core functionality for building sites from markdown files, including:
  - Configuration loading from `config.toml`.
  - Markdown rendering with frontmatter support.
  - Navigation generation based on page structure.
  - Static file copying and output directory management.
- Added templates for base layout, pages, and portal.
- Created a CSS file for styling and a JavaScript file for interactive features like language selection and theme toggling.
- Updated documentation source with new configuration and example pages in English and Japanese.
- Added a `justfile` target for building the documentation site.

* Add language/theme toggle functionality

- Created a new Japanese tour index page at docs/ja/tour/index.html
- Implemented navigation links for various sections of the cpp-httplib tutorial
- Added a language selector to switch between English and Japanese
- Introduced theme toggle functionality to switch between light and dark modes
- Added mobile sidebar toggle for better navigation on smaller screens

docs-gen/src/markdown.rs

@@ -0,0 +1,140 @@
+use anyhow::{Context, Result};
+use pulldown_cmark::{CodeBlockKind, Event, Options, Parser, Tag, TagEnd};
+use serde::Deserialize;
+use syntect::highlighting::ThemeSet;
+use syntect::html::highlighted_html_for_string;
+use syntect::parsing::SyntaxSet;
+
+#[derive(Debug, Deserialize)]
+pub struct Frontmatter {
+    pub title: String,
+    #[serde(default)]
+    pub order: i32,
+    pub status: Option<String>,
+}
+
+pub struct MarkdownRenderer {
+    syntax_set: SyntaxSet,
+    theme_set: ThemeSet,
+    theme_name: String,
+    theme_light_name: Option<String>,
+}
+
+impl MarkdownRenderer {
+    pub fn new(theme_name: &str, theme_light_name: Option<&str>) -> Self {
+        Self {
+            syntax_set: SyntaxSet::load_defaults_newlines(),
+            theme_set: ThemeSet::load_defaults(),
+            theme_name: theme_name.to_string(),
+            theme_light_name: theme_light_name.map(|s| s.to_string()),
+        }
+    }
+
+    pub fn parse_frontmatter(content: &str) -> Result<(Frontmatter, &str)> {
+        let content = content.trim_start();
+        if !content.starts_with("---") {
+            anyhow::bail!("Missing frontmatter delimiter");
+        }
+        let after_first = &content[3..];
+        let end = after_first
+            .find("\n---")
+            .context("Missing closing frontmatter delimiter")?;
+        let yaml = &after_first[..end];
+        let body = &after_first[end + 4..];
+        let fm: Frontmatter =
+            serde_yml::from_str(yaml).context("Failed to parse frontmatter YAML")?;
+        Ok((fm, body))
+    }
+
+    pub fn render(&self, markdown: &str) -> String {
+        let options = Options::ENABLE_TABLES
+            | Options::ENABLE_STRIKETHROUGH
+            | Options::ENABLE_TASKLISTS;
+
+        let parser = Parser::new_ext(markdown, options);
+
+        let mut in_code_block = false;
+        let mut code_lang = String::new();
+        let mut code_buf = String::new();
+        let mut events: Vec<Event> = Vec::new();
+
+        for event in parser {
+            match event {
+                Event::Start(Tag::CodeBlock(kind)) => {
+                    in_code_block = true;
+                    code_buf.clear();
+                    code_lang = match kind {
+                        CodeBlockKind::Fenced(lang) => lang.to_string(),
+                        CodeBlockKind::Indented => String::new(),
+                    };
+                }
+                Event::End(TagEnd::CodeBlock) => {
+                    in_code_block = false;
+                    let html = self.highlight_code(&code_buf, &code_lang);
+                    events.push(Event::Html(html.into()));
+                }
+                Event::Text(text) if in_code_block => {
+                    code_buf.push_str(&text);
+                }
+                other => events.push(other),
+            }
+        }
+
+        let mut html_output = String::new();
+        pulldown_cmark::html::push_html(&mut html_output, events.into_iter());
+        html_output
+    }
+
+    fn highlight_code(&self, code: &str, lang: &str) -> String {
+        if lang.is_empty() {
+            return format!("<pre><code>{}</code></pre>", escape_html(code));
+        }
+
+        let syntax = self
+            .syntax_set
+            .find_syntax_by_token(lang)
+            .unwrap_or_else(|| self.syntax_set.find_syntax_plain_text());
+
+        let dark_html = self.highlight_with_theme(code, syntax, &self.theme_name);
+
+        if let Some(ref light_name) = self.theme_light_name {
+            let light_html = self.highlight_with_theme(code, syntax, light_name);
+            format!(
+                "<div class=\"code-dark\">{}</div><div class=\"code-light\">{}</div>",
+                dark_html, light_html
+            )
+        } else {
+            dark_html
+        }
+    }
+
+    fn highlight_with_theme(
+        &self,
+        code: &str,
+        syntax: &syntect::parsing::SyntaxReference,
+        theme_name: &str,
+    ) -> String {
+        let theme = self
+            .theme_set
+            .themes
+            .get(theme_name)
+            .unwrap_or_else(|| {
+                self.theme_set
+                    .themes
+                    .values()
+                    .next()
+                    .expect("No themes available")
+            });
+
+        match highlighted_html_for_string(code, &self.syntax_set, syntax, theme) {
+            Ok(html) => html,
+            Err(_) => format!("<pre><code>{}</code></pre>", escape_html(code)),
+        }
+    }
+}
+
+fn escape_html(s: &str) -> String {
+    s.replace('&', "&amp;")
+        .replace('<', "&lt;")
+        .replace('>', "&gt;")
+}