support stdin, error codes

Author: yoav-lavi

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [v0.14.0] - 2022-04-11
+
+### Features
+
+- Support stdin in CLI
+- Emit proper exit codes on specific errors
+
 ## [v0.13.10] - 2022-03-11
 
 ### Fixes

Cargo.lock

@@ -17,6 +17,8 @@ colored = "2.0.0"
 thiserror = "1.0"
 anyhow = "1.0"
 melody_compiler = { version = "0.13.10", path = "../melody_compiler" }
+atty = "0.2"
+exitcode = "1.1.2"
 
 [dev-dependencies]
 assert_cmd = "2.0.4"

crates/melody_cli/Cargo.toml

@@ -1,21 +1,36 @@
+use crate::consts::STDIN_MARKER;
 use crate::errors::CliError;
 use crate::output::print_output;
 use crate::utils::write_output_to_file;
 use melody_compiler::compiler;
 use std::fs::read_to_string;
+use std::io::{self, Read};
 
-pub fn compile_file(
-    input_file_path: String,
-    output_file_path: Option<String>,
-) -> anyhow::Result<()> {
-    let source = read_to_string(input_file_path.clone())
-        .map_err(|_| CliError::ReadFileError(input_file_path))?;
+fn read_stdin() -> anyhow::Result<String> {
+    let mut buffer = String::new();
+    io::stdin()
+        .read_to_string(&mut buffer)
+        .map_err(|_| CliError::ReadStdinError)?;
+    Ok(buffer)
+}
+
+fn read_file(path: &str) -> anyhow::Result<String> {
+    let contents = read_to_string(path).map_err(|_| CliError::ReadFileError(path.to_owned()))?;
+    Ok(contents)
+}
+
+pub fn compile_file(input_file_path: &str, output_file_path: Option<String>) -> anyhow::Result<()> {
+    let source = if input_file_path == STDIN_MARKER {
+        read_stdin()?
+    } else {
+        read_file(input_file_path)?
+    };
 
     let compiler_output =
         compiler(&source).map_err(|error| CliError::ParseError(error.to_string()))?;
 
     match output_file_path {
-        Some(output_file_path) => write_output_to_file(output_file_path, compiler_output)?,
+        Some(output_file_path) => write_output_to_file(&output_file_path, &compiler_output)?,
         None => print_output(&compiler_output),
     };
 

crates/melody_cli/src/compile.rs

@@ -1 +1,2 @@
 pub(crate) const COMMAND_MARKER: &str = ":";
+pub(crate) const STDIN_MARKER: &str = "-";

crates/melody_cli/src/consts.rs

@@ -1,9 +1,11 @@
+use crate::output::report_unhandled_error;
+use crate::{report_error, report_info, Args};
+use clap::CommandFactory;
+use std::process;
 use thiserror::Error;
 
 #[derive(Error, Debug)]
 pub enum CliError {
-    #[error("invalid arguments, please supply a path argument or use --repl")]
-    MissingPath,
     #[error("unable read file at path {0}")]
     ReadFileError(String),
     #[error("{0}")]
@@ -12,4 +14,68 @@ pub enum CliError {
     WriteFileError(String),
     #[error("unable to read input")]
     ReadInputError,
+    #[error("unable to read stdin")]
+    ReadStdinError,
+    #[error("repl argument supplied with piped input or output")]
+    ReplWithPipe,
+    #[error("No input file supplied and no input piped.\nTry adding a path argument: 'melody ./file.mdy'")]
+    StdinWithoutPipe,
+}
+
+#[derive(Debug)]
+pub enum ErrorKind {
+    Info,
+    Error,
+}
+
+impl CliError {
+    pub fn kind(&self) -> ErrorKind {
+        match self {
+            CliError::StdinWithoutPipe => ErrorKind::Info,
+            _ => ErrorKind::Error,
+        }
+    }
+
+    fn report(&self) {
+        match self.kind() {
+            ErrorKind::Info => {
+                report_info(&self.to_string());
+                println!();
+                // silently ignoring an error when printing help
+                // as we're already handling an error and have printed info
+                let _print_result = Args::command().print_help();
+            }
+            ErrorKind::Error => {
+                report_error(&self.to_string());
+            }
+        };
+    }
+
+    fn to_exit_code(&self) -> exitcode::ExitCode {
+        match self {
+            CliError::WriteFileError(_)
+            | CliError::ReadFileError(_)
+            | CliError::ReadInputError
+            | CliError::ReadStdinError => exitcode::IOERR,
+            CliError::ParseError(_) => exitcode::DATAERR,
+            CliError::ReplWithPipe => exitcode::USAGE,
+            CliError::StdinWithoutPipe => exitcode::NOINPUT,
+        }
+    }
+}
+
+pub fn handle_error(error: &anyhow::Error) -> ! {
+    let cli_error = error.downcast_ref::<CliError>();
+
+    let cli_error = match cli_error {
+        Some(cli_error) => cli_error,
+        None => {
+            report_unhandled_error(&error.to_string());
+            process::exit(exitcode::SOFTWARE);
+        }
+    };
+
+    cli_error.report();
+
+    process::exit(cli_error.to_exit_code())
 }

crates/melody_cli/src/errors.rs

@@ -14,24 +14,20 @@ mod utils;
 use clap::Parser;
 use colored::control::{ShouldColorize, SHOULD_COLORIZE};
 use compile::compile_file;
-use errors::CliError;
-use output::report_error;
+use consts::STDIN_MARKER;
+use errors::{handle_error, CliError};
+use output::{report_error, report_info};
 use repl::repl;
 use std::process;
-use types::{Args, ExitCode};
+use types::{Args, Streams};
 
 fn main() {
     ShouldColorize::from_env();
 
-    let exit_code = match try_main() {
-        Ok(_) => ExitCode::Ok,
-        Err(error) => {
-            report_error(&error.to_string());
-            ExitCode::Error
-        }
+    match try_main() {
+        Ok(_) => process::exit(exitcode::OK),
+        Err(error) => handle_error(&error),
     };
-
-    process::exit(exit_code.into());
 }
 
 fn try_main() -> anyhow::Result<()> {
@@ -46,13 +42,28 @@ fn try_main() -> anyhow::Result<()> {
         SHOULD_COLORIZE.set_override(false);
     }
 
+    let input_file_path = input_file_path.unwrap_or_else(|| STDIN_MARKER.to_owned());
+
+    argument_env_validation(start_repl, &input_file_path)?;
+
     if start_repl {
         return repl();
     }
 
-    let input_file_path = input_file_path.ok_or(CliError::MissingPath)?;
+    compile_file(&input_file_path, output_file_path)?;
 
-    compile_file(input_file_path, output_file_path)?;
+    Ok(())
+}
+
+fn argument_env_validation(start_repl: bool, input_file_path: &str) -> anyhow::Result<()> {
+    let streams = Streams::new();
+
+    if streams.any_pipe() && start_repl {
+        return Err(CliError::ReplWithPipe.into());
+    }
+    if !streams.stdin && input_file_path == STDIN_MARKER {
+        return Err(CliError::StdinWithoutPipe.into());
+    }
 
     Ok(())
 }

crates/melody_cli/src/main.rs

@@ -99,7 +99,22 @@ pub fn report_source() {
 }
 
 pub fn report_error(error: &str) {
-    eprintln!("{}", format!("Error: {}", error).bright_red(),);
+    eprintln!("{}", format!("Error: {}", error).bright_red());
+}
+
+pub fn report_unhandled_error(error: &str) {
+    eprintln!(
+        "{}",
+        format!(
+            "An unhandled error occured.\nThis is a bug, please open an issue.\n\nCause: {}",
+            error
+        )
+        .bright_red()
+    );
+}
+
+pub fn report_info(error: &str) {
+    eprintln!("{}", error.bright_blue());
 }
 
 pub fn report_repl_error(error: &str) {

crates/melody_cli/src/output.rs

@@ -1,23 +1,13 @@
+use atty::Stream;
 use clap::Parser;
 
-pub enum ExitCode {
-    Ok,
-    Error,
-}
-
-impl From<ExitCode> for i32 {
-    fn from(exit_code: ExitCode) -> Self {
-        match exit_code {
-            ExitCode::Ok => 0,
-            ExitCode::Error => 1,
-        }
-    }
-}
-
 #[derive(Parser, Debug)]
 #[clap(about, version, author)]
 pub struct Args {
-    #[clap(value_name = "INPUT_FILE_PATH", help = "Read from a file")]
+    #[clap(
+        value_name = "INPUT_FILE_PATH",
+        help = "Read from a file. Use '-' and or pipe input to read from stdin"
+    )]
     pub input_file_path: Option<String>,
     #[clap(
         short = 'o',
@@ -41,3 +31,22 @@ pub enum NextLoop {
     Continue,
     Exit,
 }
+
+pub struct Streams {
+    pub stdin: bool,
+    pub stdout: bool,
+    // pub stderr: bool,
+}
+
+impl Streams {
+    pub fn new() -> Self {
+        Self {
+            stdin: !atty::is(Stream::Stdin),
+            stdout: !atty::is(Stream::Stdout),
+            // stderr: !atty::is(Stream::Stderr),
+        }
+    }
+    pub fn any_pipe(&self) -> bool {
+        self.stdin || self.stdout
+    }
+}

crates/melody_cli/src/types.rs

@@ -10,12 +10,9 @@ pub fn read_input() -> io::Result<String> {
     Ok(String::from(input.trim_end()))
 }
 
-pub fn write_output_to_file(
-    output_file_path: String,
-    compiler_output: String,
-) -> anyhow::Result<()> {
-    write(&output_file_path, compiler_output)
-        .map_err(|_| CliError::WriteFileError(output_file_path))?;
+pub fn write_output_to_file(output_file_path: &str, compiler_output: &str) -> anyhow::Result<()> {
+    write(output_file_path, compiler_output)
+        .map_err(|_| CliError::WriteFileError(output_file_path.to_owned()))?;
 
     Ok(())
 }

crates/melody_cli/src/utils.rs

@@ -8,7 +8,7 @@ use unindent::unindent;
 
 #[test]
 #[cfg_attr(miri, ignore)]
-fn cli_stdout_test() -> anyhow::Result<()> {
+fn cli_file_stdout_test() -> anyhow::Result<()> {
     let mut command = Command::cargo_bin("melody")?;
     let melody_file = NamedTempFile::new("test.mdy")?;
 
@@ -48,6 +48,44 @@ fn cli_stdout_test() -> anyhow::Result<()> {
     Ok(())
 }
 
+#[test]
+#[cfg_attr(miri, ignore)]
+fn cli_stdin_stdout_test() -> anyhow::Result<()> {
+    let mut command = Command::cargo_bin("melody")?;
+
+    let source = r#"
+    some of "a";
+    some of "b";
+    "#;
+
+    let expected_output = "a+b+";
+
+    command
+        .write_stdin(source)
+        .arg("-")
+        .assert()
+        .stdout(expected_output);
+
+    Ok(())
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn cli_stdin_stdout_no_hyphen_test() -> anyhow::Result<()> {
+    let mut command = Command::cargo_bin("melody")?;
+
+    let source = r#"
+    some of "a";
+    some of "b";
+    "#;
+
+    let expected_output = "a+b+";
+
+    command.write_stdin(source).assert().stdout(expected_output);
+
+    Ok(())
+}
+
 #[test]
 #[cfg_attr(miri, ignore)]
 fn cli_file_test() -> anyhow::Result<()> {