rhg: print error message when argument parsing fails

Differential Revision: https://phab.mercurial-scm.org/D8956

rust/rhg/src/main.rs

@@ -1,57 +1,58 b''
 use clap::App;
 use clap::AppSettings;
 use clap::SubCommand;
 
 mod commands;
 mod error;
 mod exitcode;
 mod ui;
 use commands::Command;
 
 fn main() {
     let mut app = App::new("rhg")
         .setting(AppSettings::AllowInvalidUtf8)
         .setting(AppSettings::SubcommandRequired)
         .setting(AppSettings::VersionlessSubcommands)
         .version("0.0.1")
         .subcommand(
             SubCommand::with_name("root").about(commands::root::HELP_TEXT),
         )
         .subcommand(
             SubCommand::with_name("files").about(commands::files::HELP_TEXT),
         );
 
-    let matches = app.clone().get_matches_safe().unwrap_or_else(|_| {
+    let matches = app.clone().get_matches_safe().unwrap_or_else(|err| {
+        let _ = ui::Ui::new().writeln_stderr_str(&err.message);
         std::process::exit(exitcode::UNIMPLEMENTED_COMMAND)
     });
 
     let ui = ui::Ui::new();
 
     let command_result = match matches.subcommand_name() {
         Some(name) => match name {
             "root" => commands::root::RootCommand::new().run(&ui),
             "files" => commands::files::FilesCommand::new().run(&ui),
             _ => std::process::exit(exitcode::UNIMPLEMENTED_COMMAND),
         },
         _ => {
             match app.print_help() {
                 Ok(_) => std::process::exit(exitcode::OK),
                 Err(_) => std::process::exit(exitcode::ABORT),
             };
         }
     };
 
     match command_result {
         Ok(_) => std::process::exit(exitcode::OK),
         Err(e) => {
             let message = e.get_error_message_bytes();
             if let Some(msg) = message {
                 match ui.write_stderr(&msg) {
                     Ok(_) => (),
                     Err(_) => std::process::exit(exitcode::ABORT),
                 };
             };
             e.exit()
         }
     }
 }

rust/rhg/src/ui.rs

@@ -1,100 +1,105 b''
 use std::io;
 use std::io::{ErrorKind, Write};
 
 #[derive(Debug)]
 pub struct Ui {
     stdout: std::io::Stdout,
     stderr: std::io::Stderr,
 }
 
 /// The kind of user interface error
 pub enum UiError {
     /// The standard output stream cannot be written to
     StdoutError(io::Error),
     /// The standard error stream cannot be written to
     StderrError(io::Error),
 }
 
 /// The commandline user interface
 impl Ui {
     pub fn new() -> Self {
         Ui {
             stdout: std::io::stdout(),
             stderr: std::io::stderr(),
         }
     }
 
     /// Returns a buffered handle on stdout for faster batch printing
     /// operations.
     pub fn stdout_buffer(&self) -> StdoutBuffer<std::io::StdoutLock> {
         StdoutBuffer::new(self.stdout.lock())
     }
 
     /// Write bytes to stdout
     pub fn write_stdout(&self, bytes: &[u8]) -> Result<(), UiError> {
         let mut stdout = self.stdout.lock();
 
         stdout.write_all(bytes).or_else(handle_stdout_error)?;
 
         stdout.flush().or_else(handle_stdout_error)
     }
 
     /// Write bytes to stderr
     pub fn write_stderr(&self, bytes: &[u8]) -> Result<(), UiError> {
         let mut stderr = self.stderr.lock();
 
         stderr.write_all(bytes).or_else(handle_stderr_error)?;
 
         stderr.flush().or_else(handle_stderr_error)
     }
+
+    /// Write string line to stderr
+    pub fn writeln_stderr_str(&self, s: &str) -> Result<(), UiError> {
+        self.write_stderr(&format!("{}\n", s).as_bytes())
+    }
 }
 
 /// A buffered stdout writer for faster batch printing operations.
 pub struct StdoutBuffer<W: Write> {
     buf: io::BufWriter<W>,
 }
 
 impl<W: Write> StdoutBuffer<W> {
     pub fn new(writer: W) -> Self {
         let buf = io::BufWriter::new(writer);
         Self { buf }
     }
 
     /// Write bytes to stdout buffer
     pub fn write_all(&mut self, bytes: &[u8]) -> Result<(), UiError> {
         self.buf.write_all(bytes).or_else(handle_stdout_error)
     }
 
     /// Flush bytes to stdout
     pub fn flush(&mut self) -> Result<(), UiError> {
         self.buf.flush().or_else(handle_stdout_error)
     }
 }
 
 /// Sometimes writing to stdout is not possible, try writing to stderr to
 /// signal that failure, otherwise just bail.
 fn handle_stdout_error(error: io::Error) -> Result<(), UiError> {
     if let ErrorKind::BrokenPipe = error.kind() {
         // This makes `| head` work for example
         return Ok(());
     }
     let mut stderr = io::stderr();
 
     stderr
         .write_all(&[b"abort: ", error.to_string().as_bytes(), b"\n"].concat())
         .map_err(UiError::StderrError)?;
 
     stderr.flush().map_err(UiError::StderrError)?;
 
     Err(UiError::StdoutError(error))
 }
 
 /// Sometimes writing to stderr is not possible.
 fn handle_stderr_error(error: io::Error) -> Result<(), UiError> {
     // A broken pipe should not result in a error
     // like with `| head` for example
     if let ErrorKind::BrokenPipe = error.kind() {
         return Ok(());
     }
     Err(UiError::StdoutError(error))
 }

tests/test-rhg.t

@@ -1,64 +1,70 b''
 #require rust
 
 Define an rhg function that will only run if rhg exists
   $ rhg() {
   > if [ -f "$RUNTESTDIR/../rust/target/debug/rhg" ]; then
   >   "$RUNTESTDIR/../rust/target/debug/rhg" "$@"
   > else
   >   echo "skipped: Cannot find rhg. Try to run cargo build in rust/rhg."
   >   exit 80
   > fi
   > }
 
 Unimplemented command
   $ rhg unimplemented-command
+  error: Found argument 'unimplemented-command' which wasn't expected, or isn't valid in this context
+  
+  USAGE:
+      rhg <SUBCOMMAND>
+  
+  For more information try --help
   [252]
 
 Finding root
   $ rhg root
   abort: no repository found in '$TESTTMP' (.hg not found)!
   [255]
 
   $ hg init repository
   $ cd repository
   $ rhg root
   $TESTTMP/repository
 
 Unwritable file descriptor
   $ rhg root > /dev/full
   abort: No space left on device (os error 28)
   [255]
 
 Deleted repository
   $ rm -rf `pwd`
   $ rhg root
   abort: error getting current working directory: $ENOENT$
   [255]
 
 Listing tracked files
   $ cd $TESTTMP
   $ hg init repository
   $ cd repository
   $ for i in 1 2 3; do
   >   echo $i >> file$i
   >   hg add file$i
   > done
   > hg commit -m "commit $i" -q
 
 Listing tracked files from root
   $ rhg files
   file1
   file2
   file3
 
 Listing tracked files from subdirectory
   $ mkdir -p path/to/directory
   $ cd path/to/directory
   $ rhg files
   ../../../file1
   ../../../file2
   ../../../file3
 
 Listing tracked files through broken pipe
   $ rhg files | head -n 1
   ../../../file1