@prospective.co/procss 0.1.8

package/src/ast/tree_ruleset.rs

@@ -0,0 +1,252 @@
+// ┌───────────────────────────────────────────────────────────────────────────┐
+// │                                                                           │
+// │  ██████╗ ██████╗  ██████╗   Copyright (C) 2022, The Prospective Company   │
+// │  ██╔══██╗██╔══██╗██╔═══██╗                                                │
+// │  ██████╔╝██████╔╝██║   ██║  This file is part of the Procss library,      │
+// │  ██╔═══╝ ██╔══██╗██║   ██║  distributed under the terms of the            │
+// │  ██║     ██║  ██║╚██████╔╝  Apache License 2.0.  The full license can     │
+// │  ╚═╝     ╚═╝  ╚═╝ ╚═════╝   be found in the LICENSE file.                 │
+// │                                                                           │
+// └───────────────────────────────────────────────────────────────────────────┘
+
+use nom::branch::alt;
+use nom::bytes::complete::tag;
+use nom::combinator::peek;
+use nom::error::ParseError;
+use nom::multi::{many0, many1};
+use nom::sequence::{terminated, tuple};
+use nom::{IResult, Parser};
+
+use super::flat_ruleset::FlatRuleset;
+use super::ruleset::{QualNestedRuleset, QualRule, QualRuleset, Rule, Ruleset, SelectorRuleset};
+use super::selector::Selector;
+use super::token::{comment0, sep0};
+use crate::parser::*;
+use crate::render::*;
+use crate::transform::TransformCss;
+
+/// A tree node which expresses a recursive `T` over `Ruleset<T>`.  Using this
+/// struct in place of `Rule` allows nested CSS selectors that can be later
+/// flattened.
+#[derive(Clone, Debug)]
+pub enum TreeRule<'a> {
+    Rule(Rule<'a>),
+    Ruleset(TreeRuleset<'a>),
+}
+
+impl<'a> ParseCss<'a> for TreeRule<'a> {
+    fn parse<E: ParseError<&'a str>>(input: &'a str) -> IResult<&'a str, Self, E> {
+        let block = terminated(TreeRuleset::parse, sep0).map(TreeRule::Ruleset);
+        let rule = terminated(Rule::parse, sep0).map(TreeRule::Rule);
+        alt((block, rule))(input)
+    }
+}
+
+impl<'a> RenderCss for TreeRule<'a> {
+    fn render(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            TreeRule::Rule(rule) => rule.render(f),
+            TreeRule::Ruleset(block) => block.render(f),
+        }
+    }
+}
+
+impl<'a> TransformCss<Rule<'a>> for TreeRule<'a> {
+    fn transform_each<F: FnMut(&mut Rule<'a>)>(&mut self, f: &mut F) {
+        match self {
+            TreeRule::Rule(rule) => f(rule),
+            TreeRule::Ruleset(ruleset) => ruleset.transform_each(f),
+        }
+    }
+}
+
+impl<'a> TransformCss<TreeRuleset<'a>> for TreeRule<'a> {
+    fn transform_each<F: FnMut(&mut TreeRuleset<'a>)>(&mut self, f: &mut F) {
+        match self {
+            TreeRule::Rule(_) => (),
+            TreeRule::Ruleset(ruleset) => ruleset.transform_each(f),
+        }
+    }
+}
+
+impl<'a> TransformCss<Vec<TreeRuleset<'a>>> for TreeRule<'a> {
+    fn transform_each<F: FnMut(&mut Vec<TreeRuleset<'a>>)>(&mut self, f: &mut F) {
+        match self {
+            TreeRule::Rule(_) => (),
+            TreeRule::Ruleset(ruleset) => ruleset.transform_each(f),
+        }
+    }
+}
+
+/// A nested recursive block, ala popular CSS tools and the CSS nesting
+/// proposal.
+///
+/// ```css
+/// div {
+///     color: green;
+///     &#my_elem {
+///         color: red;
+///     }
+///     .sub_elem {
+///         color: purple;
+///     }
+/// }
+/// ```
+pub type TreeRuleset<'a> = Ruleset<'a, TreeRule<'a>>;
+
+impl<'a> ParseCss<'a> for TreeRuleset<'a> {
+    fn parse<E: ParseError<&'a str>>(input: &'a str) -> IResult<&'a str, Self, E> {
+        if let Ok((input, _)) = peek::<_, _, E, _>(tag("@"))(input) {
+            let (input, qual_rule) = QualRule::parse(input)?;
+            if let Ok((input, _)) = tag::<_, _, E>(";")(input) {
+                Ok((input, Ruleset::QualRule(qual_rule)))
+            } else {
+                let (input, _) = tuple((tag("{"), sep0))(input)?;
+                let (input, rules) = many1(TreeRule::parse::<E>)(input)?;
+                let (input, _) = tuple((comment0, tag("}")))(input)?;
+                Ok((input, Ruleset::QualRuleset(QualRuleset(qual_rule, rules))))
+            }
+        } else {
+            let (input, selector_ruleset) = SelectorRuleset::parse(input)?;
+            Ok((input, Ruleset::SelectorRuleset(selector_ruleset)))
+        }
+    }
+}
+
+impl<'a> TransformCss<TreeRuleset<'a>> for TreeRuleset<'a> {
+    fn transform_each<F: FnMut(&mut TreeRuleset<'a>)>(&mut self, f: &mut F) {
+        f(self);
+        match self {
+            Ruleset::QualRule(_) => (),
+            Ruleset::QualRuleset(_) => (),
+            Ruleset::QualNestedRuleset(..) => (),
+            Ruleset::SelectorRuleset(ruleset) => {
+                for rule in ruleset.1.iter_mut() {
+                    rule.transform_each(f)
+                }
+            }
+        }
+    }
+}
+
+impl<'a> TreeRuleset<'a> {
+    /// Flatten into a `FlatRuleset`, replacing this struct's inner `TreeRule`
+    /// recursive type with a regular `Rule`, removing arbitrary nesting of
+    /// `SelectorRuleset` variants.
+    pub fn flatten_tree(&self) -> Vec<FlatRuleset<'a>> {
+        match self {
+            Ruleset::SelectorRuleset(ruleset) => ruleset.flatten_tree(),
+            Ruleset::QualRule(x) => vec![Ruleset::QualRule(x.clone())],
+            Ruleset::QualRuleset(rules) => {
+                let mut new_rules: Vec<Rule<'a>> = vec![];
+                let mut new_rulesets: Vec<FlatRuleset<'a>> = vec![];
+                for rule in rules.1.iter() {
+                    match rule {
+                        TreeRule::Rule(rule) => new_rules.push(rule.clone()),
+                        TreeRule::Ruleset(ruleset) => {
+                            let sub_rules = ruleset.flatten_tree().into_iter();
+                            new_rulesets.extend(sub_rules)
+                        }
+                    }
+                }
+
+                let mut ret = vec![];
+                if !new_rules.is_empty() {
+                    let ruleset = QualRuleset(rules.0.clone(), new_rules);
+                    ret.push(Ruleset::QualRuleset(ruleset));
+                }
+
+                if !new_rulesets.is_empty() {
+                    ret.push(Ruleset::QualNestedRuleset(QualNestedRuleset(
+                        rules.0.clone(),
+                        new_rulesets,
+                    )))
+                }
+
+                ret
+            }
+            Ruleset::QualNestedRuleset(ruleset) => {
+                vec![Ruleset::QualNestedRuleset(QualNestedRuleset(
+                    ruleset.0.clone(),
+                    ruleset.1.iter().flat_map(|x| x.flatten_tree()).collect(),
+                ))]
+            }
+        }
+    }
+}
+
+type TreeSelectorRuleset<'a> = SelectorRuleset<'a, TreeRule<'a>>;
+
+impl<'a> ParseCss<'a> for TreeSelectorRuleset<'a> {
+    fn parse<E: ParseError<&'a str>>(input: &'a str) -> IResult<&'a str, Self, E> {
+        let (input, selector) = Selector::parse(input)?;
+        let (input, _) = tuple((comment0, tag("{"), sep0))(input)?;
+        let (input, rules) = many0(TreeRule::parse)(input)?;
+        let (input, _) = tuple((comment0, tag("}")))(input)?;
+        Ok((input, SelectorRuleset(selector, rules)))
+    }
+}
+
+impl<'a> TransformCss<Vec<TreeRuleset<'a>>> for TreeRuleset<'a> {
+    fn transform_each<F: FnMut(&mut Vec<TreeRuleset<'a>>)>(&mut self, f: &mut F) {
+        match self {
+            Ruleset::SelectorRuleset(ruleset) => {
+                for rule in ruleset.1.iter_mut() {
+                    rule.transform_each(f)
+                }
+            }
+            Ruleset::QualRule(_) => (),
+            Ruleset::QualRuleset(_) => (),
+            Ruleset::QualNestedRuleset(ruleset) => {
+                for rule in ruleset.1.iter_mut() {
+                    rule.transform_each(f)
+                }
+            }
+        }
+    }
+}
+
+impl<'a> TreeSelectorRuleset<'a> {
+    /// Flatten a TreeRuleset's SelectorRuleset into a `FlatRuleset`m erging any
+    /// nested rulesets which are not allowed in the latter.
+    pub fn flatten_tree(&self) -> Vec<Ruleset<'a, Rule<'a>>> {
+        let mut new_rules: Vec<Rule<'a>> = vec![];
+        let mut new_rulesets: Vec<FlatRuleset<'a>> = vec![];
+        for rule in self.1.iter() {
+            match rule {
+                TreeRule::Rule(rule) => new_rules.push(rule.clone()),
+                TreeRule::Ruleset(ruleset) => {
+                    if !new_rules.is_empty() {
+                        let ruleset = SelectorRuleset(self.0.clone(), new_rules);
+                        new_rulesets.push(Ruleset::SelectorRuleset(ruleset));
+                        new_rules = vec![];
+                    }
+
+                    let sub_rules = ruleset
+                        .flatten_tree()
+                        .into_iter()
+                        .map(|ruleset| self.join(ruleset));
+                    new_rulesets.extend(sub_rules)
+                }
+            }
+        }
+
+        if !new_rules.is_empty() {
+            let ruleset = SelectorRuleset(self.0.clone(), new_rules);
+            new_rulesets.push(Ruleset::SelectorRuleset(ruleset));
+        }
+
+        new_rulesets
+    }
+
+    /// Join a new `Ruleset` as an extension of self's selector.
+    fn join(&self, rhs: Ruleset<'a, Rule<'a>>) -> Ruleset<'a, Rule<'a>> {
+        match rhs {
+            Ruleset::SelectorRuleset(inner_ruleset) => {
+                let joined_selector = self.0.join(&inner_ruleset.0);
+                Ruleset::SelectorRuleset(SelectorRuleset(joined_selector, inner_ruleset.1))
+            }
+            ruleset => ruleset,
+        }
+    }
+}

