Merge pull request #492 from malbarbo/dirbundle

Add DirBundle

Author: pkgw

src/bin/tectonic.rs

@@ -7,7 +7,6 @@ use tectonic;
 use structopt::StructOpt;
 
 use std::env;
-use std::fs::File;
 use std::path::{Path, PathBuf};
 use std::process;
 use std::str::FromStr;
@@ -16,11 +15,10 @@ use std::time;
 use tectonic::config::PersistentConfig;
 use tectonic::driver::{OutputFormat, PassSetting, ProcessingSessionBuilder};
 use tectonic::errors::{ErrorKind, Result};
-use tectonic::io::zipbundle::ZipBundle;
 use tectonic::status::termcolor::TermcolorStatusBackend;
 use tectonic::status::{ChatterLevel, StatusBackend};
 
-use tectonic::{ctry, errmsg, tt_error, tt_error_styled, tt_note};
+use tectonic::{errmsg, tt_error, tt_error_styled, tt_note};
 
 #[derive(Debug, StructOpt)]
 #[structopt(name = "Tectonic", about = "Process a (La)TeX document")]
@@ -31,16 +29,10 @@ struct CliOptions {
     /// The name of the "format" file used to initialize the TeX engine
     #[structopt(long, short, name = "path", default_value = "latex")]
     format: String,
-    /// Use this Zip-format bundle file to find resource files instead of the default
-    #[structopt(
-        takes_value(true),
-        parse(from_os_str),
-        long,
-        short,
-        name = "zip_file_path"
-    )]
+    /// Use this directory or Zip-format bundle file to find resource files instead of the default
+    #[structopt(takes_value(true), parse(from_os_str), long, short, name = "file_path")]
     bundle: Option<PathBuf>,
-    /// Use this URL find resource files instead of the default
+    /// Use this URL to find resource files instead of the default
     #[structopt(takes_value(true), long, short, name = "url")]
     // TODO add URL validation
     web_bundle: Option<String>,
@@ -166,16 +158,10 @@ fn inner(
     if only_cached {
         tt_note!(status, "using only cached resource files");
     }
-    if let Some(p) = args.bundle {
-        let zb = ctry!(ZipBundle::<File>::open(&p); "error opening bundle");
-        sess_builder.bundle(Box::new(zb));
+    if let Some(path) = args.bundle {
+        sess_builder.bundle(config.make_local_file_provider(path, status)?);
     } else if let Some(u) = args.web_bundle {
-        sess_builder.bundle(Box::new(config.make_cached_url_provider(
-            &u,
-            only_cached,
-            None,
-            status,
-        )?));
+        sess_builder.bundle(config.make_cached_url_provider(&u, only_cached, None, status)?);
     } else {
         sess_builder.bundle(config.default_bundle(only_cached, status)?);
     }

src/config.rs

@@ -12,14 +12,14 @@
 
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
-use std::ffi::OsStr;
 use std::fs::File;
 use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicBool, Ordering};
 
 use crate::app_dirs;
 use crate::errors::{ErrorKind, Result};
 use crate::io::cached_itarbundle::CachedITarBundle;
+use crate::io::dirbundle::DirBundle;
 use crate::io::zipbundle::ZipBundle;
 use crate::io::Bundle;
 use crate::status::StatusBackend;
@@ -119,12 +119,15 @@ impl PersistentConfig {
 
     pub fn make_local_file_provider(
         &self,
-        file_path: &OsStr,
+        file_path: PathBuf,
         _status: &mut dyn StatusBackend,
     ) -> Result<Box<dyn Bundle>> {
-        let zip_bundle = ZipBundle::<File>::open(Path::new(file_path))?;
-
-        Ok(Box::new(zip_bundle) as _)
+        let bundle: Box<dyn Bundle> = if file_path.is_dir() {
+            Box::new(DirBundle::new(file_path))
+        } else {
+            Box::new(ZipBundle::open(file_path)?)
+        };
+        Ok(bundle)
     }
 
     pub fn default_bundle(
@@ -153,9 +156,7 @@ impl PersistentConfig {
             let file_path = url.to_file_path().map_err(|_| {
                 io::Error::new(io::ErrorKind::InvalidInput, "failed to parse local path")
             })?;
-            let zip_bundle = self.make_local_file_provider(file_path.as_os_str(), status)?;
-
-            return Ok(Box::new(zip_bundle) as _);
+            return self.make_local_file_provider(file_path, status);
         }
         let bundle =
             self.make_cached_url_provider(&self.default_bundles[0].url, only_cached, None, status)?;

src/io/dirbundle.rs

@@ -0,0 +1,43 @@
+use std::ffi::OsStr;
+use std::fs::File;
+use std::io::BufReader;
+use std::path::PathBuf;
+
+use super::{Bundle, InputHandle, InputOrigin, IoProvider, OpenResult};
+use crate::status::StatusBackend;
+
+pub struct DirBundle {
+    dir: PathBuf,
+}
+
+impl DirBundle {
+    pub fn new(dir: PathBuf) -> DirBundle {
+        DirBundle { dir }
+    }
+}
+
+impl IoProvider for DirBundle {
+    fn input_open_name(
+        &mut self,
+        name: &OsStr,
+        _status: &mut dyn StatusBackend,
+    ) -> OpenResult<InputHandle> {
+        let mut path = self.dir.clone();
+        path.push(name);
+
+        if path.is_file() {
+            match File::open(path) {
+                Err(e) => OpenResult::Err(e.into()),
+                Ok(f) => OpenResult::Ok(InputHandle::new(
+                    name,
+                    BufReader::new(f),
+                    InputOrigin::Filesystem,
+                )),
+            }
+        } else {
+            OpenResult::NotAvailable
+        }
+    }
+}
+
+impl Bundle for DirBundle {}

src/io/mod.rs

@@ -18,6 +18,7 @@ use crate::errors::{Error, ErrorKind, Result};
 use crate::status::StatusBackend;
 
 pub mod cached_itarbundle;
+pub mod dirbundle;
 pub mod filesystem;
 pub mod format_cache;
 pub mod memory;

src/io/zipbundle.rs

@@ -26,7 +26,7 @@ impl<R: Read + Seek> ZipBundle<R> {
 }
 
 impl ZipBundle<File> {
-    pub fn open(path: &Path) -> Result<ZipBundle<File>> {
+    pub fn open<P: AsRef<Path>>(path: P) -> Result<ZipBundle<File>> {
         Self::new(File::open(path)?)
     }
 }