@prospective.co/procss 0.1.10 → 0.1.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prospective.co/procss",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "A simple CSS parsing and transformation framework.",
   "repository": {
     "type": "git",

package/src/builder.rs

@@ -10,7 +10,7 @@
 // └───────────────────────────────────────────────────────────────────────────┘
 
 use std::collections::HashMap;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 use anyhow::Context;
 
@@ -25,15 +25,15 @@ use crate::{ast, transformers, utils};
 /// A CSS+ project build, comprising a collection of CSS+ files which may
 /// reference eachother (via `@import`).
 pub struct BuildCss<'a> {
-    paths: Vec<String>,
-    contents: HashMap<&'a str, String>,
-    trees: HashMap<&'a str, ast::Tree<'a>>,
-    css: HashMap<&'a str, ast::Css<'a>>,
-    rootdir: String,
+    paths: Vec<PathBuf>,
+    contents: HashMap<&'a Path, String>,
+    trees: HashMap<&'a Path, ast::Tree<'a>>,
+    css: HashMap<&'a Path, ast::Css<'a>>,
+    rootdir: PathBuf,
 }
 
 /// The compiled output of a [`BuildCss`] collection, obtained from
-/// [`BuildCss::compile`].  
+/// [`BuildCss::compile`].
 pub struct CompiledCss<'a>(&'a BuildCss<'a>);
 
 /// An incremental build struct for compiling a project's CSS sources.
