core: Adjust behaviour for bindings and function file finding

From now on, we search $ common/$ then template/$ and as such
we will find common (polyglot) bindings automatically

Signed-off-by: Daniel Silverstone <dsilvers@digital-scurf.org>

1 files changed, 28 insertions, 20 deletions

diff --git a/src/resource.rs b/src/resource.rs
index bd6fc34..758ffca 100644
--- a/src/resource.rs
+++ b/src/resource.rs
@@ -71,31 +71,39 @@ fn add_search_path<P: AsRef<Path>>(path: P) {
 /// Second, it's relative to the input document.
 /// Finally we check for an embedded file.
 ///
-/// Then we repeat all the above, inserting the template name in the subpath
+/// Then we repeat all the above, inserting 'common' as the template name, and
+/// finally repeat the above inserting the real template name in the subpath
 /// too.
 fn open<P: AsRef<Path>>(subpath: P, template: Option<&str>) -> io::Result<Box<dyn Read>> {
     let subpath = subpath.as_ref();
-    match internal_open(subpath) {
-        Ok(r) => Ok(r),
-        Err(e) => {
-            if let Some(templ) = template {
-                let subpath = Path::new(templ).join(subpath);
-                match internal_open(&subpath) {
-                    Ok(r) => Ok(r),
-                    Err(sub_e) => {
-                        if sub_e.kind() != io::ErrorKind::NotFound
-                            && e.kind() == io::ErrorKind::NotFound
-                        {
-                            Err(sub_e)
-                        } else {
-                            Err(e)
-                        }
-                    }
-                }
-            } else {
-                Err(e)
+    let plain = match internal_open(subpath) {
+        Ok(r) => return Ok(r),
+        Err(e) => e,
+    };
+    let commonpath = Path::new("common").join(subpath);
+    let common = match internal_open(&commonpath) {
+        Ok(r) => return Ok(r),
+        Err(e) => e,
+    };
+    let templated = match template {
+        Some(templ) => {
+            let templpath = Path::new(templ).join(subpath);
+            match internal_open(&templpath) {
+                Ok(r) => return Ok(r),
+                Err(e) => Some(e),
             }
         }
+        None => None,
+    };
+    if plain.kind() != io::ErrorKind::NotFound {
+        return Err(plain);
+    }
+    if common.kind() != io::ErrorKind::NotFound {
+        return Err(common);
+    }
+    match templated {
+        Some(e) => Err(e),
+        None => Err(common),
     }
 }