refactor: handle unwrap (#16)

* refactor: handle unwrap

* fix: lint

Author: hirokisan

src/daterange.rs

@@ -9,7 +9,12 @@ pub fn get_monthly_date_ranges(
     if from.day() != 1 {
         return Err(anyhow::anyhow!("from must be 1st day of month"));
     }
-    if to.checked_add_signed(Duration::days(1)).unwrap().day() != 1 {
+    if to
+        .checked_add_signed(Duration::days(1))
+        .ok_or_else(|| anyhow::anyhow!("checked_add_signed"))?
+        .day()
+        != 1
+    {
         return Err(anyhow::anyhow!("to must be last day of month"));
     }
 
@@ -19,14 +24,16 @@ pub fn get_monthly_date_ranges(
     loop {
         let end = start
             .checked_add_months(Months::new(1))
-            .unwrap()
+            .ok_or_else(|| anyhow::anyhow!("checked_add_months"))?
             .pred_opt()
-            .unwrap();
+            .ok_or_else(|| anyhow::anyhow!("pred_opt"))?;
         result.push((start, end));
         if to == end {
             break;
         }
-        start = start.checked_add_months(Months::new(1)).unwrap()
+        start = start
+            .checked_add_months(Months::new(1))
+            .ok_or_else(|| anyhow::anyhow!("checked_add_months"))?
     }
 
     Ok(result)

src/github/client.rs

@@ -51,17 +51,25 @@ impl Client {
 
             match response {
                 Ok(res) => {
-                    let prs = &res.data.as_ref().unwrap().search;
+                    let prs = match res.data.as_ref() {
+                        Some(data) => &data.search,
+                        None => break,
+                    };
                     let has_next_page = prs.page_info.has_next_page;
                     let end_cursor = prs.page_info.end_cursor.clone();
 
-                    for item in prs.nodes.as_ref().unwrap().iter().flatten() {
-                        match item {
+                    match prs.nodes.as_ref() {
+                        Some(nodes) => {
+                            for node in nodes.iter().flatten() {
+                                match node {
                             pull_requests_query::PullRequestsQuerySearchNodes::PullRequest(pr) => {
                                 result.add(PullRequest::new(pr.clone()))
                             }
                             _ => continue,
                         };
+                            }
+                        }
+                        None => break,
                     }
 
                     if !has_next_page {
@@ -101,17 +109,25 @@ impl Client {
 
             match response {
                 Ok(res) => {
-                    let issues = &res.data.as_ref().unwrap().search;
+                    let issues = match res.data.as_ref() {
+                        Some(data) => &data.search,
+                        None => break,
+                    };
                     let has_next_page = issues.page_info.has_next_page;
                     let end_cursor = issues.page_info.end_cursor.clone();
 
-                    for item in issues.nodes.as_ref().unwrap().iter().flatten() {
-                        match item {
-                            issues_query::IssuesQuerySearchNodes::Issue(issue) => {
-                                result.add(Issue::new(issue.clone()))
+                    match issues.nodes.as_ref() {
+                        Some(nodes) => {
+                            for node in nodes.iter().flatten() {
+                                match node {
+                                    issues_query::IssuesQuerySearchNodes::Issue(issue) => {
+                                        result.add(Issue::new(issue.clone()))
+                                    }
+                                    _ => continue,
+                                };
                             }
-                            _ => continue,
-                        };
+                        }
+                        None => break,
                     }
 
                     if !has_next_page {

src/github/issue.rs

@@ -28,7 +28,7 @@ impl Issue {
             .nodes
             .as_ref()?
             .iter()
-            .map(|assignee| assignee.as_ref().unwrap().login.clone())
+            .filter_map(|assignee| assignee.as_ref().map(|assignee| assignee.login.clone()))
             .collect();
         if result.is_empty() {
             return None;
@@ -43,7 +43,11 @@ impl Issue {
             .nodes
             .as_ref()?
             .iter()
-            .map(|participant| participant.as_ref().unwrap().login.clone())
+            .filter_map(|participant| {
+                participant
+                    .as_ref()
+                    .map(|participant| participant.login.clone())
+            })
             .collect();
         if result.is_empty() {
             return None;
@@ -56,28 +60,26 @@ impl Issue {
     }
 
     pub fn comments_count(&self) -> i64 {
-        let comments = self.inner.comments.nodes.as_ref();
-
-        comments.unwrap().len() as i64
+        match self.inner.comments.nodes.as_ref() {
+            Some(nodes) => nodes.len() as i64,
+            None => 0,
+        }
     }
 
     pub fn comments_count_by(&self, by: &str) -> i64 {
-        let comments = self.inner.comments.nodes.as_ref();
-
-        comments
-            .as_ref()
-            .unwrap()
-            .iter()
-            .filter(|item| match item {
-                Some(item) => {
-                    if item.author.as_ref().is_none() {
-                        return false;
-                    }
-                    item.author.as_ref().unwrap().login == by
-                }
-                _ => false,
-            })
-            .count() as i64
+        match self.inner.comments.nodes.as_ref() {
+            Some(nodes) => nodes
+                .iter()
+                .filter(|item| match item {
+                    Some(item) => match item.author.as_ref() {
+                        Some(author) => author.login == by,
+                        None => false,
+                    },
+                    _ => false,
+                })
+                .count() as i64,
+            None => 0,
+        }
     }
 
     pub fn closed_at(&self) -> Option<DateTime> {
@@ -98,7 +100,7 @@ impl Issue {
             return None;
         }
 
-        let closed_event = timeline_items.first().unwrap();
+        let closed_event = timeline_items.first()?;
 
         if closed_event.actor.as_ref()?.login != by {
             return None;

src/github/issues.rs

@@ -77,11 +77,13 @@ impl Issues {
         let mut count = 0;
         let mut total_seconds = 0;
         for issue in self.inner.iter() {
-            if issue.closed_at().is_none() {
-                continue;
-            };
-            count += 1;
-            total_seconds += issue.closed_at().unwrap().diff_seconds(&issue.created_at());
+            match issue.closed_at() {
+                Some(closed_at) => {
+                    count += 1;
+                    total_seconds += closed_at.diff_seconds(&issue.created_at());
+                }
+                None => continue,
+            }
         }
         if count == 0 {
             0.0
@@ -94,14 +96,13 @@ impl Issues {
         let mut count = 0;
         let mut total_seconds = 0;
         for issue in self.inner.iter() {
-            if issue.closed_at_by(by).is_none() {
-                continue;
-            };
-            count += 1;
-            total_seconds += issue
-                .closed_at_by(by)
-                .unwrap()
-                .diff_seconds(&issue.created_at());
+            match issue.closed_at_by(by) {
+                Some(closed_at_by) => {
+                    count += 1;
+                    total_seconds += closed_at_by.diff_seconds(&issue.created_at());
+                }
+                None => continue,
+            }
         }
         if count == 0 {
             0.0