Correct some docu

crates/rustic_core/src/archiver/parent.rs

@@ -41,11 +41,11 @@ pub struct Parent {
 /// * `T` - The type of the matched parent.
 #[derive(Clone, Debug)]
 pub(crate) enum ParentResult<T> {
-    /// The parent was found.
+    /// The parent was found and matches.
     Matched(T),
     /// The parent was not found.
     NotFound,
-    /// The parent was found but not matched.
+    /// The parent was found but doesn't match.
     NotMatched,
 }
 

crates/rustic_core/src/commands/check.rs

@@ -262,7 +262,7 @@ fn check_packs(
     let mut index_collector = IndexCollector::new(if read_data {
         IndexType::Full
     } else {
-        IndexType::FullTrees
+        IndexType::DataIds
     });
 
     let mut process_pack = |p: IndexPack, check_time: bool| {

crates/rustic_core/src/crypto/aespoly1305.rs

@@ -9,17 +9,15 @@ use crate::{crypto::CryptoKey, error::CryptoErrorKind, error::RusticResult};
 pub(crate) type Nonce = aead::Nonce<Aes256CtrPoly1305Aes>;
 pub(crate) type AeadKey = aead::Key<Aes256CtrPoly1305Aes>;
 
-/// The `Key` is used to encrypt and decrypt data.
+/// The `Key` is used to encrypt/MAC and check/decrypt data.
 ///
-/// It is a 64 byte key that is used to derive the encryption, kdf, and random keys.
+/// It is a 64 byte key that is used to derive the AES256 encryption key and the numbers `k` and `r` used in the Poly1305AES MAC.
 ///
-/// The first 32 bytes are used for encryption.
+/// The first 32 bytes are used for the AES256 encryption.
 ///
-/// The next 16 bytes are used for the kdf.
+/// The next 16 bytes are used for the number `k` of Poly1305AES.
 ///
-/// The last 16 bytes are used for random data.
-///
-/// The key is generated randomly.
+/// The last 16 bytes are used for the number `r` of Poly1305AES.
 ///
 /// # Examples
 ///
@@ -40,7 +38,7 @@ pub(crate) type AeadKey = aead::Key<Aes256CtrPoly1305Aes>;
 pub struct Key(AeadKey);
 
 impl Key {
-    /// Create a new [`Key`] with a random key.
+    /// Create a new random [`Key`] using a suitable entropy source.
     #[must_use]
     pub fn new() -> Self {
         let mut key = AeadKey::default();
@@ -58,13 +56,13 @@ impl Key {
         Self(*AeadKey::from_slice(key))
     }
 
-    /// Create a new [`Key`] from the encryption, kdf, and random keys. The keys are concatenated together.
+    /// Create a new [`Key`] from the AES key and numbers `k` and `r` for Poly1305AES.
     ///
     /// # Arguments
     ///
-    /// * `encrypt` - The encryption key.
-    /// * `k` - The kdf key.
-    /// * `r` - The random key.
+    /// * `encrypt` - The AES key.
+    /// * `k` - The number k for Poly1305AES.
+    /// * `r` - The number r for Poly1305AES.
     #[must_use]
     pub fn from_keys(encrypt: &[u8], k: &[u8], r: &[u8]) -> Self {
         let mut key = AeadKey::default();
@@ -75,7 +73,7 @@ impl Key {
         Self(key)
     }
 
-    /// Returns the encryption, kdf, and random keys.
+    /// Returns the AES key and numbers `k`and `r` for Poly1305AES.
     #[must_use]
     pub fn to_keys(self) -> (Vec<u8>, Vec<u8>, Vec<u8>) {
         let mut encrypt = vec![0; 32];
@@ -90,15 +88,15 @@ impl Key {
 }
 
 impl CryptoKey for Key {
-    /// Returns the decrypted data from the given encrypted data.
+    /// Returns the decrypted data from the given encrypted/MACed data.
     ///
     /// # Arguments
     ///
-    /// * `data` - The encrypted data.
+    /// * `data` - The encrypted/MACed data.
     ///
     /// # Errors
     ///
-    /// If the data could not be decrypted.
+    /// If the MAC couldn't be checked.
     fn decrypt_data(&self, data: &[u8]) -> RusticResult<Vec<u8>> {
         if data.len() < 16 {
             return Err(CryptoErrorKind::CryptoKeyTooShort)?;
@@ -110,7 +108,7 @@ impl CryptoKey for Key {
             .map_err(|err| CryptoErrorKind::DataDecryptionFailed(err).into())
     }
 
-    /// Returns the encrypted data from the given data.
+    /// Returns the encrypted+MACed data from the given data.
     ///
     /// # Arguments
     ///

crates/rustic_core/src/index.rs

@@ -318,7 +318,7 @@ impl<BE: DecryptReadBackend> IndexBackend<BE> {
     ///
     /// If the index could not be read
     pub fn only_full_trees(be: &BE, p: &impl Progress) -> RusticResult<Self> {
-        Self::new_from_collector(be, p, IndexCollector::new(IndexType::FullTrees))
+        Self::new_from_collector(be, p, IndexCollector::new(IndexType::DataIds))
     }
 
     /// Convert the Arc<Index> to an Index

crates/rustic_core/src/index/binarysorted.rs

@@ -28,8 +28,8 @@ pub(crate) struct SortedEntry {
 pub enum IndexType {
     /// Index everything.
     Full,
-    // TODO: What is the difference between `FullTrees` and `Full`?
-    FullTrees,
+    /// Index only Ids for data blobs (+ full information for tree blobs)
+    DataIds,
     /// Index only trees.
     OnlyTrees,
 }
@@ -83,7 +83,7 @@ impl IndexCollector {
         collector.0[BlobType::Tree].entries = EntriesVariants::FullEntries(Vec::new());
         collector.0[BlobType::Data].entries = match tpe {
             IndexType::OnlyTrees => EntriesVariants::None,
-            IndexType::FullTrees => EntriesVariants::Ids(Vec::new()),
+            IndexType::DataIds => EntriesVariants::Ids(Vec::new()),
             IndexType::Full => EntriesVariants::FullEntries(Vec::new()),
         };
 
@@ -335,7 +335,7 @@ mod tests {
 
     #[test]
     fn all_index_types() {
-        for it in [IndexType::OnlyTrees, IndexType::FullTrees, IndexType::Full] {
+        for it in [IndexType::OnlyTrees, IndexType::DataIds, IndexType::Full] {
             let index = index(it);
 
             let id = parse("0000000000000000000000000000000000000000000000000000000000000000");
@@ -386,7 +386,7 @@ mod tests {
 
     #[test]
     fn full_trees() {
-        let index = index(IndexType::FullTrees);
+        let index = index(IndexType::DataIds);
 
         let id = parse("fac5e908151e565267570108127b96e6bae22bcdda1d3d867f63ed1555fc8aef");
         assert!(index.has(BlobType::Data, &id));

crates/rustic_core/src/repository.rs

@@ -969,16 +969,17 @@ impl<P: ProgressBars, S: Open> Repository<P, S> {
     }
 }
 
-// TODO: add documenation!
+/// A repository which is indexed such that all tree blobs are contained in the index.
 pub trait IndexedTree: Open {
     type I: IndexedBackend;
     fn index(&self) -> &Self::I;
 }
 
-// TODO: Repository is fully indexed
+/// A repository which is indexed such that all tree blobs are contained in the index
+/// and additionally the `Id`s of data blobs are also contained in the index.
 pub trait IndexedIds: IndexedTree {}
 
-// TODO: Repository is fully indexed
+/// A repository which is indexed such that all blob information is fully contained in the index.
 pub trait IndexedFull: IndexedIds {}
 
 impl<P, S: IndexedTree> IndexedTree for Repository<P, S> {