package/src/ast.rs

@@ -0,0 +1,216 @@
+// ┌───────────────────────────────────────────────────────────────────────────┐
+// │                                                                           │
+// │  ██████╗ ██████╗  ██████╗   Copyright (C) 2022, The Prospective Company   │
+// │  ██╔══██╗██╔══██╗██╔═══██╗                                                │
+// │  ██████╔╝██████╔╝██║   ██║  This file is part of the Procss library,      │
+// │  ██╔═══╝ ██╔══██╗██║   ██║  distributed under the terms of the            │
+// │  ██║     ██║  ██║╚██████╔╝  Apache License 2.0.  The full license can     │
+// │  ╚═╝     ╚═╝  ╚═╝ ╚═════╝   be found in the LICENSE file.                 │
+// │                                                                           │
+// └───────────────────────────────────────────────────────────────────────────┘
+
+//! The complete AST structs for [`Css`] and [`Tree`]. These top-level structs
+//! are part of the [`crate::parse`] API, and their various components structs
+//! are necessary for writing any transformations on these between parsing and
+//! rendering.
+
+mod flat_ruleset;
+mod ruleset;
+mod selector;
+mod token;
+mod tree_ruleset;
+
+use std::cmp::Ordering;
+
+use nom::branch::alt;
+use nom::combinator::eof;
+use nom::error::ParseError;
+use nom::multi::many1;
+use nom::sequence::terminated;
+use nom::{IResult, Parser};
+
+pub use self::flat_ruleset::FlatRuleset;
+pub use self::ruleset::{QualNestedRuleset, QualRule, QualRuleset, Rule, Ruleset, SelectorRuleset};
+pub use self::selector::{Combinator, Selector, SelectorAttr, SelectorPath, SelectorTerm};
+pub use self::tree_ruleset::{TreeRule, TreeRuleset};
+use crate::parser::*;
+use crate::render::*;
+use crate::transform::*;
+use crate::transformers;
+
+/// A non-nested "flat" CSS representation, suitable for browser output. The
+/// [`Css`] AST is typically generated via the
+/// [`crate::ast::Tree::flatten_tree`] method.
+#[derive(Clone, Debug)]
+pub struct Css<'a>(pub Vec<FlatRuleset<'a>>);
+
+impl<'a> Css<'a> {
+    /// A mutable transform which walks this AST recursively, invoking `f` for
+    /// all nodes of type `T`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use procss::{ast, parse, RenderCss};
+    /// let mut css = parse("div{color: red;}").unwrap().flatten_tree();
+    /// css.transform(|rule: &mut ast::Rule| {
+    ///     rule.value = "green".into();
+    /// });
+    ///
+    /// assert_eq!(css.as_css_string(), "div{color:green;}");
+    /// ```
+    pub fn transform<T>(&mut self, mut f: impl FnMut(&mut T))
+    where
+        Self: TransformCss<T>,
+    {
+        self.transform_each(&mut f)
+    }
+
+    /// Iterate over the immediate children of this Tree (non-recursive).
+    pub fn iter(&self) -> impl Iterator<Item = &'_ FlatRuleset<'a>> {
+        self.0.iter()
+    }
+}
+
+impl<'a, T> TransformCss<T> for Css<'a>
+where
+    Ruleset<'a, Rule<'a>>: TransformCss<T>,
+{
+    fn transform_each<F: FnMut(&mut T)>(&mut self, f: &mut F) {
+        for rule in self.0.iter_mut() {
+            rule.transform_each(f);
+        }
+    }
+}
+
+impl<'a> RenderCss for Css<'a> {
+    fn render(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        for x in self.0.iter() {
+            x.render(f)?;
+        }
+
+        Ok(())
+    }
+}
+
+/// A nested CSS representation yielded from parsing. [`Tree`] also implements
+/// [`RenderCss`] if this is needed, though this output can't be read by
+/// browsers and is not identical to the input since whitespace has been
+/// discarded.
+#[derive(Clone, Debug)]
+pub struct Tree<'a>(pub Vec<TreeRuleset<'a>>);
+
+impl<'a> Tree<'a> {
+    /// Flatten a nested [`Tree`] into a [`Css`], or in other words, convert the
+    /// result of a parse into something that can be rendered.
+    pub fn flatten_tree(&self) -> Css<'a> {
+        let mut rules = self
+            .0
+            .iter()
+            .flat_map(|x| x.flatten_tree())
+            .collect::<Vec<_>>();
+
+        rules.sort_by(|x, y| match (x, y) {
+            (Ruleset::QualRule(_), Ruleset::QualRule(_)) => Ordering::Equal,
+            (Ruleset::QualRule(_), _) => Ordering::Less,
+            (_, Ruleset::QualRule(_)) => Ordering::Greater,
+            _ => Ordering::Equal,
+        });
+
+        let mut css = Css(rules);
+        transformers::flat_self(&mut css);
+        css
+    }
+
+    /// A mutable transform which walks this AST recursively, invoking `f` for
+    /// all nodes of type `T`.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use procss::{ast, parse, RenderCss};
+    /// let mut tree = parse("div{color: red;}").unwrap();
+    /// tree.transform(|rule: &mut ast::Rule| {
+    ///     rule.value = "green".into();
+    /// });
+    ///
+    /// let css = tree.flatten_tree().as_css_string();
+    /// assert_eq!(css, "div{color:green;}");
+    /// ```
+    pub fn transform<T>(&mut self, mut f: impl FnMut(&mut T))
+    where
+        Self: TransformCss<T>,
+    {
+        self.transform_each(&mut f)
+    }
+
+    /// Iterate over the immediate children of this Tree (non-recursive).
+    pub fn iter(&self) -> impl Iterator<Item = &'_ TreeRuleset<'a>> {
+        self.0.iter()
+    }
+}
+
+impl<'a> TransformCss<Rule<'a>> for Tree<'a> {
+    fn transform_each<F: FnMut(&mut Rule<'a>)>(&mut self, f: &mut F) {
+        for rule in self.0.iter_mut() {
+            rule.transform_each(f);
+        }
+    }
+}
+
+impl<'a> TransformCss<TreeRuleset<'a>> for Tree<'a> {
+    fn transform_each<F: FnMut(&mut TreeRuleset<'a>)>(&mut self, f: &mut F) {
+        for rule in self.0.iter_mut() {
+            f(rule);
+            match rule {
+                Ruleset::SelectorRuleset(ruleset) => {
+                    for rule in ruleset.1.iter_mut() {
+                        rule.transform_each(f)
+                    }
+                }
+                Ruleset::QualRule(_) => (),
+                Ruleset::QualRuleset(_) => (),
+                Ruleset::QualNestedRuleset(ruleset) => {
+                    for rule in ruleset.1.iter_mut() {
+                        rule.transform_each(f)
+                    }
+                }
+            }
+        }
+    }
+}
+
+impl<'a> TransformCss<Vec<TreeRuleset<'a>>> for Tree<'a> {
+    fn transform_each<F: FnMut(&mut Vec<TreeRuleset<'a>>)>(&mut self, f: &mut F) {
+        f(&mut self.0);
+        for rule in self.0.iter_mut() {
+            // f(rule);
+            rule.transform_each(f);
+        }
+    }
+}
+
+impl<'a> ParseCss<'a> for Tree<'a> {
+    fn parse<E>(input: &'a str) -> IResult<&'a str, Self, E>
+    where
+        E: ParseError<&'a str>,
+    {
+        let (input, _) = token::sep0(input)?;
+        let (input, x) = alt((
+            eof.map(|_| vec![]),
+            terminated(many1(terminated(TreeRuleset::parse, token::sep0)), eof),
+        ))(input)?;
+
+        Ok((input, Tree(x)))
+    }
+}
+
+impl<'a> RenderCss for Tree<'a> {
+    fn render(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        for x in self.0.iter() {
+            x.render(f)?;
+        }
+
+        Ok(())
+    }
+}

