Add logic to read and assign files / layout

[rbdr/page] / src / file_handler / mod.rs

mod file_strategies;

use file_strategies::file::Strategy as FileStrategy;
use file_strategies::gemini::Strategy as GeminiStrategy;
use file_strategies::layout::Strategy as LayoutStrategy;

use std::path::PathBuf;
use std::fs::read_to_string;

pub struct FileHandler {
   pub strategies: Vec<Box<dyn FileHandlerStrategy>>,
   pub layout: Option<String>
}

impl Default for FileHandler {
    fn default() -> FileHandler {
        FileHandler {
            strategies: vec![
                Box::new(GeminiStrategy{}),
                Box::new(LayoutStrategy{}),
                Box::new(FileStrategy{}),
            ],
            layout: None
        }
    }
}

impl FileHandler {
    pub fn identify(&self, path: &PathBuf) -> FileType {
        for strategy in self.strategies.iter() {
            if strategy.is(&path) {
                return strategy.identify();
            }
        }
        FileType::Unknown
    }

    pub fn get_layout_or_panic(&mut self, files: &Vec<File>) {
        for file in files {
            match file.file_type {
                FileType::Layout => {
                    let layout_text = read_to_string(&file.path).unwrap();
                    self.layout = Some(layout_text);
                    return;
                },
                _ => {}
            }
        }
        panic!("No layout found. Please ensure there's a _layout.html file at the root");
    }

    pub fn handle_all(&self, source: &PathBuf, destination: &PathBuf, files: &Vec<File>) {
        for file in files {
            self.handle(source, destination, file);
        }
    }

    pub fn handle(&self, source: &PathBuf, destination: &PathBuf, file: &File) {
        for strategy in self.strategies.iter() {
            if strategy.can_handle(&file.file_type) {
                return strategy.handle(file);
            }
        }
    }
}

pub trait FileHandlerStrategy {
    fn is(&self, path: &PathBuf) -> bool;
    fn identify(&self) -> FileType;
    fn can_handle(&self, file_type: &FileType) -> bool;
    fn handle(&self, file: &File);
}

pub enum FileType {
    Gemini,
    File,
    Layout,
    Unknown,
}

pub struct File {
    pub path: PathBuf,
    pub file_type: FileType,
}