openpgp: Rename signature types.

  - This aligns our terminology with that of the RFC.

9 files changed, 67 insertions, 67 deletions

diff --git a/openpgp/src/cert/bindings.rs b/openpgp/src/cert/bindings.rs
index c6d9e6c6..bfaa0534 100644
--- a/openpgp/src/cert/bindings.rs
+++ b/openpgp/src/cert/bindings.rs
@@ -100,7 +100,7 @@ impl UserID {
     /// // Generate a userid and a binding signature.
     /// let userid = UserID::from("test@example.org");
     /// let builder =
-    ///     signature::Builder::new(SignatureType::PositiveCertificate);
+    ///     signature::Builder::new(SignatureType::PositiveCertification);
     /// let binding = userid.bind(&mut keypair, &cert, builder, None)?;
     ///
     /// // Now merge the userid and binding signature into the Cert.
@@ -131,7 +131,7 @@ impl UserID {
     /// The signature binds this userid to `cert`. `signer` will be
     /// used to create a certification signature of type
     /// `signature_type`.  `signature_type` defaults to
-    /// `SignatureType::GenericCertificate`, `hash_algo` to SHA512,
+    /// `SignatureType::GenericCertification`, `hash_algo` to SHA512,
     /// `creation_time` to the current time.
     ///
     /// This function adds a creation time subpacket, a issuer
@@ -169,7 +169,7 @@ impl UserID {
     /// // Alice now certifies the binding between `bob@example.org` and `bob`.
     /// let certificate =
     ///     bob.userids().nth(0).unwrap().userid()
-    ///     .certify(&mut keypair, &bob, SignatureType::PositiveCertificate,
+    ///     .certify(&mut keypair, &bob, SignatureType::PositiveCertification,
     ///              None, None)?;
     ///
     /// // `certificate` can now be used, e.g. by merging it into `bob`.
@@ -188,13 +188,13 @@ impl UserID {
     {
         let typ = signature_type.into();
         let typ = match typ {
-            Some(SignatureType::GenericCertificate)
-                | Some(SignatureType::PersonaCertificate)
-                | Some(SignatureType::CasualCertificate)
-                | Some(SignatureType::PositiveCertificate) => typ.unwrap(),
+            Some(SignatureType::GenericCertification)
+                | Some(SignatureType::PersonaCertification)
+                | Some(SignatureType::CasualCertification)
+                | Some(SignatureType::PositiveCertification) => typ.unwrap(),
             Some(t) => return Err(Error::InvalidArgument(
                 format!("Invalid signature type: {}", t)).into()),
-            None => SignatureType::GenericCertificate,
+            None => SignatureType::GenericCertification,
         };
         let mut sig = signature::Builder::new(typ);
         if let Some(algo) = hash_algo.into() {
@@ -245,7 +245,7 @@ impl UserAttribute {
     ///         Image::Private(100, vec![0, 1, 2].into_boxed_slice())),
     /// ])?;
     /// let builder =
-    ///     signature::Builder::new(SignatureType::PositiveCertificate);
+    ///     signature::Builder::new(SignatureType::PositiveCertification);
     /// let binding = user_attr.bind(&mut keypair, &cert, builder, None)?;
     ///
     /// // Now merge the user attribute and binding signature into the Cert.
@@ -275,7 +275,7 @@ impl UserAttribute {
     /// The signature binds this user attribute to `cert`. `signer` will be
     /// used to create a certification signature of type
     /// `signature_type`.  `signature_type` defaults to
-    /// `SignatureType::GenericCertificate`, `hash_algo` to SHA512,
+    /// `SignatureType::GenericCertification`, `hash_algo` to SHA512,
     /// `creation_time` to the current time.
     ///
     /// This function adds a creation time subpacket, a issuer
@@ -317,7 +317,7 @@ impl UserAttribute {
     /// // Alice now certifies the binding between `bob@example.org` and `bob`.
     /// let certificate =
     ///     bob.user_attributes().nth(0).unwrap().user_attribute()
-    ///     .certify(&mut keypair, &bob, SignatureType::PositiveCertificate,
+    ///     .certify(&mut keypair, &bob, SignatureType::PositiveCertification,
     ///              None, None)?;
     ///
     /// // `certificate` can now be used, e.g. by merging it into `bob`.
@@ -337,13 +337,13 @@ impl UserAttribute {
     {
         let typ = signature_type.into();
         let typ = match typ {
-            Some(SignatureType::GenericCertificate)
-                | Some(SignatureType::PersonaCertificate)
-                | Some(SignatureType::CasualCertificate)
-                | Some(SignatureType::PositiveCertificate) => typ.unwrap(),
+            Some(SignatureType::GenericCertification)
+                | Some(SignatureType::PersonaCertification)
+                | Some(SignatureType::CasualCertification)
+                | Some(SignatureType::PositiveCertification) => typ.unwrap(),
             Some(t) => return Err(Error::InvalidArgument(
                 format!("Invalid signature type: {}", t)).into()),
-            None => SignatureType::GenericCertificate,
+            None => SignatureType::GenericCertification,
         };
         let mut sig = signature::Builder::new(typ);
         if let Some(algo) = hash_algo.into() {
diff --git a/openpgp/src/cert/builder.rs b/openpgp/src/cert/builder.rs
index 9e2a2899..a13d2274 100644
--- a/openpgp/src/cert/builder.rs
+++ b/openpgp/src/cert/builder.rs
@@ -336,7 +336,7 @@ impl CertBuilder {
         // Sign UserIDs.
         for uid in self.userids.into_iter() {
             let builder = signature::Builder::from(sig.clone())
-                .set_type(SignatureType::PositiveCertificate)
+                .set_type(SignatureType::PositiveCertification)
                 // GnuPG wants at least a 512-bit hash for P521 keys.
                 .set_hash_algo(HashAlgorithm::SHA512);
             let signature = uid.bind(&mut signer, &cert, builder, None)?;
@@ -346,7 +346,7 @@ impl CertBuilder {
         // Sign UserAttributes.
         for ua in self.user_attributes.into_iter() {
             let builder = signature::Builder::from(sig.clone())
-                .set_type(SignatureType::PositiveCertificate)
+                .set_type(SignatureType::PositiveCertification)
             // GnuPG wants at least a 512-bit hash for P521 keys.
                 .set_hash_algo(HashAlgorithm::SHA512);
             let signature = ua.bind(&mut signer, &cert, builder, None)?;
diff --git a/openpgp/src/cert/mod.rs b/openpgp/src/cert/mod.rs
index d7a94f7b..d735d8ac 100644
--- a/openpgp/src/cert/mod.rs
+++ b/openpgp/src/cert/mod.rs
@@ -2289,7 +2289,7 @@ mod test {
             // If we have a user id---even if it is revoked---we have
             // a primary key signature.
             let typ = cert.primary_key_signature(None).unwrap().typ();
-            assert_eq!(typ, SignatureType::PositiveCertificate,
+            assert_eq!(typ, SignatureType::PositiveCertification,
                        "{:#?}", cert);
 
             let revoked = cert.revoked(None);
@@ -2303,7 +2303,7 @@ mod test {
 
             for userid in cert.userids() {
                 let typ = userid.binding_signature(None).unwrap().typ();
-                assert_eq!(typ, SignatureType::PositiveCertificate,
+                assert_eq!(typ, SignatureType::PositiveCertification,
                            "{:#?}", cert);
 
                 let revoked = userid.revoked(None);
@@ -2473,7 +2473,7 @@ mod test {
                 .build(&mut keypair, &cert, uid.userid(), None)
                 .unwrap()
         };
-        assert_eq!(sig.typ(), SignatureType::CertificateRevocation);
+        assert_eq!(sig.typ(), SignatureType::CertificationRevocation);
         let cert = cert.merge_packets(vec![sig.into()]).unwrap();
         assert_eq!(RevocationStatus::NotAsFarAsWeKnow,
                    cert.revoked(None));
@@ -3198,7 +3198,7 @@ Pu1xwz57O4zo1VYf6TqHJzVC3OMvMUM2hhdecMUe5x6GorNaj6g=
             assert_eq!(bob_userid_binding.userid().value(), b"bob@bar.com");
 
             let sig_template
-                = signature::Builder::new(SignatureType::GenericCertificate)
+                = signature::Builder::new(SignatureType::GenericCertification)
                       .set_trust_signature(255, 120)
                       .unwrap();
 
diff --git a/openpgp/src/cert/parser/mod.rs b/openpgp/src/cert/parser/mod.rs
index 74854021..3772e219 100644
--- a/openpgp/src/cert/parser/mod.rs
+++ b/openpgp/src/cert/parser/mod.rs
@@ -648,7 +648,7 @@ impl<'a, I: Iterator<Item=Packet>> CertParser<'a, I> {
                             use crate::SignatureType::*;
                             if typ == KeyRevocation
                                 || typ == SubkeyRevocation
-                                || typ == CertificateRevocation
+                                || typ == CertificationRevocation
                             {
                                 if is_selfsig {
                                     self_revs.push(sig.into());
diff --git a/openpgp/src/cert/revoke.rs b/openpgp/src/cert/revoke.rs
index a4876e0f..4342df59 100644
--- a/openpgp/src/cert/revoke.rs
+++ b/openpgp/src/cert/revoke.rs
@@ -286,7 +286,7 @@ impl Deref for SubkeyRevocationBuilder {
 ///             ReasonForRevocation::KeyRetired,
 ///             b"Left example.org.").unwrap()
 ///         .build(&mut keypair, &cert, userid.userid(), None)?;
-/// assert_eq!(revocation.typ(), SignatureType::CertificateRevocation);
+/// assert_eq!(revocation.typ(), SignatureType::CertificationRevocation);
 ///
 /// // Now merge the revocation signature into the Cert.
 /// let cert = cert.merge_packets(vec![revocation.clone().into()])?;
@@ -310,7 +310,7 @@ impl UserIDRevocationBuilder {
     pub fn new() -> Self {
         Self {
             builder:
-                signature::Builder::new(SignatureType::CertificateRevocation)
+                signature::Builder::new(SignatureType::CertificationRevocation)
         }
     }
 
@@ -404,7 +404,7 @@ impl Deref for UserIDRevocationBuilder {
 ///             ReasonForRevocation::KeyRetired,
 ///             b"Left example.org.").unwrap()
 ///         .build(&mut keypair, &cert, ua.user_attribute(), None)?;
-/// assert_eq!(revocation.typ(), SignatureType::CertificateRevocation);
+/// assert_eq!(revocation.typ(), SignatureType::CertificationRevocation);
 ///
 /// // Now merge the revocation signature into the Cert.
 /// let cert = cert.merge_packets(vec![revocation.clone().into()])?;
@@ -428,7 +428,7 @@ impl UserAttributeRevocationBuilder {
     pub fn new() -> Self {
         Self {
             builder:
-                signature::Builder::new(SignatureType::CertificateRevocation)
+                signature::Builder::new(SignatureType::CertificationRevocation)
         }
     }
 
diff --git a/openpgp/src/packet/signature/mod.rs b/openpgp/src/packet/signature/mod.rs
index 1740e727..2978c834 100644
--- a/openpgp/src/packet/signature/mod.rs
+++ b/openpgp/src/packet/signature/mod.rs
@@ -959,10 +959,10 @@ impl Signature4 {
         -> Result<bool>
         where R: key::KeyRole
     {
-        if !(self.typ() == SignatureType::GenericCertificate
-             || self.typ() == SignatureType::PersonaCertificate
-             || self.typ() == SignatureType::CasualCertificate
-             || self.typ() == SignatureType::PositiveCertificate) {
+        if !(self.typ() == SignatureType::GenericCertification
+             || self.typ() == SignatureType::PersonaCertification
+             || self.typ() == SignatureType::CasualCertification
+             || self.typ() == SignatureType::PositiveCertification) {
             return Err(Error::UnsupportedSignatureType(self.typ()).into());
         }
 
@@ -994,7 +994,7 @@ impl Signature4 {
         -> Result<bool>
         where R: key::KeyRole
     {
-        if self.typ() != SignatureType::CertificateRevocation {
+        if self.typ() != SignatureType::CertificationRevocation {
             return Err(Error::UnsupportedSignatureType(self.typ()).into());
         }
 
@@ -1026,10 +1026,10 @@ impl Signature4 {
         -> Result<bool>
         where R: key::KeyRole
     {
-        if !(self.typ() == SignatureType::GenericCertificate
-             || self.typ() == SignatureType::PersonaCertificate
-             || self.typ() == SignatureType::CasualCertificate
-             || self.typ() == SignatureType::PositiveCertificate) {
+        if !(self.typ() == SignatureType::GenericCertification
+             || self.typ() == SignatureType::PersonaCertification
+             || self.typ() == SignatureType::CasualCertification
+             || self.typ() == SignatureType::PositiveCertification) {
             return Err(Error::UnsupportedSignatureType(self.typ()).into());
         }
 
@@ -1061,7 +1061,7 @@ impl Signature4 {
         -> Result<bool>
         where R: key::KeyRole
     {
-        if self.typ() != SignatureType::CertificateRevocation {
+        if self.typ() != SignatureType::CertificationRevocation {
             return Err(Error::UnsupportedSignatureType(self.typ()).into());
         }
 
diff --git a/openpgp/src/serialize/cert.rs b/openpgp/src/serialize/cert.rs
index 79af5ed9..98b3e542 100644
--- a/openpgp/src/serialize/cert.rs
+++ b/openpgp/src/serialize/cert.rs
@@ -747,7 +747,7 @@ mod test {
             &mut keypair, &cert,
             signature::Builder::from(
                 cert.primary_key_signature(None).unwrap().clone())
-                .set_type(SignatureType::PositiveCertificate)
+                .set_type(SignatureType::PositiveCertification)
                 .set_exportable_certification(false).unwrap(),
             None).unwrap();
 
@@ -758,7 +758,7 @@ mod test {
             &mut keypair, &cert,
             signature::Builder::from(
                 cert.primary_key_signature(None).unwrap().clone())
-                .set_type(SignatureType::PositiveCertificate)
+                .set_type(SignatureType::PositiveCertification)
                 .set_exportable_certification(false).unwrap(),
             None).unwrap();
 
diff --git a/openpgp/src/serialize/mod.rs b/openpgp/src/serialize/mod.rs
index a078a628..15e95ada 100644
--- a/openpgp/src/serialize/mod.rs
+++ b/openpgp/src/serialize/mod.rs
@@ -2944,7 +2944,7 @@ mod test {
         // Make a signature w/o an exportable certification subpacket.
         let sig = uid.bind(
             &mut keypair, &cert,
-            signature::Builder::new(SignatureType::GenericCertificate),
+            signature::Builder::new(SignatureType::GenericCertification),
             None).unwrap();
 
         // The signature is exportable.  Try to export it in
@@ -2968,7 +2968,7 @@ mod test {
         // Make a signature that is explicitly marked as exportable.
         let sig = uid.bind(
             &mut keypair, &cert,
-            signature::Builder::new(SignatureType::GenericCertificate)
+            signature::Builder::new(SignatureType::GenericCertification)
                 .set_exportable_certification(true).unwrap(),
             None).unwrap();
 
@@ -2993,7 +2993,7 @@ mod test {
         // Make a non-exportable signature.
         let sig = uid.bind(
             &mut keypair, &cert,
-            signature::Builder::new(SignatureType::GenericCertificate)
+            signature::Builder::new(SignatureType::GenericCertification)
                 .set_exportable_certification(false).unwrap(),
             None).unwrap();
 
diff --git a/openpgp/src/types/mod.rs b/openpgp/src/types/mod.rs
index 0e76e1bd..01ada8f7 100644
--- a/openpgp/src/types/mod.rs
+++ b/openpgp/src/types/mod.rs
@@ -778,13 +778,13 @@ pub enum SignatureType {
     Standalone,
 
     /// Generic certification of a User ID and Public-Key packet.
-    GenericCertificate,
+    GenericCertification,
     /// Persona certification of a User ID and Public-Key packet.
-    PersonaCertificate,
+    PersonaCertification,
     /// Casual certification of a User ID and Public-Key packet.
-    CasualCertificate,
+    CasualCertification,
     /// Positive certification of a User ID and Public-Key packet.
-    PositiveCertificate,
+    PositiveCertification,
 
     /// Subkey Binding Signature
     SubkeyBinding,
@@ -798,7 +798,7 @@ pub enum SignatureType {
     /// Subkey revocation signature
     SubkeyRevocation,
     /// Certification revocation signature
-    CertificateRevocation,
+    CertificationRevocation,
 
     /// Timestamp signature.
     Timestamp,
@@ -815,16 +815,16 @@ impl From<u8> for SignatureType {
             0x00 => SignatureType::Binary,
             0x01 => SignatureType::Text,
             0x02 => SignatureType::Standalone,
-            0x10 => SignatureType::GenericCertificate,
-            0x11 => SignatureType::PersonaCertificate,
-            0x12 => SignatureType::CasualCertificate,
-            0x13 => SignatureType::PositiveCertificate,
+            0x10 => SignatureType::GenericCertification,
+            0x11 => SignatureType::PersonaCertification,
+            0x12 => SignatureType::CasualCertification,
+            0x13 => SignatureType::PositiveCertification,
             0x18 => SignatureType::SubkeyBinding,
             0x19 => SignatureType::PrimaryKeyBinding,
             0x1f => SignatureType::DirectKey,
             0x20 => SignatureType::KeyRevocation,
             0x28 => SignatureType::SubkeyRevocation,
-            0x30 => SignatureType::CertificateRevocation,
+            0x30 => SignatureType::CertificationRevocation,
             0x40 => SignatureType::Timestamp,
             0x50 => SignatureType::Confirmation,
             _ => SignatureType::Unknown(u),
@@ -838,16 +838,16 @@ impl From<SignatureType> for u8 {
             SignatureType::Binary => 0x00,
             SignatureType::Text => 0x01,
             SignatureType::Standalone => 0x02,
-            SignatureType::GenericCertificate => 0x10,
-            SignatureType::PersonaCertificate => 0x11,
-            SignatureType::CasualCertificate => 0x12,
-            SignatureType::PositiveCertificate => 0x13,
+            SignatureType::GenericCertification => 0x10,
+            SignatureType::PersonaCertification => 0x11,
+            SignatureType::CasualCertification => 0x12,
+            SignatureType::PositiveCertification => 0x13,
             SignatureType::SubkeyBinding => 0x18,
             SignatureType::PrimaryKeyBinding => 0x19,
             SignatureType::DirectKey => 0x1f,
             SignatureType::KeyRevocation => 0x20,
             SignatureType::SubkeyRevocation => 0x28,
-            SignatureType::CertificateRevocation => 0x30,
+            SignatureType::CertificationRevocation => 0x30,
             SignatureType::Timestamp => 0x40,
             SignatureType::Confirmation => 0x50,
             SignatureType::Unknown(u) => u,
@@ -864,14 +864,14 @@ impl fmt::Display for SignatureType {
                 f.write_str("Text"),
             SignatureType::Standalone =>
                 f.write_str("Standalone"),
-            SignatureType::GenericCertificate =>
-                f.write_str("GenericCertificate"),
-            SignatureType::PersonaCertificate =>
-                f.write_str("PersonaCertificate"),
-            SignatureType::CasualCertificate =>
-                f.write_str("CasualCertificate"),
-            SignatureType::PositiveCertificate =>
-                f.write_str("PositiveCertificate"),
+            SignatureType::GenericCertification =>
+                f.write_str("GenericCertification"),
+            SignatureType::PersonaCertification =>
+                f.write_str("PersonaCertification"),
+            SignatureType::CasualCertification =>
+                f.write_str("CasualCertification"),
+            SignatureType::PositiveCertification =>
+                f.write_str("PositiveCertification"),
             SignatureType::SubkeyBinding =>
                 f.write_str("SubkeyBinding"),
             SignatureType::PrimaryKeyBinding =>
@@ -882,8 +882,8 @@ impl fmt::Display for SignatureType {
                 f.write_str("KeyRevocation"),
             SignatureType::SubkeyRevocation =>
                 f.write_str("SubkeyRevocation"),
-            SignatureType::CertificateRevocation =>
-                f.write_str("CertificateRevocation"),
+            SignatureType::CertificationRevocation =>
+                f.write_str("CertificationRevocation"),
             SignatureType::Timestamp =>
                 f.write_str("Timestamp"),
             SignatureType::Confirmation =>