openpgp: Adjust examples to use try operator.

  - Change `expect` to `context(...)?`,

  - Change `unwrap` to `?`.

1 files changed, 19 insertions, 15 deletions

diff --git a/openpgp/examples/sign.rs b/openpgp/examples/sign.rs
index cb50a0bf..cee74940 100644
--- a/openpgp/examples/sign.rs
+++ b/openpgp/examples/sign.rs
@@ -3,26 +3,28 @@
 use std::env;
 use std::io;
 
+use anyhow::Context;
+
 extern crate sequoia_openpgp as openpgp;
 use crate::openpgp::armor;
 use crate::openpgp::parse::Parse;
 use crate::openpgp::serialize::stream::{Message, LiteralWriter, Signer};
 use crate::openpgp::policy::StandardPolicy as P;
 
-fn main() {
+fn main() -> openpgp::Result<()> {
     let p = &P::new();
     let args: Vec<String> = env::args().collect();
     if args.len() < 2 {
-        panic!("A simple signing filter.\n\n\
+        return Err(anyhow::anyhow!("A simple signing filter.\n\n\
                 Usage: {} <secret-keyfile> [<secret-keyfile>...] \
-                <input >output\n", args[0]);
+                <input >output\n", args[0]));
     }
 
     // Read the transferable secret keys from the given files.
     let mut keys = Vec::new();
     for filename in &args[1..] {
         let tsk = openpgp::Cert::from_file(filename)
-            .expect("Failed to read key");
+            .context("Failed to read key")?;
         let mut n = 0;
 
         for key in tsk.keys()
@@ -34,19 +36,19 @@ fn main() {
                 if key.secret().is_encrypted() {
                     let password = rpassword::read_password_from_tty(
                         Some(&format!("Please enter password to decrypt \
-                                       {}/{}: ",tsk, key))).unwrap();
+                                       {}/{}: ",tsk, key)))?;
                     let algo = key.pk_algo();
                     key.secret_mut()
                         .decrypt_in_place(algo, &password.into())
-                        .expect("decryption failed");
+                        .context("decryption failed")?;
                 }
                 n += 1;
-                key.into_keypair().unwrap()
+                key.into_keypair()?
             });
         }
 
         if n == 0 {
-            panic!("Found no suitable signing key on {}", tsk);
+            return Err(anyhow::anyhow!("Found no suitable signing key on {}", tsk));
         }
     }
 
@@ -54,33 +56,35 @@ fn main() {
     // packet structure we want.  First, we want the output to be
     // ASCII armored.
     let mut sink = armor::Writer::new(io::stdout(), armor::Kind::Message)
-        .expect("Failed to create an armored writer.");
+        .context("Failed to create an armored writer.")?;
 
     // Stream an OpenPGP message.
     let message = Message::new(&mut sink);
 
     // Now, create a signer that emits the signature(s).
     let mut signer =
-        Signer::new(message, keys.pop().expect("No key for signing"));
+        Signer::new(message, keys.pop().context("No key for signing")?);
     for s in keys {
         signer = signer.add_signer(s);
     }
-    let signer = signer.build().expect("Failed to create signer");
+    let signer = signer.build().context("Failed to create signer")?;
 
     // Then, create a literal writer to wrap the data in a literal
     // message packet.
     let mut literal = LiteralWriter::new(signer).build()
-        .expect("Failed to create literal writer");
+        .context("Failed to create literal writer")?;
 
     // Copy all the data.
     io::copy(&mut io::stdin(), &mut literal)
-        .expect("Failed to sign data");
+        .context("Failed to sign data")?;
 
     // Finally, teardown the stack to ensure all the data is written.
     literal.finalize()
-        .expect("Failed to write data");
+        .context("Failed to write data")?;
 
     // Finalize the armor writer.
     sink.finalize()
-        .expect("Failed to write data");
+        .context("Failed to write data")?;
+
+    Ok(())
 }