@@ -47,7 +47,7 @@ pub struct CompiledCss<'a>(&'a BuildCss<'a>);
 /// ```
 impl<'a> BuildCss<'a> {
     /// Create a new [`BuildCss`] rooted at `rootdir`.
-    pub fn new<S: Into<String>>(rootdir: S) -> Self {
+    pub fn new<P: Into<PathBuf>>(rootdir: P) -> Self {
         Self {
             paths: Default::default(),
             contents: Default::default(),
@@ -59,17 +59,17 @@ impl<'a> BuildCss<'a> {
 
     /// Add a file `path` to this build.
     #[cfg(not(target_arch = "wasm32"))]
-    pub fn add_file(&mut self, path: &'a str) {
-        self.paths.push(path.to_owned());
-        let inpath = PathBuf::from(&self.rootdir).join(path);
-        let txt = fs::read_to_string(inpath.as_path()).unwrap();
-        self.contents.insert(path, txt);
+    pub fn add_file<P: ?Sized + AsRef<Path>>(&mut self, path: &'a P) {
+        self.paths.push(path.as_ref().into());
+        let inpath = self.rootdir.join(path);
+        let txt = fs::read_to_string(&inpath).unwrap();
+        self.contents.insert(path.as_ref(), txt);
     }
 
     /// Add a file `path` to this build.
-    pub fn add_content(&mut self, path: &'a str, scss: String) {
-        self.paths.push(path.to_owned());
-        self.contents.insert(path, scss);
+    pub fn add_content<P: ?Sized + AsRef<Path>>(&mut self, path: &'a P, scss: String) {
+        self.paths.push(path.as_ref().into());
+        self.contents.insert(path.as_ref(), scss);
     }
 
     /// Compile this [`BuildCss`] start-to-finish, applying all transforms along
@@ -104,9 +104,9 @@ impl<'a> CompiledCss<'a> {
     /// subdirectory structure of the `input` sources passed to
     /// [`BuildCss::add`], relative to `outdir`.
     #[cfg(not(target_arch = "wasm32"))]
-    pub fn write(self, outdir: &'static str) -> anyhow::Result<()> {
+    pub fn write<P: AsRef<Path>>(self, outdir: P) -> anyhow::Result<()> {
         for (outfile, css, path) in self.iter_files().flatten() {
-            let outdir = utils::join_paths(outdir, path);
+            let outdir = utils::join_paths(outdir.as_ref(), path);
             fs::create_dir_all(outdir.clone()).unwrap_or_default();
             fs::write(outdir.join(outfile), css)?;
         }
@@ -126,7 +126,7 @@ impl<'a> CompiledCss<'a> {
         Ok(results)
     }
 
-    fn iter_files(&self) -> impl Iterator<Item = anyhow::Result<(String, String, &'_ str)>> {
+    fn iter_files(&self) -> impl Iterator<Item = anyhow::Result<(String, String, &'_ Path)>> {
         self.0.css.iter().map(|(path, css)| {
             let outpath = PathBuf::from(path);
             let outfile = format!(

package/src/main.rs

@@ -15,14 +15,13 @@ use procss::*;
 
 #[cfg(not(target_arch = "wasm32"))]
 mod init {
-    use std::path::Path;
     use std::{env, fs};
 
     use procss::*;
 
     pub fn init() -> anyhow::Result<String> {
         let args: Vec<String> = env::args().collect();
-        let contents = fs::read_to_string(Path::new(&args[1]));
+        let contents = fs::read_to_string(&args[1]);
         let css = parse(&contents?)?.flatten_tree().as_css_string();
         Ok(css)
     }

package/src/transformers/apply_import.rs

@@ -10,12 +10,13 @@
 // └───────────────────────────────────────────────────────────────────────────┘
 
 use std::collections::HashMap;
+use std::path::Path;
 
 use super::filter_refs;
 use crate::ast::Ruleset::{self};
 use crate::ast::*;
 
-pub fn apply_import<'a, 'b>(assets: &'b HashMap<&str, Tree<'a>>) -> impl Fn(&mut Tree<'a>) + 'b {
+pub fn apply_import<'a, 'b>(assets: &'b HashMap<&Path, Tree<'a>>) -> impl Fn(&mut Tree<'a>) + 'b {
     |tree| {
         tree.transform(|ruleset| {
             let mut replace = None;
@@ -23,15 +24,17 @@ pub fn apply_import<'a, 'b>(assets: &'b HashMap<&str, Tree<'a>>) -> impl Fn(&mut
                 if *name == "import" {
                     if let Some(val) = val {
                         if val.starts_with('\"') {
-                            replace = assets.get(&val[1..val.len() - 1]).cloned();
+                            replace = assets.get(Path::new(&val[1..val.len() - 1])).cloned();
                             if replace.is_none() {
                                 panic!("File not found: '{}'", &val[1..val.len() - 1])
                             }
                         } else if val.starts_with("url(\"ref://") {
-                            replace = assets.get(&val[11..val.len() - 2]).cloned().map(|mut x| {
-                                filter_refs(&mut x);
-                                x
-                            });
+                            replace = assets.get(Path::new(&val[11..val.len() - 2])).cloned().map(
+                                |mut x| {
+                                    filter_refs(&mut x);
+                                    x
+                                },
+                            );
 
                             if replace.is_none() {
                                 panic!("File not found: '{}'", &val[1..val.len() - 1])

package/src/transformers/inline_url.rs

@@ -27,15 +27,20 @@ fn parse_url(input: &str) -> nom::IResult<&str, &str> {
     alt((quoted, unquoted))(input)
 }
 
-fn into_data_uri<'a>(path: &Path) -> Cow<'a, str> {
-    let contents = fs::read_to_string(path).expect("Error reading file");
+fn into_data_uri<'a>(path: &Path) -> Option<Cow<'a, str>> {
+    if path.starts_with("data:") {
+        return None;
+    }
+
+    let contents = fs::read(path).ok()?;
     let encoded = base64::encode(contents);
     let fff = path.extension().unwrap_or_default().to_string_lossy();
     let fmt = match fff.as_ref() {
         "png" => "png",
         _ => "svg+xml",
     };
-    format!("url(\"data:image/{};base64,{}\")", fmt, encoded).into()
+
+    Some(format!("url(\"data:image/{};base64,{}\")", fmt, encoded).into())
 }
 
 fn inline_url_impl<'a>(newpath: &str, flat: &mut Css<'a>) {
@@ -46,7 +51,9 @@ fn inline_url_impl<'a>(newpath: &str, flat: &mut Css<'a>) {
 
         if let Some(path) = &path {
             if path.starts_with(".") || path.starts_with("/") {
-                rule.value = into_data_uri(path);
+                if let Some(value) = into_data_uri(path) {
+                    rule.value = value;
+                }
             }
         }
     })

package/src/utils.rs

@@ -9,8 +9,6 @@
 // │                                                                           │
 // └───────────────────────────────────────────────────────────────────────────┘
 
-use std::path::PathBuf;
-
 use crate::render::RenderCss;
 
 /// A wrapper around [`Vec`] which guarantees at least `N` elements.
@@ -56,8 +54,8 @@ impl<T: RenderCss, const N: usize> RenderCss for MinVec<T, N> {
 /// to the latter and join with the former.  If the latter path is not relative,
 /// return the former.  Useful for moving directory trees while retaining their
 /// relative structure to some root.
-pub fn join_paths(outdir: &str, path: &str) -> PathBuf {
-    if let Some(parent) = PathBuf::from(path).parent() {
+pub fn join_paths(outdir: &Path, path: &Path) -> PathBuf {
+    if let Some(parent) = path.parent() {
         PathBuf::from(outdir).join(parent)
     } else {
         PathBuf::from(outdir)
@@ -72,6 +70,8 @@ mod mock {
         // where
         //     P: AsRef<std::path::Path> + 'static;
 
+        fn read(path: &std::path::Path) -> std::io::Result<Vec<u8>>;
+
         fn create_dir_all<P>(path: P) -> std::io::Result<()>
         where
             P: AsRef<std::path::Path> + 'static;
@@ -85,6 +85,7 @@ mod mock {
 
 #[cfg(not(feature = "iotest"))]
 pub use std::fs;
+use std::path::{Path, PathBuf};
 
 #[cfg(feature = "iotest")]
 pub use mock::{IoTestFs, MockIoTestFs as fs};