support for manual format specification, better autodetection in the cli

mgree · mgree · commit d441958d8741 · 2021-06-20T21:08:09.000-04:00
diff --git a/json/empty.json b/json/empty.json
@@ -0,0 +1 @@
+{}
diff --git a/json/single.json b/json/single.json
@@ -0,0 +1 @@
+{"onlyone":"highlander"}
diff --git a/src/format.rs b/src/format.rs
@@ -17,6 +17,43 @@ pub enum Format {
     Toml,
 }
 
+pub const POSSIBLE_FORMATS: &[&str] = &["json", "toml"];
+
+impl std::fmt::Display for Format {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+        write!(
+            f,
+            "{}",
+            match self {
+                Format::Json => "json",
+                Format::Toml => "toml",
+            }
+        )
+    }
+}
+
+#[derive(Debug)]
+pub enum ParseFormatError {
+    NoSuchFormat(String),
+    NoFormatProvided,
+}
+
+impl FromStr for Format {
+    type Err = ParseFormatError;
+
+    fn from_str(s: &str) -> Result<Self, ParseFormatError> {
+        let s = s.trim().to_lowercase();
+
+        if s == "json" {
+            Ok(Format::Json)
+        } else if s == "toml" {
+            Ok(Format::Toml)
+        } else {
+            Err(ParseFormatError::NoSuchFormat(s))
+        }
+    }
+}
+
 impl Format {
     /// Generates a filesystem `fs`, reading from `reader` according to a
     /// particular `Config`.
diff --git a/src/fs.rs b/src/fs.rs
@@ -184,7 +184,7 @@ impl FS {
         info!("called");
         debug!("{:?}", self.inodes);
 
-        if !self.synced.get() && !self.dirty.get() {
+        if self.synced.get() && !self.dirty.get() {
             info!("skipping sync; already synced and not dirty");
             return;
         }
diff --git a/src/main.rs b/src/main.rs
@@ -3,7 +3,7 @@ use std::path::PathBuf;
 
 use clap::{App, Arg};
 
-use tracing::{error, info, warn};
+use tracing::{debug, error, info, warn};
 use tracing_subscriber::prelude::*;
 use tracing_subscriber::{filter::EnvFilter, fmt};
 
@@ -103,6 +103,22 @@ fn main() {
                 .overrides_with("OUTPUT")            
                 .overrides_with("NOOUTPUT")
         )
+        .arg(
+            Arg::with_name("SOURCE_FORMAT")
+                .help("Specify the source format explicitly (by default, automatically inferred from filename extension)")
+                .long("source")
+                .short("s")
+                .takes_value(true)
+                .possible_values(format::POSSIBLE_FORMATS)
+        )
+        .arg(
+            Arg::with_name("TARGET_FORMAT")
+                .help("Specify the target format explicitly (by default, automatically inferred from filename extension)")
+                .long("target")
+                .short("t")
+                .takes_value(true)
+                .possible_values(format::POSSIBLE_FORMATS)
+        )
         .arg(
             Arg::with_name("MOUNT")
                 .help("Sets the mountpoint")
@@ -228,14 +244,90 @@ fn main() {
     } else {
         Output::Stdout
     };
-    let reader: Box<dyn std::io::Read> = if input_source == "-" {
-        Box::new(std::io::stdin())
-    } else {
-        let file = std::fs::File::open(input_source).unwrap_or_else(|e| {
-            error!("Unable to open {} for JSON input: {}", input_source, e);
-            std::process::exit(1);
-        });
-        Box::new(file)
+
+    // try to autodetect the input format.
+    //
+    // first see if it's specified and parses okay.
+    //
+    // then see if we can pull it out of the extension.
+    //
+    // then give up and use json
+    config.input_format = match args
+        .value_of("SOURCE_FORMAT")
+        .ok_or(format::ParseFormatError::NoFormatProvided)
+        .and_then(|s| s.parse::<Format>())
+    {
+        Ok(source_format) => source_format,
+        Err(e) => {
+            match e {
+                format::ParseFormatError::NoSuchFormat(s) => {
+                    warn!("Unrecognized format '{}', inferring from input.", s)
+                }
+                format::ParseFormatError::NoFormatProvided => {
+                    debug!("Inferring format from input.")
+                }
+            };
+
+            match Path::new(input_source)
+                .extension() // will fail for STDIN, no worries
+                .map(|s| s.to_str().expect("utf8 filename").to_lowercase())
+            {
+                Some(s) => match s.parse::<Format>() {
+                    Ok(format) => format,
+                    Err(_) => {
+                        warn!("Unrecognized format {}, defaulting to JSON.", s);
+                        Format::Json
+                    }
+                },
+                None => Format::Json,
+            }
+        }
+    };
+
+    // try to autodetect the input format.
+    //
+    // first see if it's specified and parses okay.
+    //
+    // then see if we can pull it out of the extension (if specified)
+    //
+    // then give up and use the input format
+    config.output_format = match args
+        .value_of("TARGET_FORMAT")
+        .ok_or(format::ParseFormatError::NoFormatProvided)
+        .and_then(|s| s.parse::<Format>())
+    {
+        Ok(target_format) => target_format,
+        Err(e) => {
+            match e {
+                format::ParseFormatError::NoSuchFormat(s) => {
+                    warn!(
+                        "Unrecognized format '{}', inferring from input and output.",
+                        s
+                    )
+                }
+                format::ParseFormatError::NoFormatProvided => {
+                    debug!("Inferring output format from input.")
+                }
+            };
+
+            match args
+                .value_of("OUTPUT")
+                .and_then(|s| Path::new(s).extension())
+                .and_then(|s| s.to_str())
+            {
+                Some(s) => match s.parse::<Format>() {
+                    Ok(format) => format,
+                    Err(_) => {
+                        warn!(
+                            "Unrecognized format {}, defaulting to input format '{}'.",
+                            s, config.input_format
+                        );
+                        config.input_format
+                    }
+                },
+                None => config.input_format,
+            }
+        }
     };
 
     let mut options = vec![MountOption::FSName(input_source.into())];
@@ -246,26 +338,16 @@ fn main() {
         options.push(MountOption::RO);
     }
 
-    // try to autodetect the input format... poorly
-    config.input_format = match Path::new(input_source)
-        .extension()
-        .map(|s| s.to_str().expect("utf8 filename").to_lowercase())
-    {
-        Some(s) => {
-            if &s == "json" {
-                Format::Json
-            } else if &s == "toml" {
-                Format::Toml
-            } else {
-                warn!("Unrecognized format {}, defaulting to JSON.", s);
-                Format::Json
-            }
-        }
-        None => Format::Json,
-    };
-    config.output_format = config.input_format;
-
     let input_format = config.input_format;
+    let reader: Box<dyn std::io::Read> = if input_source == "-" {
+        Box::new(std::io::stdin())
+    } else {
+        let file = std::fs::File::open(input_source).unwrap_or_else(|e| {
+            error!("Unable to open {} for JSON input: {}", input_source, e);
+            std::process::exit(1);
+        });
+        Box::new(file)
+    };
     let fs = input_format.load(reader, config);
 
     info!("mounting on {:?} with options {:?}", mount_point, options);
diff --git a/tests/json_to_toml.sh b/tests/json_to_toml.sh
@@ -0,0 +1,29 @@
+#!/bin/sh
+
+fail() {
+    echo FAILED: $1
+    if [ "$MNT" ]
+    then
+        cd
+        umount "$MNT"
+        rmdir "$MNT"
+        rm "$TGT"
+    fi
+    exit 1
+}
+
+MNT=$(mktemp -d)
+TGT=$(mktemp)
+
+ffs --source json --target toml -o "$TGT" "$MNT" ../json/single.json &
+PID=$!
+sleep 2
+umount "$MNT" || fail unmount1    
+sleep 1
+kill -0 $PID >/dev/null 2>&1 && fail process1
+
+diff "$TGT" ../toml/single.toml || fail diff
+
+rmdir "$MNT" || fail mount
+rm "$TGT"
+
diff --git a/tests/override_infer.sh b/tests/override_infer.sh
@@ -0,0 +1,32 @@
+#!/bin/sh
+
+fail() {
+    echo FAILED: $1
+    if [ "$MNT" ]
+    then
+        cd
+        umount "$MNT"
+        rmdir "$MNT"
+        rm "$SRC" "$TGT"
+    fi
+    exit 1
+}
+
+MNT=$(mktemp -d)
+SRC=$(mktemp)
+TGT=$(mktemp)
+
+cp ../toml/single.toml "$SRC"
+
+ffs --source toml --target json -o "$TGT" "$MNT" "$SRC" &
+PID=$!
+sleep 2
+umount "$MNT" || fail unmount1    
+sleep 1
+kill -0 $PID >/dev/null 2>&1 && fail process1
+
+diff "$TGT" ../json/single.json || fail diff
+
+rmdir "$MNT" || fail mount
+rm "$SRC" "$TGT"
+
diff --git a/tests/toml_to_json.sh b/tests/toml_to_json.sh
@@ -0,0 +1,29 @@
+#!/bin/sh
+
+fail() {
+    echo FAILED: $1
+    if [ "$MNT" ]
+    then
+        cd
+        umount "$MNT"
+        rmdir "$MNT"
+        rm "$TGT"
+    fi
+    exit 1
+}
+
+MNT=$(mktemp -d)
+TGT=$(mktemp)
+
+ffs --source toml --target json -o "$TGT" "$MNT" ../toml/single.toml &
+PID=$!
+sleep 2
+umount "$MNT" || fail unmount1    
+sleep 1
+kill -0 $PID >/dev/null 2>&1 && fail process1
+
+diff "$TGT" ../json/single.json || fail diff
+
+rmdir "$MNT" || fail mount
+rm "$TGT"
+
diff --git a/toml/empty.toml b/toml/empty.toml
diff --git a/toml/single.toml b/toml/single.toml
@@ -0,0 +1 @@
+onlyone = "highlander"

Original file line number	Diff line number	Diff line change
`@@ -184,7 +184,7 @@ impl FS {`
`184`	`184`	`info!("called");`
`185`	`185`	`debug!("{:?}", self.inodes);`
`186`	`186`
`187`		`- if !self.synced.get() && !self.dirty.get() {`
	`187`	`+ if self.synced.get() && !self.dirty.get() {`
`188`	`188`	`info!("skipping sync; already synced and not dirty");`
`189`	`189`	`return;`
`190`	`190`	`}`