refactor: reorganize modules and split files

Author: QuadnucYard

cli/src/args.rs

@@ -0,0 +1,210 @@
+use core::fmt;
+use std::path::{Path, PathBuf};
+
+use clap::{Parser, Subcommand, ValueEnum};
+use reflexo_typst::error_once;
+
+use crate::{utils::make_absolute, version::VersionFormat};
+
+#[derive(Debug, Parser)]
+#[clap(name = "shiroa", version = "0.3.1-rc4")]
+pub struct Opts {
+    /// Print Version
+    #[arg(short = 'V', long, group = "version-dump")]
+    pub version: bool,
+
+    /// Print Version in format
+    #[arg(long = "VV", alias = "version-fmt", group = "version-dump", default_value_t = VersionFormat::None)]
+    pub vv: VersionFormat,
+
+    /// Print Verbose Log
+    #[arg(short = 'v', long, global = true)]
+    pub verbose: bool,
+
+    #[clap(subcommand)]
+    pub sub: Option<Subcommands>,
+}
+
+#[derive(Debug, Subcommand)]
+#[clap(
+    about = "The cli for shiroa.",
+    after_help = "",
+    next_display_order = None
+)]
+#[allow(clippy::large_enum_variant)]
+pub enum Subcommands {
+    #[clap(about = "init book.")]
+    Init(InitArgs),
+    #[clap(about = "build book.")]
+    Build(BuildArgs),
+    #[clap(about = "serve book.")]
+    Serve(ServeArgs),
+}
+
+/// Determine the approach to retrieving metadata of a book project.
+#[derive(ValueEnum, Debug, Clone, Copy, Eq, PartialEq, Default)]
+#[value(rename_all = "kebab-case")]
+pub enum MetaSource {
+    /// Strictly retrieve the project's meta by label queries.
+    /// - retrieve the book meta from `<shiroa-book-meta>`
+    /// - retrieve the build meta from `<shiroa-build-meta>`
+    Strict,
+    /// Infer the project's meta from the outline of main file.
+    /// Note: if the main file also contains `<shiroa-book-meta>` or
+    /// `<shiroa-build-meta>`, the manual-set meta will be used first.
+    #[default]
+    Outline,
+}
+
+impl fmt::Display for MetaSource {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(self.to_possible_value().unwrap().get_name())
+    }
+}
+
+#[derive(ValueEnum, Debug, Clone, Copy, Eq, PartialEq, Default)]
+#[value(rename_all = "kebab-case")]
+pub enum RenderMode {
+    /// Dynamically render as paged document.
+    #[default]
+    DynPaged,
+    /// Statically render html parts as much as possible, and leave frames
+    /// rendered dynamically.
+    StaticHtmlDynPaged,
+    /// Statically render the whole document, the embedded frames are not
+    /// resizable.
+    StaticHtml,
+}
+
+const ENV_PATH_SEP: char = if cfg!(windows) { ';' } else { ':' };
+
+#[derive(Default, Debug, Clone, Parser)]
+#[clap(next_help_heading = "Compile options")]
+pub struct CompileArgs {
+    /// The directory storing the `book.typ` file.
+    /// (Defaults to the current directory when omitted)
+    #[clap(default_value = "")]
+    pub dir: String,
+
+    /// Determine the approach to retrieving metadata of the book project.
+    #[clap(long, default_value = "strict")]
+    pub meta_source: MetaSource,
+
+    /// The mode to render typst document. The dynamically rendering means that
+    /// some elements will be rendered by a wasm module in the browser.
+    #[clap(long, default_value = "dyn-paged")]
+    pub mode: RenderMode,
+
+    /// Deprecated: use `--root` instead.
+    ///
+    /// Root directory for the typst workspace, which is same as the
+    /// `typst-cli`'s `--root` flag. (Defaults to the root directory for the
+    /// book when omitted)
+    #[clap(long, short, default_value = "")]
+    pub workspace: String,
+
+    /// Configure the project root (for absolute paths in typst source files).
+    #[clap(long = "root", value_name = "DIR")]
+    pub root: Option<String>,
+
+    /// Add additional directories that are recursively searched for fonts.
+    ///
+    /// If multiple paths are specified, they are separated by the system's path
+    /// separator (`:` on Unix-like systems and `;` on Windows).
+    #[clap(
+        long = "font-path",
+        value_name = "DIR",
+        action = clap::ArgAction::Append,
+        env = "TYPST_FONT_PATHS",
+        value_delimiter = ENV_PATH_SEP
+    )]
+    pub font_paths: Vec<PathBuf>,
+
+    /// Output to directory, default in the same directory as the entry file.
+    /// Relative paths are interpreted relative to the book's root directory.
+    /// If omitted, shiroa uses #build-meta.build-dir from book.typ or defaults
+    /// to `./dist`.
+    #[clap(long, short, default_value = "")]
+    pub dest_dir: String,
+
+    /// Reset path to root in html files.
+    #[clap(long, default_value = "/")]
+    pub path_to_root: String,
+
+    /// Specify a filter to only load files with a specific extension.
+    #[clap(long, default_value = "^(player.bilibili.com)$")]
+    pub allowed_url_source: Option<String>,
+}
+
+impl CompileArgs {
+    pub fn compat(&mut self) {
+        if !self.workspace.is_empty() {
+            eprintln!("warning: the --workspace flag is deprecated, use --root instead");
+        }
+        if let Some(root) = self.root.take() {
+            self.workspace = root;
+        }
+    }
+
+    pub fn canonicalize(&mut self) -> crate::error::Result<()> {
+        if !self.path_to_root.starts_with('/') {
+            self.path_to_root.insert(0, '/');
+        }
+
+        if !self.path_to_root.ends_with('/') {
+            self.path_to_root.push('/');
+        }
+
+        make_absolute(Path::new(&self.dir))
+            .to_str()
+            .unwrap()
+            .clone_into(&mut self.dir);
+
+        let dir = Path::new(&self.dir);
+        if dir.is_file() {
+            if self.meta_source == MetaSource::Strict {
+                return Err(error_once!("project dir is a file", dir: dir.display()));
+            }
+            let w = dir.parent().unwrap().to_str().unwrap().to_owned();
+            self.dir = w;
+        }
+
+        if self.workspace.is_empty() {
+            self.workspace.clone_from(&self.dir);
+        }
+
+        Ok(())
+    }
+}
+
+#[derive(Default, Debug, Clone, Parser)]
+#[clap(next_help_heading = "Init options")]
+pub struct InitArgs {
+    /// arguments for compile setting.
+    #[clap(flatten)]
+    pub compile: CompileArgs,
+}
+
+#[derive(Default, Debug, Clone, Parser)]
+#[clap(next_help_heading = "Build options")]
+pub struct BuildArgs {
+    /// arguments for compile setting.
+    #[clap(flatten)]
+    pub compile: CompileArgs,
+}
+
+#[derive(Default, Debug, Clone, Parser)]
+#[clap(next_help_heading = "Compile options")]
+pub struct ServeArgs {
+    /// arguments for compile setting.
+    #[clap(flatten)]
+    pub compile: CompileArgs,
+
+    /// Do not build the book before serving.
+    #[clap(long)]
+    pub no_build: bool,
+
+    /// Listen address.
+    #[clap(long, default_value = "127.0.0.1:25520")]
+    pub addr: String,
+}

