From a299442fa50d2571f426b396a3d23e0b3f24da7b Mon Sep 17 00:00:00 2001 From: Emile Date: Sun, 9 Jan 2022 13:32:02 +0100 Subject: initial commit --- src/main.rs | 473 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 473 insertions(+) create mode 100644 src/main.rs (limited to 'src/main.rs') diff --git a/src/main.rs b/src/main.rs new file mode 100644 index 0000000..6f24c4f --- /dev/null +++ b/src/main.rs @@ -0,0 +1,473 @@ +// pull the std into scope and inline it so that we get documentation for it, +// even when running offline +#[doc(inline)] +pub use std; + +use std::path::{Path, PathBuf}; +use std::io::{self, Read, Write}; +use std::fs::{self, File}; +use std::time; + +fn main() -> std::io::Result<()> { + + // the input and output pathes + let in_path = Path::new("../emile.space/in").to_path_buf(); + let out_path = Path::new("../emile.space/out").to_path_buf(); + + println!("inpath: {}", in_path.display()); + println!("outpath: {}", out_path.display()); + + // read the style + let mut style_file = File::open("./style.css")?; + let mut style = String::new(); + style_file.read_to_string(&mut style)?; + + // read all dirs in the input path + let pathes = recursive_read_dir(&in_path, false)?; + + println!("---"); + for path in pathes { + println!("\n"); + println!("[i] {}", path.as_os_str().to_str().unwrap()); + + let stripped_path = path.strip_prefix(&in_path) + .expect("could not strip the in_path prefix"); + + // copy images and other files to the output folder + if path.is_file() { + + // define the source and destination + let src = Path::new(&in_path).join(stripped_path); + let dst = Path::new(&out_path).join(stripped_path); + + // define the destination folder (the dst path without the file) and + // create it + let mut dst_folder = dst.clone(); + dst_folder.pop(); + fs::create_dir_all(dst_folder)?; + + // copy the file to the destination + std::fs::copy(src, dst.as_path())?; + } + + if stripped_path.ends_with("README.md") { + println!("\tstripped_path: {:?}", stripped_path); + + // define the "raw" path (no infile prefix, no file) + let mut ancestors = stripped_path.ancestors(); + ancestors.next(); + + let raw_path = ancestors.next() + .expect("could not extract next ancestor"); + println!("\traw_path: {:?}", raw_path); + + // out + rawpath + let index_path = out_path.join(raw_path); + println!("\tindex_path: {:?}", index_path); + + // (out + rawpath) + "index.html" + let index_file = index_path.join("index.html"); + println!("\tindex_file: {:?}", index_file); + + // - create the dir for the index.html as well as the index.html itself + fs::create_dir_all(index_path)?; + let mut file = File::create(&index_file)?; + + write_header(&mut file, &style)?; + write_body_start(&mut file)?; + write_nav(&mut file, in_path.as_path(), raw_path)?; + write_same_level(&mut file, in_path.as_path(), raw_path)?; + write_readme_content(&mut file, in_path.as_path(), raw_path)?; + write_footer(&mut file)?; + + file.write_all("".as_bytes())?; + } + + } + + Ok(()) +} + +/// Write the html header including the style file +fn write_header(file: &mut File, style: &String) -> std::io::Result<()>{ + + // write the header including the style file + file.write_all(format!(r#" + + + + + + emile.space + + + + "#, style).as_bytes())?; + + Ok(()) +} + +fn write_body_start(file: &mut File) -> std::io::Result<()>{ + file.write_all(format!(r#" + +

+ emile.space +

"#).as_bytes())?; + + Ok(()) +} + +/// Write the navigation section to the given file +fn write_nav(file: &mut File, in_path: &Path, raw_path: &Path) + -> std::io::Result<()> { + + //////////////////////////////////////////////////////////////////////////// + file.write_all(format!(r#" +

>(); + + // for each list of components (["a"], ["a", "b"], ["a", "b", "c"]), create + // the path for the list, view all other dirs at that path and write the + // result to the file + let mut i = 0; + let slice = components.as_slice(); + + // for each navbar component + for component in slice { + + // get the items belonging to that navbar item + // (["a"], ["a", "b"], ["a", "b", "c"]) + let subpath_components = &slice[..i+1]; + i += 1; + + println!("\tsubpath_components:"); + subpath_components.iter().for_each(|c| { + println!("\t\t{:?}", c); + }); + + let mut subpath_path = PathBuf::new(); + + // push the inpath, so we've got a basis from where we can read the + // subpath items + // subpath_path = inpath + ??? + subpath_path.push(in_path); + + let mut nav_breadcrumb_link = PathBuf::new(); + + // for each item in the subpath, push it into the subpath_path so that + // in the end, we've got something like this: + // "inpath" + "a" + "b" + "c" + for subpath_component in subpath_components { + subpath_path.push(subpath_component); + nav_breadcrumb_link.push(subpath_component); + } + + // make the nav_breadcrumb_link an absolute by prefixing it with a / + // (this is in scope of the web-page, so this is find) and make it a + // string + let nav_breadcrumb_link_absolute + = Path::new("/") + .join(nav_breadcrumb_link); + + let nav_breadcrumb_link + = nav_breadcrumb_link_absolute.to_str().unwrap(); + + // define the name of the breadcrumb + let nav_breadcrumb_name = component.as_os_str().to_str().unwrap(); + + //////////////////////////////////////////////////////////////////////// + file.write_all(format!(r#" +

+ {} +

