enshort to common variable name

src/profile/bookmark.rs

@@ -28,12 +28,12 @@ impl Bookmark {
         match database.records(None) {
             Ok(records) => {
                 for record in records {
-                    if let Err(reason) = memory.add(record.request, record.id) {
-                        todo!("{}", reason.to_string())
+                    if let Err(e) = memory.add(record.request, record.id) {
+                        todo!("{}", e.to_string())
                     }
                 }
             }
-            Err(reason) => todo!("{}", reason.to_string()),
+            Err(e) => todo!("{}", e.to_string()),
         }
 
         // Return new `Self`

src/profile/bookmark/database.rs

@@ -52,7 +52,7 @@ impl Database {
         // Done
         match tx.commit() {
             Ok(_) => Ok(id),
-            Err(reason) => Err(reason),
+            Err(e) => Err(e),
         }
     }
 
@@ -66,9 +66,9 @@ impl Database {
         match delete(&tx, id) {
             Ok(_) => match tx.commit() {
                 Ok(_) => Ok(()),
-                Err(reason) => Err(reason),
+                Err(e) => Err(e),
             },
-            Err(reason) => Err(reason),
+            Err(e) => Err(e),
         }
     }
 }

src/profile/identity.rs

@@ -29,16 +29,16 @@ impl Identity {
                 Some(identity) => identity.id,
                 None => match database.add(profile_id, true) {
                     Ok(id) => id,
-                    Err(reason) => return Err(Error::Database(reason)),
+                    Err(e) => return Err(Error::Database(e)),
                 },
             },
-            Err(reason) => return Err(Error::Database(reason)),
+            Err(e) => return Err(Error::Database(e)),
         });
 
         // Init gemini component
         let gemini = Rc::new(match Gemini::new(connection, profile_identity_id) {
             Ok(result) => result,
-            Err(reason) => return Err(Error::Gemini(reason)),
+            Err(e) => return Err(Error::Gemini(e)),
         });
 
         // Done