cli/src/book.rs

@@ -0,0 +1,10 @@
+pub mod meta;
+pub mod outline;
+
+use reflexo_typst::ImmutStr;
+use typst::ecow::EcoString;
+
+pub struct ChapterItem {
+    pub title: EcoString,
+    pub path: Option<ImmutStr>,
+}

cli/src/meta.rs cli/src/book/meta.rscli/src/meta.rs renamed to cli/src/book/meta.rs

@@ -1,15 +1,15 @@
 use std::num::NonZeroUsize;
-use std::{ops::DerefMut, sync::Arc};
 
-use indexmap::IndexSet;
-use reflexo_typst::debug_loc::{DocumentPosition, SourceSpan};
-use reflexo_typst::TypstDocument;
+use reflexo_typst::{debug_loc::DocumentPosition, TypstDocument};
 use serde::{Deserialize, Serialize};
-use tokio::sync::RwLock;
-use typst::foundations::{Content, NativeElement, Packed, StyleChain};
-use typst::introspection::Introspector;
-use typst::model::HeadingElem;
-use typst::syntax::Span;
+use typst::{
+    foundations::{Content, NativeElement, Packed, StyleChain},
+    introspection::Introspector,
+    model::HeadingElem,
+    syntax::Span,
+};
+
+use crate::utils::interner::SpanInternerImpl;
 
 /// A heading in the outline panel.
 #[derive(Debug, Clone)]
