Allow templating with stdin/stdout (#24)

Author: ellsclytn

Makefile

@@ -28,6 +28,7 @@ test: $(EXECFILE)
 	rm -rf $(TEST_DEST_DIR)
 	mkdir $(TEST_DEST_DIR)
 	./$(EXECFILE) $(TEST_RULES) $(TEST_DOTFILES) $(TEST_DEST_DIR) $(TEST_IGNORE_ARG); \
+	cat $(TEST_DOTFILES)/template | ./$(EXECFILE) $(TEST_RULES) > $(TEST_DEST_DIR)/stdout; \
 	diff $(DIFF_FLAGS) $(TEST_DEST_DIR) $(TEST_EXPECTED_DIR)
 	if [ ! -x "$(TEST_DEST_DIR)/binary_file" ]; then \
 		@echo "Expected binary_file to be executable."; \

README.md

@@ -2,12 +2,12 @@
 A small, portable Rust program intended for templating dotfiles across multiple systems.
 
 ## Purpose
-Storing dotfiles in git repositories allows them to be shared across multiple computers, but this becomes problematic once systems require slightly different configurations. Laptops require battery indicators and WiFi utilities, HiDPI displays use larger fonts... `dot-templater` intends to solve these problems by making it simple to change values or enable/disable chunks of configuration in any file.
+Storing dotfiles in git repositories allows them to be shared across multiple computers, but this becomes problematic once systems require slightly different configurations. Laptops require battery indicators and WiFi utilities, HiDPI displays use larger fonts... `dot-templater` intends to solve these problems by making it simple to change values or enable/disable chunks of configuration in any file, or content from stdin.
 
 ## Features
-* Make string substitutions in files according to configured key/value pairs.
+* Make string substitutions in files/content according to configured key/value pairs.
 * Use output from arbitrary shell commands in templated dotfiles (e.g. for passwords with GNU Pass).
-* Toggle chunks of files per feature flags.
+* Toggle chunks of files/content per feature flags.
 * Copy binary files without templating.
 * Preserve file permissions.
 * Perform a dry-run to compare expected output against existing files.
@@ -30,6 +30,12 @@ dot-templater CONFIG SRC_DIR DEST_DIR
 
 Copies files from `SRC_DIR` to `DEST_DIR` according to rules in `CONFIG`.
 
+```
+dot-templater CONFIG
+```
+
+Templates content from stdin to stdout according to rules in `CONFIG`.
+
 ```
 dot-templater --diff CONFIG SRC_DIR DEST_DIR
 ```

src/lib.rs

@@ -84,12 +84,14 @@ impl Config {
         }
     }
 
-    fn template_file(&self, source: &Path) -> Result<String, Box<dyn Error>> {
-        let source = BufReader::new(File::open(source)?);
+    fn template_lines<T: BufRead>(
+        &self,
+        lines: std::io::Lines<T>,
+    ) -> Result<String, Box<dyn Error>> {
         let mut feature_stack = Vec::new();
         let mut templated_output = String::new();
 
-        for line in source.lines() {
+        for line in lines {
             let mut line = line?;
             match Config::get_feature(&line) {
                 Some(feature) => match feature_stack.last() {
@@ -115,6 +117,12 @@ impl Config {
         Ok(templated_output)
     }
 
+    fn template_file(&self, source: &Path) -> Result<String, Box<dyn Error>> {
+        let source = BufReader::new(File::open(source)?);
+
+        Ok(self.template_lines(source.lines())?)
+    }
+
     fn get_feature(line: &str) -> Option<&str> {
         let re = Regex::new("^\\s*### .*$").expect("fixed regex always valid");
         if re.is_match(line) {
@@ -141,25 +149,33 @@ pub enum ConfigValue {
 
 pub struct Arguments<'a> {
     pub rules: &'a str,
-    pub source: &'a str,
-    pub dest: &'a str,
     pub diff: Mode,
+    pub source: Option<&'a str>,
+    pub dest: Option<&'a str>,
     pub ignore: Vec<&'a str>,
 }
 
 impl<'a> Arguments<'a> {
     pub fn new(args: &'a clap::ArgMatches) -> Self {
         let rules = args.value_of("CONFIG").expect("CONFIG is required");
-        let mut source = args.value_of("SRC_DIR").expect("SRC_DIR is required");
-        let mut dest = args.value_of("DEST_DIR").expect("DEST_DIR is required");
+        let mut source = args.value_of("SRC_DIR");
+        let mut dest = args.value_of("DEST_DIR");
         let diff = if args.is_present("diff") {
             Mode::Diff
         } else {
             Mode::Template
         };
 
-        source = Self::trim_trailing_slash(&source);
-        dest = Self::trim_trailing_slash(&dest);
+        source = match &source {
+            None => None,
+            Some(s) => Some(Self::trim_trailing_slash(&s)),
+        };
+
+        dest = match &dest {
+            None => None,
+            Some(s) => Some(Self::trim_trailing_slash(&s)),
+        };
+
         let ignore = match args.values_of("ignore") {
             Some(value) => value.collect(),
             None => vec![],
@@ -237,6 +253,15 @@ fn diff_files(config: &Config, source: &Path, dest: &Path) -> Result<(), Box<dyn
     Ok(())
 }
 
+pub fn template_lines(
+    config: &Config,
+    lines: std::io::Lines<std::io::StdinLock>,
+) -> Result<(), Box<dyn Error>> {
+    print!("{}", config.template_lines(lines)?);
+
+    Ok(())
+}
+
 pub fn template(
     config: &Config,
     source_dir: &str,

src/main.rs

@@ -9,6 +9,7 @@ use dot_templater::Config;
 use std::fs::File;
 use std::io::BufRead;
 use std::io::BufReader;
+use std::io::{self};
 use std::process;
 
 fn main() {
@@ -24,13 +25,11 @@ fn main() {
         .arg(
             Arg::with_name("SRC_DIR")
                 .help("Path to directory containing template files")
-                .required(true)
                 .index(2),
         )
         .arg(
             Arg::with_name("DEST_DIR")
                 .help("Path to generate output files in")
-                .required(true)
                 .index(3),
         )
         .arg(
@@ -74,9 +73,16 @@ fn main() {
         process::exit(1);
     });
 
-    dot_templater::template(&config, &args.source, &args.dest, args.diff, args.ignore)
-        .unwrap_or_else(|err| {
-            eprintln!("Error while performing templating: {}", err);
-            process::exit(1);
-        });
+    if args.source.is_some() && args.dest.is_some() {
+        let source = &args.source.unwrap();
+        let dest = &args.dest.unwrap();
+
+        dot_templater::template(&config, &source, &dest, args.diff, args.ignore)
+    } else {
+        dot_templater::template_lines(&config, io::stdin().lock().lines())
+    }
+    .unwrap_or_else(|err| {
+        eprintln!("Error while performing templating: {}", err);
+        process::exit(1);
+    });
 }