"#.as_bytes())?; + //////////////////////////////////////////////////////////////////////// + } + + //////////////////////////////////////////////////////////////////////////// + file.write_all(format!(r#" +

"#).as_bytes())?; + //////////////////////////////////////////////////////////////////////////// + + Ok(()) +} + + +fn write_same_level(file: &mut File, in_path: &Path, raw_path: &Path) + -> std::io::Result<()> { + + let search_path = Path::new(in_path).join(raw_path); + + println!("\tsame_level:"); + println!("\t\t{:?}", search_path); + + let mut dirs: Vec = Vec::new(); + let mut files: Vec = Vec::new(); + + let mut vertical: bool = false; + + for entry in fs::read_dir(search_path)? { + let path = &entry?.path(); + + if path.is_dir() { + dirs.push(path.to_path_buf()); + println!("\t\t\t{:?}", path); + } + if path.is_file() { + files.push(path.to_path_buf()); + if path.file_name().unwrap() == "vertical" { + vertical = true; + } + println!("\t\t\t{:?}", path); + } + } + + dirs.sort(); + files.sort(); + + let in_path = in_path.canonicalize()?; + + if vertical == true { + file.write_all(format!(r#" +

").as_bytes())?;
+
+    // cheap markdown 2 html converter
+    for line in readme.split('\n') {
+
+        if line.starts_with("###") {
+            let heading = line.get(4..).unwrap();
+            let heading_sanitized = sanitize(heading.to_string());
+
+            file.write_all(format!(r##"

{b}

"##, a = heading_sanitized, b = heading).as_bytes())?;
+
+        } else if line.starts_with("##") {
+            let heading = line.get(3..).unwrap();
+            let heading_sanitized = sanitize(heading.to_string());
+
+            file.write_all(format!(r##"

{b}

"##, a = heading_sanitized, b = heading).as_bytes())?;
+
+        } else if line.starts_with("#") {
+            let heading = line.get(2..).unwrap();
+            let heading_sanitized = sanitize(heading.to_string());
+
+            file.write_all(format!(r##"

{b}

"##, a = heading_sanitized, b = heading).as_bytes())?;
+
+        } else if line.starts_with(">") {
+            let line = line.get(1..).unwrap();
+            file.write_all(format!("

{}

\n", line).as_bytes())?;
+
+        } else if line.starts_with(":::tree") {
+
+            // get all dirs in the current dir recursively
+            let tree_files_path = Path::new(in_path).join(raw_path);
+            let mut tree_files
+                = recursive_read_dir(&tree_files_path, true)?;
+            
+            // sort them, otherwise we'll get complete chaos
+            tree_files.sort();
+
+            for path in tree_files {
+
+                // strip the inpath prefix and raw_path prefix, as we don't need
+                // them
+                let path 
+                    = path.strip_prefix(in_path)
+                        .expect("could not strip in_file prefix")
+                        .strip_prefix(raw_path)
+                        .expect("could not strip raw_path prefix");
+
+
+                // count the amount of segments in the path and write spaces for
+                // each
+                let segments = path.iter().count();
+                for _ in 0..(segments-1) {
+                    file.write_all(r#"    "#.as_bytes())?;
+                }
+
+                // write the linke and the entry name to the file
+                let link = Path::new(raw_path).join(path);
+                file.write_all(
+                    format!("{}\n",
+                        link.display(),
+                        path.file_name().unwrap().to_str().unwrap()
+                        ).as_bytes()
+                )?;
+            }
+            
+        } else {
+
+            // for the case that nothing of the above matches, just write the
+            // content into the html body as it is
+            file.write_all(format!("{}\n", line).as_bytes())?;
+        }
+    }
+
+    Ok(())
+}
+
+fn write_footer(file: &mut File) -> std::io::Result<()> {
+    file.write_all(format!(r#"

+    

+    

+———
+emile - {:?}
+
+
+    "#,
+    time::SystemTime::now()
+        .duration_since(time::SystemTime::UNIX_EPOCH).unwrap()
+    ).as_bytes())?;
+
+    Ok(())
+}
+
+/// sanitize the given string (to lower + space to hypen + keep only
+/// [a-zA-Z0-9])
+fn sanitize(input: String) -> String {
+    let input = input.replace(" ", "-");
+
+    input
+        .chars()
+        .filter(|c| c.is_ascii_alphanumeric() || c.eq(&'-'))
+        .collect::()
+        .to_lowercase()
+}
+
+/// Return a list of all files in the directory, recursively.
+fn recursive_read_dir(dir: &PathBuf, dir_only: bool) -> io::Result> {
+    // return an empty vec if the given path is not a directory
+    if dir.is_dir() == false {
+        return Ok(vec![]);
+    }
+
+    // store the child pathes
+    let mut entries: Vec = Vec::new();
+    
+    // iterate over all items in the dir, pushing the dirs pathes to the dirs
+    // vector for returnin it
+    for entry in fs::read_dir(dir)? {
+        let path = &entry?.path();
+
+        if dir_only == true {
+            if path.is_dir() {
+                entries.push(path.to_path_buf());
+            }
+        } else {
+            entries.push(path.to_path_buf());
+        }
+
+        // recursively push all dirs from all children to the dirs vector
+        let subdirs = recursive_read_dir(&path, dir_only)?;
+
+        for subdir in subdirs {
+            entries.push(subdir)
+        }
+    }
+
+    // return the dirs, the ones from this folder and the ones from all child folders
+    Ok(entries)
+}
\ No newline at end of file
-- 
cgit 1.4.1