guide: Convert unwraps to use the try operator.

4 files changed, 85 insertions, 59 deletions

diff --git a/guide/src/chapter_00.md b/guide/src/chapter_00.md
index fafa17f9..e4967939 100644
--- a/guide/src/chapter_00.md
+++ b/guide/src/chapter_00.md
@@ -57,7 +57,7 @@ your favorite editor, and enter:
 extern crate sequoia_openpgp as openpgp;
 use std::io;
 
-fn main() {
+fn main() -> openpgp::Result<()> {
     let mut reader = openpgp::armor::Reader::from_bytes(
        b"-----BEGIN PGP ARMORED FILE-----
 
@@ -65,7 +65,9 @@ fn main() {
          =XLsG
          -----END PGP ARMORED FILE-----", None);
 
-    io::copy(&mut reader, &mut io::stdout()).unwrap();
+    io::copy(&mut reader, &mut io::stdout())?;
+
+    Ok(())
 }
 ```
 
diff --git a/guide/src/chapter_01.md b/guide/src/chapter_01.md
index 3d2af662..f89f7ed5 100644
--- a/guide/src/chapter_01.md
+++ b/guide/src/chapter_01.md
@@ -22,21 +22,23 @@ use openpgp::policy::StandardPolicy as P;
 
 const MESSAGE: &'static str = "дружба";
 
-fn main() {
+fn main() -> openpgp::Result<()> {
     let p = &P::new();
 
     // Generate a key.
-    let key = generate().unwrap();
+    let key = generate()?;
 
     // Sign the message.
     let mut signed_message = Vec::new();
-    sign(p, &mut signed_message, MESSAGE, &key).unwrap();
+    sign(p, &mut signed_message, MESSAGE, &key)?;
 
     // Verify the message.
     let mut plaintext = Vec::new();
-    verify(p, &mut plaintext, &signed_message, &key).unwrap();
+    verify(p, &mut plaintext, &signed_message, &key)?;
 
     assert_eq!(MESSAGE.as_bytes(), &plaintext[..]);
+
+    Ok(())
 }
 #
 # /// Generates an signing-capable key.
@@ -171,21 +173,23 @@ create it:
 #
 # const MESSAGE: &'static str = "дружба";
 #
-# fn main() {
+# fn main() -> openpgp::Result<()> {
 #     let p = &P::new();
 #
 #     // Generate a key.
-#     let key = generate().unwrap();
+#     let key = generate()?;
 #
 #     // Sign the message.
 #     let mut signed_message = Vec::new();
-#     sign(p, &mut signed_message, MESSAGE, &key).unwrap();
+#     sign(p, &mut signed_message, MESSAGE, &key)?;
 #
 #     // Verify the message.
 #     let mut plaintext = Vec::new();
-#     verify(p, &mut plaintext, &signed_message, &key).unwrap();
+#     verify(p, &mut plaintext, &signed_message, &key)?;
 #
 #     assert_eq!(MESSAGE.as_bytes(), &plaintext[..]);
+#
+#     Ok(())
 # }
 #
 /// Generates an signing-capable key.
@@ -320,21 +324,23 @@ implements [`io::Write`], and we simply write the plaintext to it.
 #
 # const MESSAGE: &'static str = "дружба";
 #
-# fn main() {
+# fn main() -> openpgp::Result<()> {
 #     let p = &P::new();
 #
 #     // Generate a key.
-#     let key = generate().unwrap();
+#     let key = generate()?;
 #
 #     // Sign the message.
 #     let mut signed_message = Vec::new();
-#     sign(p, &mut signed_message, MESSAGE, &key).unwrap();
+#     sign(p, &mut signed_message, MESSAGE, &key)?;
 #
 #     // Verify the message.
 #     let mut plaintext = Vec::new();
-#     verify(p, &mut plaintext, &signed_message, &key).unwrap();
+#     verify(p, &mut plaintext, &signed_message, &key)?;
 #
 #     assert_eq!(MESSAGE.as_bytes(), &plaintext[..]);
+#
+#     Ok(())
 # }
 #
 # /// Generates an signing-capable key.
@@ -477,38 +483,40 @@ Verified data can be read from this using [`io::Read`].
 # use openpgp::parse::{Parse, stream::*};
 # use openpgp::policy::Policy;
 # use openpgp::policy::StandardPolicy as P;
-# 
+#
 # const MESSAGE: &'static str = "дружба";
-# 
-# fn main() {
+#
+# fn main() -> openpgp::Result<()> {
 #     let p = &P::new();
 #
 #     // Generate a key.
-#     let key = generate().unwrap();
-# 
+#     let key = generate()?;
+#
 #     // Sign the message.
 #     let mut signed_message = Vec::new();
-#     sign(p, &mut signed_message, MESSAGE, &key).unwrap();
-# 
+#     sign(p, &mut signed_message, MESSAGE, &key)?;
+#
 #     // Verify the message.
 #     let mut plaintext = Vec::new();
-#     verify(p, &mut plaintext, &signed_message, &key).unwrap();
-# 
+#     verify(p, &mut plaintext, &signed_message, &key)?;
+#
 #     assert_eq!(MESSAGE.as_bytes(), &plaintext[..]);
+#
+#     Ok(())
 # }
-# 
+#
 # /// Generates an signing-capable key.
 # fn generate() -> openpgp::Result<openpgp::Cert> {
 #     let (cert, _revocation) = CertBuilder::new()
 #         .add_userid("someone@example.org")
 #         .add_signing_subkey()
 #         .generate()?;
-# 
+#
 #     // Save the revocation certificate somewhere.
-# 
+#
 #     Ok(cert)
 # }
-# 
+#
 # /// Signs the given message.
 # fn sign(policy: &dyn Policy,
 #         sink: &mut Write, plaintext: &str, tsk: &openpgp::Cert)
@@ -519,26 +527,26 @@ Verified data can be read from this using [`io::Read`].
 #         .keys().unencrypted_secret()
 #         .with_policy(policy, None).alive().revoked(false).for_signing()
 #         .nth(0).unwrap().key().clone().into_keypair()?;
-# 
+#
 #     // Start streaming an OpenPGP message.
 #     let message = Message::new(sink);
-# 
+#
 #     // We want to sign a literal data packet.
 #     let signer = Signer::new(message, keypair).build()?;
-# 
+#
 #     // Emit a literal data packet.
 #     let mut literal_writer = LiteralWriter::new(signer).build()?;
-# 
+#
 #     // Sign the data.
 #     literal_writer.write_all(plaintext.as_bytes())?;
-# 
+#
 #     // Finalize the OpenPGP message to make sure that all data is
 #     // written.
 #     literal_writer.finalize()?;
-# 
+#
 #     Ok(())
 # }
-# 
+#
 /// Verifies the given message.
 fn verify(policy: &dyn Policy,
           sink: &mut Write, signed_message: &[u8], sender: &openpgp::Cert)
diff --git a/guide/src/chapter_02.md b/guide/src/chapter_02.md
index fe7e9856..34bc60b5 100644
--- a/guide/src/chapter_02.md
+++ b/guide/src/chapter_02.md
@@ -22,21 +22,23 @@ use openpgp::policy::StandardPolicy as P;
 
 const MESSAGE: &'static str = "дружба";
 
-fn main() {
+fn main() -> openpgp::Result<()> {
     let p = &P::new();
 
     // Generate a key.
-    let key = generate().unwrap();
+    let key = generate()?;
 
     // Encrypt the message.
     let mut ciphertext = Vec::new();
-    encrypt(p, &mut ciphertext, MESSAGE, &key).unwrap();
+    encrypt(p, &mut ciphertext, MESSAGE, &key)?;
 
     // Decrypt the message.
     let mut plaintext = Vec::new();
-    decrypt(p, &mut plaintext, &ciphertext, &key).unwrap();
+    decrypt(p, &mut plaintext, &ciphertext, &key)?;
 
     assert_eq!(MESSAGE.as_bytes(), &plaintext[..]);
+
+    Ok(())
 }
 #
 # /// Generates an encryption-capable key.
@@ -168,21 +170,23 @@ create it:
 #
 # const MESSAGE: &'static str = "дружба";
 #
-# fn main() {
+# fn main() -> openpgp::Result<()> {
 #     let p = &P::new();
 #
 #     // Generate a key.
-#     let key = generate().unwrap();
+#     let key = generate()?;
 #
 #     // Encrypt the message.
 #     let mut ciphertext = Vec::new();
-#     encrypt(p, &mut ciphertext, MESSAGE, &key).unwrap();
+#     encrypt(p, &mut ciphertext, MESSAGE, &key)?;
 #
 #     // Decrypt the message.
 #     let mut plaintext = Vec::new();
-#     decrypt(p, &mut plaintext, &ciphertext, &key).unwrap();
+#     decrypt(p, &mut plaintext, &ciphertext, &key)?;
 #
 #     assert_eq!(MESSAGE.as_bytes(), &plaintext[..]);
+#
+#     Ok(())
 # }
 #
 /// Generates an encryption-capable key.
@@ -314,21 +318,23 @@ implements [`io::Write`], and we simply write the plaintext to it.
 #
 # const MESSAGE: &'static str = "дружба";
 #
-# fn main() {
+# fn main() -> openpgp::Result<()> {
 #     let p = &P::new();
 #
 #     // Generate a key.
-#     let key = generate().unwrap();
+#     let key = generate()?;
 #
 #     // Encrypt the message.
 #     let mut ciphertext = Vec::new();
-#     encrypt(p, &mut ciphertext, MESSAGE, &key).unwrap();
+#     encrypt(p, &mut ciphertext, MESSAGE, &key)?;
 #
 #     // Decrypt the message.
 #     let mut plaintext = Vec::new();
-#     decrypt(p, &mut plaintext, &ciphertext, &key).unwrap();
+#     decrypt(p, &mut plaintext, &ciphertext, &key)?;
 #
 #     assert_eq!(MESSAGE.as_bytes(), &plaintext[..]);
+#
+#     Ok(())
 # }
 #
 # /// Generates an encryption-capable key.
@@ -474,21 +480,23 @@ Decrypted data can be read from this using [`io::Read`].
 #
 # const MESSAGE: &'static str = "дружба";
 #
-# fn main() {
+# fn main() -> openpgp::Result<()> {
 #     let p = &P::new();
 #
 #     // Generate a key.
-#     let key = generate().unwrap();
+#     let key = generate()?;
 #
 #     // Encrypt the message.
 #     let mut ciphertext = Vec::new();
-#     encrypt(p, &mut ciphertext, MESSAGE, &key).unwrap();
+#     encrypt(p, &mut ciphertext, MESSAGE, &key)?;
 #
 #     // Decrypt the message.
 #     let mut plaintext = Vec::new();
-#     decrypt(p, &mut plaintext, &ciphertext, &key).unwrap();
+#     decrypt(p, &mut plaintext, &ciphertext, &key)?;
 #
 #     assert_eq!(MESSAGE.as_bytes(), &plaintext[..]);
+#
+#     Ok(())
 # }
 #
 # /// Generates an encryption-capable key.
diff --git a/guide/src/chapter_03.md b/guide/src/chapter_03.md
index eef988ca..b8f05dd2 100644
--- a/guide/src/chapter_03.md
+++ b/guide/src/chapter_03.md
@@ -40,8 +40,8 @@ const KEY: &str =
      =MHBq
      -----END PGP PUBLIC KEY BLOCK-----";
 
-fn main() {
-    let cert = openpgp::Cert::from_bytes(KEY.as_bytes()).unwrap();
+fn main() -> openpgp::Result<()> {
+    let cert = openpgp::Cert::from_bytes(KEY.as_bytes())?;
 
     assert_eq!(cert.fingerprint().to_string(),
                "C087 4478 A65C 540A 1F73  72B4 A22E AD61 4D11 744A");
@@ -56,6 +56,8 @@ fn main() {
                "67A4 8753 A380 A6B3 B7DF  7DC5 E6C6 897A 4CEF 8924");
     assert_eq!(cert.keys().subkeys().nth(1).unwrap().key().fingerprint().to_string(),
                "185C DAA1 2723 0423 19E4  7F67 108F 2CAF 9034 356D");
+
+    Ok(())
 }
 ```
 
@@ -83,10 +85,12 @@ const MESSAGE: &str =
      =AqoO
      -----END PGP MESSAGE-----";
 
-fn main() {
-    let message = openpgp::Message::from_bytes(MESSAGE.as_bytes()).unwrap();
+fn main() -> openpgp::Result<()> {
+    let message = openpgp::Message::from_bytes(MESSAGE.as_bytes())?;
 
     assert_eq!(message.body().unwrap().body(), "صداقة".as_bytes());
+
+    Ok(())
 }
 ```
 
@@ -117,8 +121,8 @@ const MESSAGE: &str =
      =AqoO
      -----END PGP MESSAGE-----";
 
-fn main() {
-    let pile = openpgp::PacketPile::from_bytes(MESSAGE.as_bytes()).unwrap();
+fn main() -> openpgp::Result<()> {
+    let pile = openpgp::PacketPile::from_bytes(MESSAGE.as_bytes())?;
 
     // For simplicity, turn the pile into a vector of packets.
     let packets: Vec<openpgp::Packet> = pile.into_children().collect();
@@ -147,6 +151,8 @@ fn main() {
     } else {
         panic!("expected signature packet");
     }
+
+    Ok(())
 }
 ```
 
@@ -196,11 +202,11 @@ const MESSAGE: &str =
      =eySo
      -----END PGP MESSAGE-----";
 
-fn main() {
+fn main() -> openpgp::Result<()> {
     let mut bytes_read = 0;
     let mut buf = vec![0; 1024 * 1024];
 
-    let mut ppr = PacketParser::from_bytes(MESSAGE.as_bytes()).unwrap();
+    let mut ppr = PacketParser::from_bytes(MESSAGE.as_bytes())?;
     while let PacketParserResult::Some(mut pp) = ppr {
         // Match on the kind of packet here while it is in the parser.
         if let openpgp::Packet::Literal(_) = pp.packet {
@@ -211,9 +217,11 @@ fn main() {
         }
 
         // Start parsing the next packet.
-        ppr = pp.recurse().unwrap().1;
+        ppr = pp.recurse()?.1;
     }
 
     assert_eq!(bytes_read, 128 * 1024 * 1024);    // 128 megabytes
+
+    Ok(())
 }
 ```