@@ -53,8 +53,8 @@ impl Identity {
 
 pub fn migrate(tx: &Transaction) -> Result<(), String> {
     // Migrate self components
-    if let Err(reason) = database::init(tx) {
-        return Err(reason.to_string());
+    if let Err(e) = database::init(tx) {
+        return Err(e.to_string());
     }
 
     // Delegate migration to childs

src/profile/identity/database.rs

@@ -59,7 +59,7 @@ impl Database {
         // Done
         match tx.commit() {
             Ok(_) => Ok(id),
-            Err(reason) => Err(reason),
+            Err(e) => Err(e),
         }
     }
 }

src/profile/identity/error.rs

@@ -9,11 +9,11 @@ pub enum Error {
 impl Display for Error {
     fn fmt(&self, f: &mut Formatter) -> Result {
         match self {
-            Self::Database(reason) => {
-                write!(f, "Database error: {reason}")
+            Self::Database(e) => {
+                write!(f, "Database error: {e}")
             }
-            Self::Gemini(reason) => {
-                write!(f, "Could not init Gemini identity: {reason}")
+            Self::Gemini(e) => {
+                write!(f, "Could not init Gemini identity: {e}")
             }
         }
     }

src/profile/identity/gemini.rs

@@ -36,7 +36,7 @@ impl Gemini {
         // Init components
         let auth = match Auth::new(connection.clone()) {
             Ok(auth) => Rc::new(auth),
-            Err(reason) => return Err(Error::Auth(reason)),
+            Err(e) => return Err(Error::Auth(e)),
         };
         let database = Rc::new(Database::new(connection, profile_identity_id.clone()));
         let memory = Rc::new(Memory::new());
@@ -64,7 +64,7 @@ impl Gemini {
                 self.index()?;
                 Ok(profile_identity_gemini_id)
             }
-            Err(reason) => Err(Error::Database(reason)),
+            Err(e) => Err(Error::Database(e)),
         }
     }
 
@@ -76,7 +76,7 @@ impl Gemini {
                     self.index()?;
                     Ok(())
                 }
-                Err(reason) => Err(Error::Database(reason)),
+                Err(e) => Err(Error::Database(e)),
             },
             Err(e) => Err(Error::Auth(e)),
         }
@@ -97,27 +97,27 @@ impl Gemini {
             name,
         ) {
             Ok(pem) => self.add(&pem),
-            Err(reason) => Err(Error::Certificate(reason)),
+            Err(e) => Err(Error::Certificate(e)),
         }
     }
 
     /// Create new `Memory` index from `Database` for `Self`
     pub fn index(&self) -> Result<(), Error> {
         // Clear previous records
-        if let Err(reason) = self.memory.clear() {
-            return Err(Error::Memory(reason));
+        if let Err(e) = self.memory.clear() {
+            return Err(Error::Memory(e));
         }
 
         // Build new index
         match self.database.records() {
             Ok(records) => {
                 for record in records {
-                    if let Err(reason) = self.memory.add(record.id, record.pem) {
-                        return Err(Error::Memory(reason));
+                    if let Err(e) = self.memory.add(record.id, record.pem) {
+                        return Err(Error::Memory(e));
                     }
                 }
             }
-            Err(reason) => return Err(Error::Database(reason)),
+            Err(e) => return Err(Error::Database(e)),
         };
 
         Ok(())
@@ -135,7 +135,7 @@ impl Gemini {
                         pem,
                     });
                 }
-                Err(reason) => todo!("{:?}", reason.to_string()),
+                Err(e) => todo!("{:?}", e.to_string()),
             }
         }
         None

src/profile/identity/gemini/auth.rs

@@ -49,7 +49,7 @@ impl Auth {
         let profile_identity_gemini_auth_id =
             match self.database.add(profile_identity_gemini_id, scope) {
                 Ok(id) => id,
-                Err(reason) => return Err(Error::Database(reason)),
+                Err(e) => return Err(Error::Database(e)),
             };
 
         // Reindex
@@ -64,12 +64,12 @@ impl Auth {
         match self.database.records_scope(Some(scope)) {
             Ok(records) => {
                 for record in records {
-                    if let Err(reason) = self.database.delete(record.id) {
-                        return Err(Error::Database(reason));
+                    if let Err(e) = self.database.delete(record.id) {
+                        return Err(Error::Database(e));
                     }
                 }
             }
-            Err(reason) => return Err(Error::Database(reason)),
+            Err(e) => return Err(Error::Database(e)),
         }
         self.index()?;
         Ok(())
@@ -80,12 +80,12 @@ impl Auth {
         match self.database.records_ref(profile_identity_gemini_id) {
             Ok(records) => {
                 for record in records {
-                    if let Err(reason) = self.database.delete(record.id) {
-                        return Err(Error::Database(reason));
+                    if let Err(e) = self.database.delete(record.id) {
+                        return Err(Error::Database(e));
                     }
                 }
             }
-            Err(reason) => return Err(Error::Database(reason)),
+            Err(e) => return Err(Error::Database(e)),
         }
         self.index()?;
         Ok(())
@@ -94,23 +94,23 @@ impl Auth {
     /// Create new `Memory` index from `Database` for `Self`
     pub fn index(&self) -> Result<(), Error> {
         // Clear previous records
-        if let Err(reason) = self.memory.clear() {
-            return Err(Error::Memory(reason));
+        if let Err(e) = self.memory.clear() {
+            return Err(Error::Memory(e));
         }
 
         // Build new index
         match self.database.records_scope(None) {
             Ok(records) => {
                 for record in records {
-                    if let Err(reason) = self
+                    if let Err(e) = self
                         .memory
                         .add(record.scope, record.profile_identity_gemini_id)
                     {
-                        return Err(Error::Memory(reason));
+                        return Err(Error::Memory(e));
                     }
                 }
             }
-            Err(reason) => return Err(Error::Database(reason)),
+            Err(e) => return Err(Error::Database(e)),
         }
 
         Ok(())

src/profile/identity/gemini/auth/database.rs

@@ -37,7 +37,7 @@ impl Database {
         // Done
         match tx.commit() {
             Ok(_) => Ok(id),
-            Err(reason) => Err(reason),
+            Err(e) => Err(e),
         }
     }
 
@@ -53,7 +53,7 @@ impl Database {
         // Done
         match tx.commit() {
             Ok(_) => Ok(()),
-            Err(reason) => Err(reason),
+            Err(e) => Err(e),
         }
     }
 

src/profile/identity/gemini/auth/error.rs

@@ -9,8 +9,8 @@ pub enum Error {
 impl Display for Error {
     fn fmt(&self, f: &mut Formatter) -> Result {
         match self {
-            Self::Database(reason) => write!(f, "Database error: {reason}"),
-            Self::Memory(reason) => write!(f, "Memory error: {reason}"),
+            Self::Database(e) => write!(f, "Database error: {e}"),
+            Self::Memory(e) => write!(f, "Memory error: {e}"),
         }
     }
 }

src/profile/identity/gemini/database.rs

@@ -41,7 +41,7 @@ impl Database {
         // Done
         match tx.commit() {
             Ok(_) => Ok(id),
-            Err(reason) => Err(reason),
+            Err(e) => Err(e),
         }
     }
 
@@ -57,7 +57,7 @@ impl Database {
         // Done
         match tx.commit() {
             Ok(_) => Ok(()),
-            Err(reason) => Err(reason),
+            Err(e) => Err(e),
         }
     }
 

src/profile/identity/gemini/identity.rs

@@ -15,7 +15,7 @@ impl Identity {
     pub fn to_tls_certificate(&self) -> Result<TlsCertificate, Error> {
         match TlsCertificate::from_pem(&self.pem) {
             Ok(certificate) => Ok(certificate),
-            Err(reason) => Err(Error::TlsCertificate(reason)),
+            Err(e) => Err(Error::TlsCertificate(e)),
         }
     }
 }