@@ -178,137 +178,3 @@ fn outline_item(interner: &mut SpanInternerImpl, src: &HeadingNode, res: &mut Ve
         children,
     });
 }
-
-#[derive(Debug)]
-pub enum InternQuery<T> {
-    Ok(Option<T>),
-    UseAfterFree,
-}
-
-pub struct InternId {
-    lifetime: u32,
-    id: u32,
-}
-
-impl InternId {
-    pub fn new(lifetime: usize, id: usize) -> Self {
-        Self {
-            lifetime: lifetime as u32,
-            id: id as u32,
-        }
-    }
-
-    fn to_u64(&self) -> u64 {
-        ((self.lifetime as u64) << 32) | self.id as u64
-    }
-
-    fn from_u64(id: u64) -> Self {
-        Self {
-            lifetime: (id >> 32) as u32,
-            id: (id & 0xffffffff) as u32,
-        }
-    }
-
-    pub fn to_hex(&self) -> String {
-        format!("{:x}", self.to_u64())
-    }
-
-    pub fn from_hex(hex: &str) -> Self {
-        Self::from_u64(u64::from_str_radix(hex, 16).unwrap())
-    }
-}
-
-/// Span interner
-///
-/// Interns spans and returns an intern id. Intern id can be converted to a
-/// span. Clone of the interner is cheap, and the clone shares the same interned
-/// spans.
-#[derive(Clone, Default)]
-pub struct SpanInterner {
-    inner: Arc<RwLock<SpanInternerImpl>>,
-}
-
-impl SpanInterner {
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    #[allow(unused)]
-    pub async fn reset(&self) {
-        self.inner.write().await.reset();
-    }
-
-    pub async fn span_by_str(&self, str: &str) -> InternQuery<SourceSpan> {
-        self.inner.read().await.span_by_str(str)
-    }
-
-    #[allow(unused)]
-    pub async fn span(&self, id: InternId) -> InternQuery<SourceSpan> {
-        self.inner.read().await.span(id)
-    }
-
-    #[allow(unused)]
-    pub async fn intern(&self, span: SourceSpan) -> InternId {
-        self.inner.write().await.intern(span)
-    }
-
-    pub async fn with_writer<F, R>(&self, f: F) -> R
-    where
-        F: FnOnce(&mut SpanInternerImpl) -> R,
-    {
-        f(self.inner.write().await.deref_mut())
-    }
-}
-
-pub struct SpanInternerImpl {
-    lifetime: usize,
-    span2id: IndexSet<(usize, SourceSpan)>,
-}
-
-impl Default for SpanInternerImpl {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-const GARAGE_COLLECT_THRESHOLD: usize = 30;
-
-impl SpanInternerImpl {
-    pub fn new() -> Self {
-        Self {
-            lifetime: 1,
-            span2id: IndexSet::new(),
-        }
-    }
-
-    pub fn reset(&mut self) {
-        self.lifetime += 1;
-        self.span2id
-            .retain(|(id, _)| self.lifetime - id < GARAGE_COLLECT_THRESHOLD);
-    }
-
-    pub fn span_by_str(&self, str: &str) -> InternQuery<SourceSpan> {
-        self.span(InternId::from_hex(str))
-    }
-
-    pub fn span(&self, id: InternId) -> InternQuery<SourceSpan> {
-        if (id.lifetime as usize + GARAGE_COLLECT_THRESHOLD) <= self.lifetime {
-            InternQuery::UseAfterFree
-        } else {
-            InternQuery::Ok(
-                self.span2id
-                    .get_index(id.id as usize)
-                    .map(|(_, span)| span)
-                    .copied(),
-            )
-        }
-    }
-
-    pub fn intern(&mut self, span: SourceSpan) -> InternId {
-        let item = (self.lifetime, span);
-        let (idx, _) = self.span2id.insert_full(item);
-        // combine lifetime
-
-        InternId::new(self.lifetime, idx)
-    }
-}

cli/src/outline.rs cli/src/book/outline.rscli/src/outline.rs renamed to cli/src/book/outline.rs

@@ -0,0 +1,5 @@
+mod init;
+mod serve;
+
+pub use init::init;
+pub use serve::serve;