clean up use of u16s and patterns

Author: tertsdiepraam

src/uu/more/src/more.rs

@@ -98,10 +98,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
         println!("{panic_info}");
     }));
 
-    let matches = match uu_app().try_get_matches_from(args) {
-        Ok(m) => m,
-        Err(e) => return Err(e.into()),
-    };
+    let matches = uu_app().try_get_matches_from(args)?;
 
     let mut options = Options::from(&matches);
 
@@ -308,12 +305,12 @@ fn more(
         rows = number;
     }
 
-    let lines = break_buff(buff, usize::from(cols));
+    let lines = break_buff(buff, cols as usize);
 
     let mut pager = Pager::new(rows, lines, next_file, options);
 
-    if options.pattern.is_some() {
-        match search_pattern_in_file(&pager.lines, &options.pattern) {
+    if let Some(pat) = options.pattern.as_ref() {
+        match search_pattern_in_file(&pager.lines, pat) {
             Some(number) => pager.upper_mark = number,
             None => {
                 execute!(stdout, terminal::Clear(terminal::ClearType::CurrentLine))?;
@@ -446,7 +443,7 @@ struct Pager<'a> {
     // The current line at the top of the screen
     upper_mark: usize,
     // The number of rows that fit on the screen
-    content_rows: u16,
+    content_rows: usize,
     lines: Vec<&'a str>,
     next_file: Option<&'a str>,
     line_count: usize,
@@ -460,7 +457,7 @@ impl<'a> Pager<'a> {
         let line_count = lines.len();
         Self {
             upper_mark: options.from_line,
-            content_rows: rows.saturating_sub(1),
+            content_rows: rows.saturating_sub(1) as usize,
             lines,
             next_file,
             line_count,
@@ -481,21 +478,20 @@ impl<'a> Pager<'a> {
         // the upper mark must not grow past top of the screen at the end of the open file.
         if self
             .upper_mark
-            .saturating_add(self.content_rows as usize * 2)
-            .ge(&self.line_count)
+            .saturating_add(self.content_rows * 2)
+            >= self.line_count
         {
-            self.upper_mark = self.line_count - self.content_rows as usize;
+            self.upper_mark = self.line_count - self.content_rows;
             return;
         }
 
         self.upper_mark = self.upper_mark.saturating_add(self.content_rows.into());
     }
 
     fn page_up(&mut self) {
-        let content_row_usize: usize = self.content_rows.into();
         self.upper_mark = self
             .upper_mark
-            .saturating_sub(content_row_usize.saturating_add(self.line_squeezed));
+            .saturating_sub(self.content_rows.saturating_add(self.line_squeezed));
 
         if self.squeeze {
             let iter = self.lines.iter().take(self.upper_mark).rev();
@@ -520,7 +516,7 @@ impl<'a> Pager<'a> {
     // TODO: Deal with column size changes.
     fn page_resize(&mut self, _: u16, row: u16, option_line: Option<u16>) {
         if option_line.is_none() {
-            self.content_rows = row.saturating_sub(1);
+            self.content_rows = row.saturating_sub(1) as usize;
         };
     }
 
@@ -541,7 +537,7 @@ impl<'a> Pager<'a> {
         let mut displayed_lines = Vec::new();
         let mut iter = self.lines.iter().skip(self.upper_mark);
 
-        while displayed_lines.len() < self.content_rows as usize {
+        while displayed_lines.len() < self.content_rows {
             match iter.next() {
                 Some(line) => {
                     if self.squeeze {
@@ -608,13 +604,12 @@ impl<'a> Pager<'a> {
     }
 }
 
-fn search_pattern_in_file(lines: &[&str], pattern: &Option<String>) -> Option<usize> {
-    let pattern = pattern.clone().unwrap_or_default();
+fn search_pattern_in_file(lines: &[&str], pattern: &str) -> Option<usize> {
     if lines.is_empty() || pattern.is_empty() {
         return None;
     }
     for (line_number, line) in lines.iter().enumerate() {
-        if line.contains(pattern.as_str()) {
+        if line.contains(pattern) {
             return Some(line_number);
         }
     }
@@ -723,32 +718,32 @@ mod tests {
     #[test]
     fn test_search_pattern_empty_lines() {
         let lines = vec![];
-        let pattern = Some(String::from("pattern"));
-        assert_eq!(None, search_pattern_in_file(&lines, &pattern));
+        let pattern = "pattern";
+        assert_eq!(None, search_pattern_in_file(&lines, pattern));
     }
 
     #[test]
     fn test_search_pattern_empty_pattern() {
         let lines = vec!["line1", "line2"];
-        let pattern = None;
-        assert_eq!(None, search_pattern_in_file(&lines, &pattern));
+        let pattern = "";
+        assert_eq!(None, search_pattern_in_file(&lines, pattern));
     }
 
     #[test]
     fn test_search_pattern_found_pattern() {
         let lines = vec!["line1", "line2", "pattern"];
         let lines2 = vec!["line1", "line2", "pattern", "pattern2"];
         let lines3 = vec!["line1", "line2", "other_pattern"];
-        let pattern = Some(String::from("pattern"));
-        assert_eq!(2, search_pattern_in_file(&lines, &pattern).unwrap());
-        assert_eq!(2, search_pattern_in_file(&lines2, &pattern).unwrap());
-        assert_eq!(2, search_pattern_in_file(&lines3, &pattern).unwrap());
+        let pattern = "pattern";
+        assert_eq!(2, search_pattern_in_file(&lines, pattern).unwrap());
+        assert_eq!(2, search_pattern_in_file(&lines2, pattern).unwrap());
+        assert_eq!(2, search_pattern_in_file(&lines3, pattern).unwrap());
     }
 
     #[test]
     fn test_search_pattern_not_found_pattern() {
         let lines = vec!["line1", "line2", "something"];
-        let pattern = Some(String::from("pattern"));
-        assert_eq!(None, search_pattern_in_file(&lines, &pattern));
+        let pattern = "pattern";
+        assert_eq!(None, search_pattern_in_file(&lines, pattern));
     }
 }