.interactive

                .confirm(format!("Accept revision {}?", term::format::tertiary(id)))

            {

                if let Some(revision) = identity.revision(&id) {

                    // Update the canonical head to point to the latest accepted revision.

    signer: &G,

) -> anyhow::Result<Revision> {

    if let Some((title, description)) = edit_title_description(title, description)? {

    } else {

        Err(anyhow!("you must provide a revision title and description"))

    }

    Create, Embed, Entry, Evaluate, History, Manifest, ObjectId, Store, TypeName, Update, Updated,

    Version,

};

    Op(#[from] op::OpEncodingError),

    #[error(transparent)]

    Doc(#[from] DocError),

}

/// An evolving identity document.

        description: impl ToString,

        doc: &Doc<Verified>,

        signer: &G,

        let parent = self.current;

        let id = self.transaction("Propose revision", signer, |tx| {

            tx.revision(title, description, doc, Some(parent), signer)

        })?;

    }

    /// Accept an active revision.

        let signature = revision.sign(signer)?;

    }

    /// Reject an active revision.

        // Let's add another delegate.

        doc.delegate(bob.public_key());

        // The update should go through now.

        assert!(identity.revision(&r1).unwrap().is_accepted());

        assert_eq!(identity.current, r1);

        // With two delegates now, we need two signatures for any update to go through.

        let r2 = identity.update(title, description, &doc, signer).unwrap();

        // R1 is still the head.

        assert_eq!(identity.current, r1);

        assert_eq!(repo.canonical_identity_head().unwrap(), r1);

        assert_eq!(repo.identity_doc().unwrap().visibility, Visibility::Public);

        // Now let's add a signature on R2 from Bob.

        identity.accept(&r2, &bob).unwrap();

        // R2 is now the head.

        assert_eq!(

            repo.canonical_identity_doc().unwrap().visibility,

            Visibility::private([])

        // Let's add another delegate.

        doc.delegate(bob.public_key());

        assert_eq!(identity.current, r1);

        doc.visibility = Visibility::private([]);

            .unwrap();

        // 1/2 rejected means that we can never reach the required 2/2 votes.

        assert_eq!(r2.state, State::Rejected);

        // Now let's add another delegate.

            .update("Add Eve", description, &doc, &node.signer)

            .unwrap();

        let _ = identity.accept(&r3, &bob).unwrap();

        doc.visibility = Visibility::Public;

        let r3 = identity

            .unwrap();

        // 1/3 rejected means that we can still reach the 2/3 required votes.

        assert_eq!(r3.state, State::Active); // Still active.

        // 2/3 rejected means that we can no longer reach the 2/3 required votes.

        alice_doc.delegate(bob.signer.public_key());

        let a1 = alice_identity

            .update("Add Bob", "", &alice_doc, &alice.signer)

        bob.repo.fetch(alice);

        // Bob makes the same change without knowing Alice already did.

        let b1 = bob_identity

            .update("Make private", "", &alice_doc, &bob.signer)

        // Bob gets Alice's data.

        bob.repo.fetch(alice);

        alice.repo.fetch(bob);

        alice_identity.reload().unwrap();

        assert_eq!(alice_identity.current, a1);

        assert_eq!(bob_identity.revision(&b1).unwrap().state, State::Active);

        // Now Bob accepts Alice's proposal. This voids his own.

        bob_identity.accept(&a2, &bob.signer).unwrap();

        assert_eq!(bob_identity.revision(&a1).unwrap().state, State::Accepted);

        assert_eq!(bob_identity.revision(&b1).unwrap().state, State::Stale);

    }

        let a0 = alice_identity.root;

        let a1 = alice_identity

            .update("Add Bob", "Eh.", &alice_doc, &alice.signer)

        alice_doc.visibility = Visibility::private([eve.signer.public_key().into()]);

        let a2 = alice_identity

            .unwrap();

        bob.repo.fetch(alice);

        assert!(alice_identity.revision(&a1).is_some());

        let mut bob_identity = Identity::load_mut(&*bob.repo).unwrap();

        let b1 = bob_identity.accept(&a2, &bob.signer).unwrap();

        bob.repo.fetch(alice);

        bob_identity.reload().unwrap();

        assert_eq!(bob_identity.current, a1);

    }

        let a0 = alice_identity.root;

        let a1 = alice_identity

            .update("Add Bob and Eve", "Eh.", &alice_doc, &alice.signer)

        alice_doc.rescind(eve.signer.public_key()).unwrap();

        let a2 = alice_identity

        let mut bob_identity = Identity::load_mut(&*bob.repo).unwrap();

        let b1 = bob_identity.accept(&a2, &bob.signer).unwrap();

        let mut eve_identity = Identity::load_mut(&*eve.repo).unwrap();

        let mut eve_doc = eve_identity.doc().clone();

        eve.repo.fetch(bob);

        eve_identity.reload().unwrap();

        assert!(!eve_identity.is_delegate(eve.signer.public_key()));

    }

        let a0 = alice_identity.root;

        let a1 = alice_identity

            .update("Add Bob and Eve", "Eh.", &alice_doc, &alice.signer)

        alice_doc.visibility = Visibility::private([]);

        let a2 = alice_identity

        // Eve rejects the revision, not knowing.

        let mut eve_identity = Identity::load_mut(&*eve.repo).unwrap();

        // Then she submits a new revision.

        let mut eve_doc = eve_identity.doc().clone();

        eve.repo.fetch(bob);

        eve_identity.reload().unwrap();

        // Her revision is there, although stale, since another revision was accepted since.

        // However, it wasn't pruned, even though rejecting an accepted revision is an error.

        assert_eq!(e2.state, State::Stale);

    }

            .update("Change visibility #2", "Woops", &eve_doc, &eve.signer)

            .unwrap();

        assert_eq!(eve_identity.revisions().count(), 4);

        let a2 = alice_identity.accept(&b1, &alice.signer).unwrap();

        eve.repo.fetch(alice);

        eve_identity.reload().unwrap();

    }

    #[test]

        let identity: Identity = Identity::load(&repo).unwrap();

        let root = repo.identity_root().unwrap();

        assert_eq!(identity.signatures().count(), 2);

        assert_eq!(identity.revisions().count(), 5);

        assert_eq!(identity.root().id, root);

        assert_eq!(identity.current().blob, doc.blob);

        assert_eq!(identity.current().description.as_str(), "Bob's repository");

        assert_eq!(identity.doc(), &*doc);

        assert_eq!(

            identity.doc().project().unwrap().description(),