refactor: apply clippy auto-fixes (162 warnings resolved)

- Fix needless borrows and references
- Collapse nested if statements
- Replace manual strip_prefix with str::strip_prefix()
- Remove redundant closures in map/unwrap_or_else
- Use Iterator::next_back() instead of rev().next()
- Simplify map_or patterns
- Use std::io::Error::other() instead of new(ErrorKind::Other, ..)
- Use div_ceil() instead of manual ceiling division
- Consolidate format! string arguments
- Various other idiomatic Rust improvements

39 files changed, 220 insertions(+), 320 deletions(-)

src/domain/entities/calendar_event.rs

@@ -109,15 +109,14 @@ impl CalendarEvent {
         }
         
         // Validate RRULE if provided (basic validation)
-        if let Some(ref rule) = rrule {
-            if !rule.starts_with("FREQ=") {
+        if let Some(ref rule) = rrule
+            && !rule.starts_with("FREQ=") {
                 return Err(DomainError::new(
                     ErrorKind::InvalidInput,
                     "CalendarEvent",
                     "Recurrence rule must start with FREQ=",
                 ));
             }
-        }
         
         // Validate iCalendar data (basic validation)
         if !ical_data.contains("BEGIN:VEVENT") || !ical_data.contains("END:VEVENT") {
@@ -500,15 +499,14 @@ impl CalendarEvent {
      */
     pub fn update_rrule(&mut self, rrule: Option<String>) -> Result<()> {
         // Validate RRULE if provided (basic validation)
-        if let Some(ref rule) = rrule {
-            if !rule.starts_with("FREQ=") {
+        if let Some(ref rule) = rrule
+            && !rule.starts_with("FREQ=") {
                 return Err(DomainError::new(
                     ErrorKind::InvalidInput,
                     "CalendarEvent",
                     "Recurrence rule must start with FREQ=",
                 ));
             }
-        }
         
         self.rrule = rrule.clone();
         self.updated_at = Utc::now();
@@ -547,17 +545,15 @@ impl CalendarEvent {
         self.description = Self::extract_ical_property(&ical_data, "DESCRIPTION");
         self.location = Self::extract_ical_property(&ical_data, "LOCATION");
         
-        if let Some(dtstart) = Self::extract_ical_property(&ical_data, "DTSTART") {
-            if let Ok(start_time) = Self::parse_ical_datetime(&dtstart) {
+        if let Some(dtstart) = Self::extract_ical_property(&ical_data, "DTSTART")
+            && let Ok(start_time) = Self::parse_ical_datetime(&dtstart) {
                 self.start_time = start_time;
             }
-        }
         
-        if let Some(dtend) = Self::extract_ical_property(&ical_data, "DTEND") {
-            if let Ok(end_time) = Self::parse_ical_datetime(&dtend) {
+        if let Some(dtend) = Self::extract_ical_property(&ical_data, "DTEND")
+            && let Ok(end_time) = Self::parse_ical_datetime(&dtend) {
                 self.end_time = end_time;
             }
-        }
         
         // Update all-day status based on DTSTART
         if let Some(dtstart) = Self::extract_ical_property(&ical_data, "DTSTART") {
@@ -612,13 +608,13 @@ impl CalendarEvent {
                 let until_start = until_pos + 6; // "UNTIL=" is 6 chars
                 if let Some(until_end) = rrule[until_start..].find(';') {
                     let until_str = &rrule[until_start..until_start+until_end];
-                    if let Ok(until_date) = Self::parse_ical_datetime(&until_str) {
+                    if let Ok(until_date) = Self::parse_ical_datetime(until_str) {
                         return until_date >= *start;
                     }
                 } else {
                     // UNTIL is the last part of the rule
                     let until_str = &rrule[until_start..];
-                    if let Ok(until_date) = Self::parse_ical_datetime(&until_str) {
+                    if let Ok(until_date) = Self::parse_ical_datetime(until_str) {
                         return until_date >= *start;
                     }
                 }
@@ -677,7 +673,7 @@ impl CalendarEvent {
     fn parse_ical_datetime(datetime: &str) -> std::result::Result<DateTime<Utc>, String> {
         // Handle VALUE=DATE format
         if datetime.contains("VALUE=DATE") {
-            let date_str = datetime.split(':').last().unwrap_or("");
+            let date_str = datetime.split(':').next_back().unwrap_or("");
             if date_str.len() != 8 {
                 return Err("Invalid date format".to_string());
             }
@@ -696,7 +692,7 @@ impl CalendarEvent {
         }
         
         // Handle standard UTC format (20230101T120000Z)
-        let datetime_str = datetime.split(':').last().unwrap_or(datetime);
+        let datetime_str = datetime.split(':').next_back().unwrap_or(datetime);
         if datetime_str.len() < 15 || !datetime_str.ends_with('Z') {
             return Err("Invalid datetime format".to_string());
         }

src/domain/entities/share.rs

@@ -262,9 +262,9 @@ mod tests {
         assert_eq!(share.item_id(), "test_file_id");
         assert_eq!(*share.item_type(), ShareItemType::File);
         assert_eq!(share.created_by(), "user123");
-        assert_eq!(share.permissions().read(), true);
-        assert_eq!(share.permissions().write(), false);
-        assert_eq!(share.permissions().reshare(), false);
+        assert!(share.permissions().read());
+        assert!(!share.permissions().write());
+        assert!(!share.permissions().reshare());
         assert!(!share.has_password());
         assert!(share.expires_at().is_none());
         assert_eq!(share.access_count(), 0);

src/domain/entities/user.rs

@@ -59,21 +59,15 @@ impl User {
     ) -> UserResult<Self> {
         // Validations
         if username.is_empty() || username.len() < 3 || username.len() > 32 {
-            return Err(UserError::InvalidUsername(format!(
-                "Username must be between 3 and 32 characters"
-            )));
+            return Err(UserError::InvalidUsername("Username must be between 3 and 32 characters".to_string()));
         }
         
         if !email.contains('@') || email.len() < 5 {
-            return Err(UserError::ValidationError(format!(
-                "Invalid email"
-            )));
+            return Err(UserError::ValidationError("Invalid email".to_string()));
         }
         
         if password_hash.is_empty() {
-            return Err(UserError::InvalidPassword(format!(
-                "Password hash cannot be empty"
-            )));
+            return Err(UserError::InvalidPassword("Password hash cannot be empty".to_string()));
         }
         
         let now = Utc::now();