openpgp: Fix examples to use stream::Armorer.

6 files changed, 38 insertions, 59 deletions

diff --git a/openpgp/examples/encrypt-for.rs b/openpgp/examples/encrypt-for.rs
index 28f63934..958c2095 100644
--- a/openpgp/examples/encrypt-for.rs
+++ b/openpgp/examples/encrypt-for.rs
@@ -7,7 +7,8 @@ use std::io;
 use anyhow::Context;
 
 extern crate sequoia_openpgp as openpgp;
-use crate::openpgp::armor;
+
+use crate::openpgp::serialize::stream::Armorer;
 use crate::openpgp::types::KeyFlags;
 use crate::openpgp::parse::Parse;
 use crate::openpgp::serialize::stream::{
@@ -47,14 +48,16 @@ fn main() -> openpgp::Result<()> {
         });
 
     // Compose a writer stack corresponding to the output format and
-    // packet structure we want.  First, we want the output to be
-    // ASCII armored.
-    let mut sink = armor::Writer::new(io::stdout(), armor::Kind::Message)
-        .context("Failed to create an armored writer")?;
+    // packet structure we want.
+    let mut sink = io::stdout();
 
     // Stream an OpenPGP message.
     let message = Message::new(&mut sink);
 
+    let message = Armorer::new(message)
+        // Customize the `Armorer` here.
+        .build()?;
+
     // We want to encrypt a literal data packet.
     let encryptor = Encryptor::for_recipients(message, recipients)
         .build().context("Failed to create encryptor")?;
@@ -70,9 +73,5 @@ fn main() -> openpgp::Result<()> {
     // writer stack.
     literal_writer.finalize()?;
 
-    // Finalize the armor writer.
-    sink.finalize()
-        .context("Failed to write data")?;
-
     Ok(())
 }
diff --git a/openpgp/examples/notarize.rs b/openpgp/examples/notarize.rs
index 1e4939c6..c93ca744 100644
--- a/openpgp/examples/notarize.rs
+++ b/openpgp/examples/notarize.rs
@@ -7,11 +7,11 @@ use std::io;
 use anyhow::Context;
 
 extern crate sequoia_openpgp as openpgp;
+
 use crate::openpgp::{
-    armor,
     Packet,
     parse::{Parse, PacketParserResult},
-    serialize::Marshal,
+    serialize::{Marshal, stream::Armorer},
 };
 use crate::openpgp::serialize::stream::{Message, LiteralWriter, Signer};
 use crate::openpgp::policy::StandardPolicy as P;
@@ -58,14 +58,14 @@ fn main() -> openpgp::Result<()> {
     }
 
     // Compose a writer stack corresponding to the output format and
-    // packet structure we want.  First, we want the output to be
-    // ASCII armored.
-    let mut sink = armor::Writer::new(io::stdout(), armor::Kind::Message)
-        .context("Failed to create an armored writer.")?;
+    // packet structure we want.
+    let mut sink = io::stdout();
 
     // Stream an OpenPGP message.
     let message = Message::new(&mut sink);
 
+    let message = Armorer::new(message).build()?;
+
     // Now, create a signer that emits the signature(s).
     let mut signer =
         Signer::new(message, keys.pop().context("No key for signing")?);
@@ -124,9 +124,5 @@ fn main() -> openpgp::Result<()> {
     signer.finalize()
         .context("Failed to write data")?;
 
-    // Finalize the armor writer.
-    sink.finalize()
-        .context("Failed to write data")?;
-
     Ok(())
 }
diff --git a/openpgp/examples/pad.rs b/openpgp/examples/pad.rs
index 825d7758..10ee1804 100644
--- a/openpgp/examples/pad.rs
+++ b/openpgp/examples/pad.rs
@@ -7,12 +7,12 @@ use std::io;
 use anyhow::Context;
 
 extern crate sequoia_openpgp as openpgp;
-use crate::openpgp::armor;
+
 use crate::openpgp::KeyID;
 use crate::openpgp::types::KeyFlags;
 use crate::openpgp::parse::Parse;
 use crate::openpgp::serialize::stream::{
-    Message, LiteralWriter, Encryptor, Recipient, padding::*,
+    Armorer, Message, LiteralWriter, Encryptor, Recipient, padding::*,
 };
 use crate::openpgp::policy::StandardPolicy as P;
 