package/src/builder.rs

@@ -0,0 +1,189 @@
+// ┌───────────────────────────────────────────────────────────────────────────┐
+// │                                                                           │
+// │  ██████╗ ██████╗  ██████╗   Copyright (C) 2022, The Prospective Company   │
+// │  ██╔══██╗██╔══██╗██╔═══██╗                                                │
+// │  ██████╔╝██████╔╝██║   ██║  This file is part of the Procss library,      │
+// │  ██╔═══╝ ██╔══██╗██║   ██║  distributed under the terms of the            │
+// │  ██║     ██║  ██║╚██████╔╝  Apache License 2.0.  The full license can     │
+// │  ╚═╝     ╚═╝  ╚═╝ ╚═════╝   be found in the LICENSE file.                 │
+// │                                                                           │
+// └───────────────────────────────────────────────────────────────────────────┘
+
+use std::collections::HashMap;
+use std::path::PathBuf;
+
+use anyhow::Context;
+
+use crate::parser::{unwrap_parse_error, ParseCss};
+use crate::render::RenderCss;
+#[cfg(not(target_arch = "wasm32"))]
+use crate::utils::fs;
+#[cfg(feature = "iotest")]
+use crate::utils::IoTestFs;
+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,
+}
+
+/// The compiled output of a [`BuildCss`] collection, obtained from
+/// [`BuildCss::compile`].  
+pub struct CompiledCss<'a>(&'a BuildCss<'a>);
+
+/// An incremental build struct for compiling a project's CSS sources.
+///
+/// # Example
+///
+/// ```no_run
+/// let mut build = procss::BuildCss::new("./src");
+/// build.add_file("app.scss");
+/// build.compile().unwrap().write("./dist").unwrap();
+/// ```
+impl<'a> BuildCss<'a> {
+    /// Create a new [`BuildCss`] rooted at `rootdir`.
+    pub fn new<S: Into<String>>(rootdir: S) -> Self {
+        Self {
+            paths: Default::default(),
+            contents: Default::default(),
+            trees: Default::default(),
+            css: Default::default(),
+            rootdir: rootdir.into(),
+        }
+    }
+
+    /// 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);
+    }
+
+    /// 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);
+    }
+
+    /// Compile this [`BuildCss`] start-to-finish, applying all transforms along
+    /// the way.
+    pub fn compile(&'a mut self) -> anyhow::Result<CompiledCss<'a>> {
+        for (path, contents) in &self.contents {
+            let tree = ast::Tree::parse(contents);
+            let (_, tree) = tree.map_err(|err| unwrap_parse_error(contents, err))?;
+            self.trees.insert(path, tree);
+        }
+
+        let dep_trees = self.trees.clone();
+        for (path, tree) in self.trees.iter_mut() {
+            transformers::apply_import(&dep_trees)(tree);
+            transformers::apply_mixin(tree);
+            transformers::apply_var(tree);
+            self.css.insert(path, tree.flatten_tree());
+        }
+
+        for (path, css) in self.css.iter_mut() {
+            let srcdir = utils::join_paths(&self.rootdir, path);
+            transformers::inline_url(&srcdir.to_string_lossy())(css);
+            transformers::dedupe(css);
+        }
+
+        Ok(CompiledCss(self))
+    }
+}
+
+impl<'a> CompiledCss<'a> {
+    /// Write this struct's compiled data to `outdir`, preserving the relative
+    /// 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<()> {
+        for (outfile, css, path) in self.iter_files().flatten() {
+            let outdir = utils::join_paths(outdir, path);
+            fs::create_dir_all(outdir.clone()).unwrap_or_default();
+            fs::write(outdir.join(outfile), css)?;
+        }
+
+        Ok(())
+    }
+
+    /// Render this struct's compiled data in memory as a `String`, preserving
+    /// the relative subdirectory structure of the `input` sources passed to
+    /// [`BuildCss::add`], relative to `outdir`.
+    pub fn as_strings(&self) -> anyhow::Result<HashMap<String, String>> {
+        let mut results = HashMap::default();
+        for (outfile, css, _) in self.iter_files().flatten() {
+            results.insert(outfile, css).unwrap_or_default();
+        }
+
+        Ok(results)
+    }
+
+    fn iter_files(&self) -> impl Iterator<Item = anyhow::Result<(String, String, &'_ str)>> {
+        self.0.css.iter().map(|(path, css)| {
+            let outpath = PathBuf::from(path);
+            let outfile = format!(
+                "{}.css",
+                outpath
+                    .file_prefix()
+                    .context("No Prefix")?
+                    .to_string_lossy()
+            );
+
+            Ok((outfile, css.as_css_string(), *path))
+        })
+    }
+}
+
+#[cfg(all(test, feature = "iotest"))]
+mod tests {
+    use std::cell::RefCell;
+    use std::path::*;
+    use std::rc::Rc;
+
+    use super::*;
+
+    #[test]
+    fn test_simple_build() {
+        let outputs = Rc::new(RefCell::new(vec![]));
+        let infiles = Rc::new(RefCell::new(vec![]));
+        let outfiles = Rc::new(RefCell::new(vec![]));
+
+        let ctx = fs::read_to_string_context();
+        let infiles2 = infiles.clone();
+        ctx.expect().times(1).returning_st(move |x: &Path| {
+            infiles2.borrow_mut().push(x.to_string_lossy().to_string());
+            Ok("div{.open{color:green}}".to_owned())
+        });
+
+        let ctx = fs::create_dir_all_context();
+        ctx.expect().times(1).returning(|_: PathBuf| Ok(()));
+
+        let ctx = fs::write_context();
+        let outputs2 = outputs.clone();
+        let outfiles2 = outfiles.clone();
+        ctx.expect().returning_st(move |x: PathBuf, y: String| {
+            outfiles2.borrow_mut().push(x.to_string_lossy().to_string());
+            outputs2.borrow_mut().push(y);
+            Ok(())
+        });
+
+        let mut build = BuildCss::new("./src".to_owned());
+        build.add_file("app/component.scss");
+        build.compile().unwrap().write("./dist").unwrap();
+
+        let outputs = outputs.borrow().clone();
+        assert_eq!(outputs, vec!["div .open{color:green;}".to_owned()]);
+        let infiles = infiles.borrow().clone();
+        assert_eq!(infiles, vec!["./src/app/component.scss".to_owned()]);
+        let outfiles = outfiles.borrow().clone();
+        assert_eq!(outfiles, vec!["./dist/app/component.css".to_owned()])
+    }
+}