@@ -49,14 +49,14 @@ fn main() -> openpgp::Result<()> {
         .collect::<Vec<_>>();
 
     // Compose a writer stack corresponding to the output format and
-    // packet structure we want.  First, we want the output to be
-    // ASCII armored.
-    let mut sink = armor::Writer::new(io::stdout(), armor::Kind::Message)
-        .context("Failed to create an armored writer")?;
+    // packet structure we want.
+    let mut sink = io::stdout();
 
     // Stream an OpenPGP message.
     let message = Message::new(&mut sink);
 
+    let message = Armorer::new(message).build()?;
+
     // We want to encrypt a literal data packet.
     let encryptor = Encryptor::for_recipients(message, recipients)
         .build().context("Failed to create encryptor")?;
@@ -75,9 +75,5 @@ fn main() -> openpgp::Result<()> {
     // writer stack.
     literal_writer.finalize()?;
 
-    // Finalize the armor writer.
-    sink.finalize()
-        .context("Failed to write data")?;
-
     Ok(())
 }
diff --git a/openpgp/examples/sign-detached.rs b/openpgp/examples/sign-detached.rs
index f16b1e93..944abf76 100644
--- a/openpgp/examples/sign-detached.rs
+++ b/openpgp/examples/sign-detached.rs
@@ -8,9 +8,9 @@ use anyhow::Context;
 extern crate rpassword;
 
 extern crate sequoia_openpgp as openpgp;
-use crate::openpgp::armor;
+
 use crate::openpgp::parse::Parse;
-use crate::openpgp::serialize::stream::{Message, Signer};
+use crate::openpgp::serialize::stream::{Armorer, Message, Signer};
 use crate::openpgp::policy::StandardPolicy as P;
 
 fn main() -> openpgp::Result<()> {
@@ -55,14 +55,14 @@ fn main() -> openpgp::Result<()> {
     }
 
     // Compose a writer stack corresponding to the output format and
-    // packet structure we want.  First, we want the output to be
-    // ASCII armored.
-    let mut sink = armor::Writer::new(io::stdout(), armor::Kind::Signature)
-        .context("Failed to create armored writer.")?;
+    // packet structure we want.
+    let mut sink = io::stdout();
 
     // Stream an OpenPGP message.
     let message = Message::new(&mut sink);
 
+    let message = Armorer::new(message).build()?;
+
     // Now, create a signer that emits the detached signature(s).
     let mut signer =
         Signer::new(message, keys.pop().context("No key for signing")?);
@@ -80,9 +80,5 @@ fn main() -> openpgp::Result<()> {
     signer.finalize()
         .context("Failed to write data")?;
 
-    // Finalize the armor writer.
-    sink.finalize()
-        .context("Failed to write data")?;
-
     Ok(())
 }
diff --git a/openpgp/examples/sign.rs b/openpgp/examples/sign.rs
index cee74940..b49816cd 100644
--- a/openpgp/examples/sign.rs
+++ b/openpgp/examples/sign.rs
@@ -6,9 +6,9 @@ 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::serialize::stream::{Armorer, Message, LiteralWriter, Signer};
 use crate::openpgp::policy::StandardPolicy as P;
 
 fn main() -> openpgp::Result<()> {
@@ -53,14 +53,14 @@ fn main() -> openpgp::Result<()> {
     }
 
     // Compose a writer stack corresponding to the output format and
-    // packet structure we want.  First, we want the output to be
-    // ASCII armored.
-    let mut sink = armor::Writer::new(io::stdout(), armor::Kind::Message)
-        .context("Failed to create an armored writer.")?;
+    // packet structure we want.
+    let mut sink = io::stdout();
 
     // Stream an OpenPGP message.
     let message = Message::new(&mut sink);
 
+    let message = Armorer::new(message).build()?;
+
     // Now, create a signer that emits the signature(s).
     let mut signer =
         Signer::new(message, keys.pop().context("No key for signing")?);
@@ -82,9 +82,5 @@ fn main() -> openpgp::Result<()> {
     literal.finalize()
         .context("Failed to write data")?;
 
-    // Finalize the armor writer.
-    sink.finalize()
-        .context("Failed to write data")?;
-
     Ok(())
 }
diff --git a/openpgp/examples/wrap-literal.rs b/openpgp/examples/wrap-literal.rs
index 7f2b6023..155638a8 100644
--- a/openpgp/examples/wrap-literal.rs
+++ b/openpgp/examples/wrap-literal.rs
@@ -9,8 +9,8 @@ use std::io;
 use anyhow::Context;
 
 extern crate sequoia_openpgp as openpgp;
-use crate::openpgp::armor;
-use crate::openpgp::serialize::stream::{Message, LiteralWriter};
+
+use crate::openpgp::serialize::stream::{Armorer, Message, LiteralWriter};
 
 fn main() -> openpgp::Result<()> {
     let args: Vec<String> = env::args().collect();
@@ -20,14 +20,14 @@ fn main() -> openpgp::Result<()> {
     }
 
     // Compose a writer stack corresponding to the output format and
-    // packet structure we want.  First, we want the output to be
-    // ASCII armored.
-    let mut sink = armor::Writer::new(io::stdout(), armor::Kind::Message)
-        .context("Failed to create armored writer.")?;
+    // packet structure we want.
+    let mut sink = io::stdout();
 
     // Stream an OpenPGP message.
     let message = Message::new(&mut sink);
 
+    let message = Armorer::new(message).build()?;
+
     // Then, create a literal writer to wrap the data in a literal
     // message packet.
     let mut literal = LiteralWriter::new(message).build()
@@ -41,9 +41,5 @@ fn main() -> openpgp::Result<()> {
     literal.finalize()
         .context("Failed to write data")?;
 
-    // Finalize the armor writer.
-    sink.finalize()
-        .context("Failed to write data")?;
-
     Ok(())
 }