From 5914238724f9f75b853289aad88a4c6d7a9e5845 Mon Sep 17 00:00:00 2001
From: rhysd <lin90162@yahoo.co.jp>
Date: Thu, 30 Jun 2022 19:26:03 +0900
Subject: [PATCH 01/18] implement minimal text search

- Set query with `TextArea::set_search_pattern`
- Move cursor to next match `TextArea::search_forward`
- Move cursor to previous match `TextArea::search_back`
---
 Cargo.toml      |   4 +-
 src/textarea.rs | 103 ++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 106 insertions(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index fbb1d83..38f78be 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -24,9 +24,11 @@ include = [
 default = ["crossterm"]
 crossterm = ["dep:crossterm", "tui/crossterm"]
 termion = ["dep:termion", "tui/termion"]
+search = ["dep:regex"]
 
 [dependencies]
 crossterm = { version = "0.23", optional = true }
+regex = { version = "1", optional = true }
 termion = { version = "1.5", optional = true }
 tui = { version = "0.18", default-features = false }
 
@@ -40,7 +42,7 @@ required-features = ["termion"]
 
 [[example]]
 name = "editor"
-required-features = ["crossterm"]
+required-features = ["crossterm", "search"]
 
 [[example]]
 name = "split"
diff --git a/src/textarea.rs b/src/textarea.rs
index 3a7c10a..38247a4 100644
--- a/src/textarea.rs
+++ b/src/textarea.rs
@@ -2,6 +2,8 @@ use crate::cursor::CursorMove;
 use crate::history::{Edit, EditKind, History};
 use crate::input::{Input, Key};
 use crate::word::{find_word_end_forward, find_word_start_backward};
+#[cfg(feature = "search")]
+use regex::Regex;
 use std::borrow::Cow;
 use std::sync::atomic::{AtomicU16, Ordering};
 use tui::buffer::Buffer;
@@ -48,6 +50,8 @@ pub struct TextArea<'a> {
     scroll_top: (AtomicU16, AtomicU16),
     cursor_style: Style,
     yank: String,
+    #[cfg(feature = "search")]
+    search: Option<Regex>,
 }
 
 /// Convert any iterator whose elements can be converted into [`String`] into [`TextArea`]. Each [`String`] element is
@@ -142,6 +146,8 @@ impl<'a> TextArea<'a> {
             scroll_top: (AtomicU16::new(0), AtomicU16::new(0)),
             cursor_style: Style::default().add_modifier(Modifier::REVERSED),
             yank: String::new(),
+            #[cfg(feature = "search")]
+            search: None,
         }
     }
 
@@ -1326,6 +1332,103 @@ impl<'a> TextArea<'a> {
     pub fn set_yank_text(&mut self, text: impl Into<String>) {
         self.yank = text.into();
     }
+
+    #[cfg(feature = "search")]
+    pub fn set_search_pattern(&mut self, query: impl AsRef<str>) -> Result<(), regex::Error> {
+        let query = query.as_ref();
+        match &self.search {
+            Some(r) if r.as_str() == query => {}
+            _ if query.is_empty() => self.search = None,
+            _ => self.search = Some(Regex::new(query)?),
+        }
+        Ok(())
+    }
+
+    #[cfg(feature = "search")]
+    pub fn search_forward(&mut self) -> bool {
+        let pat = if let Some(pat) = &self.search {
+            pat
+        } else {
+            return false;
+        };
+        let (row, col) = self.cursor;
+
+        // Search current line
+        {
+            let line = &self.lines[row];
+            // Avoid matching to current cursor position
+            if let Some((i, _)) = line.char_indices().nth(col + 1) {
+                if let Some(m) = pat.find_at(line, i) {
+                    let col = col + 1 + line[i..m.start()].chars().count();
+                    self.cursor = (row, col);
+                    return true;
+                }
+            }
+        }
+
+        // Search lines after cursor
+        for (i, line) in self.lines[row + 1..].iter().enumerate() {
+            if let Some(m) = pat.find(line) {
+                let col = line[..m.start()].chars().count();
+                self.cursor = (row + 1 + i, col);
+                return true;
+            }
+        }
+
+        // Search lines before cursor (wrap)
+        for (i, line) in self.lines[..row].iter().enumerate() {
+            if let Some(m) = pat.find(line) {
+                let col = line[..m.start()].chars().count();
+                self.cursor = (i, col);
+                return true;
+            }
+        }
+
+        false
+    }
+
+    #[cfg(feature = "search")]
+    pub fn search_back(&mut self) -> bool {
+        let pat = if let Some(pat) = &self.search {
+            pat
+        } else {
+            return false;
+        };
+        let (row, col) = self.cursor;
+
+        // Search current line
+        if col > 0 {
+            let line = &self.lines[row];
+            // Avoid matching to current cursor position
+            if let Some((i, _)) = line.char_indices().nth(col - 1) {
+                if let Some(m) = pat.find_iter(line).take_while(|m| m.start() <= i).last() {
+                    let col = line[..m.start()].chars().count();
+                    self.cursor = (row, col);
+                    return true;
+                }
+            }
+        }
+
+        // Search lines before cursor
+        for (i, line) in self.lines[..row].iter().enumerate().rev() {
+            if let Some(m) = pat.find(line) {
+                let col = line[..m.start()].chars().count();
+                self.cursor = (i, col);
+                return true;
+            }
+        }
+
+        // Search lines after cursor (wrap)
+        for (i, line) in self.lines[row + 1..].iter().enumerate().rev() {
+            if let Some(m) = pat.find(line) {
+                let col = line[..m.start()].chars().count();
+                self.cursor = (row + 1 + i, col);
+                return true;
+            }
+        }
+
+        false
+    }
 }
 
 struct Renderer<'a> {

From 68a18b2ae0db957ee4db451970d6220d5c460722 Mon Sep 17 00:00:00 2001
From: rhysd <lin90162@yahoo.co.jp>
Date: Fri, 1 Jul 2022 23:07:02 +0900
Subject: [PATCH 02/18] highlight searched text

---
 src/textarea.rs | 170 +++++++++++++++++++++++++++++++++++++-----------
 1 file changed, 131 insertions(+), 39 deletions(-)

diff --git a/src/textarea.rs b/src/textarea.rs
index 38247a4..1983c66 100644
--- a/src/textarea.rs
+++ b/src/textarea.rs
@@ -5,10 +5,11 @@ use crate::word::{find_word_end_forward, find_word_start_backward};
 #[cfg(feature = "search")]
 use regex::Regex;
 use std::borrow::Cow;
+use std::cmp;
 use std::sync::atomic::{AtomicU16, Ordering};
 use tui::buffer::Buffer;
 use tui::layout::Rect;
-use tui::style::{Modifier, Style};
+use tui::style::{Color, Modifier, Style};
 use tui::text::{Span, Spans, Text};
 use tui::widgets::{Block, Paragraph, Widget};
 
@@ -17,6 +18,41 @@ fn spaces(size: u8) -> &'static str {
     &SPACES[..size as usize]
 }
 
+fn num_digits(i: usize) -> u8 {
+    f64::log10(i as f64) as u8 + 1
+}
+
+// Highlight boundary in line
+enum Boundary {
+    Cursor(Style),
+    #[cfg(feature = "search")]
+    Search(Style),
+    End,
+}
+
+impl Boundary {
+    fn cmp(&self, other: &Boundary) -> cmp::Ordering {
+        fn rank(b: &Boundary) -> u8 {
+            match b {
+                Boundary::Cursor(_) => 2,
+                #[cfg(feature = "search")]
+                Boundary::Search(_) => 1,
+                Boundary::End => 0,
+            }
+        }
+        rank(self).cmp(&rank(other))
+    }
+
+    fn style(&self) -> Option<Style> {
+        match self {
+            Boundary::Cursor(s) => Some(*s),
+            #[cfg(feature = "search")]
+            Boundary::Search(s) => Some(*s),
+            Boundary::End => None,
+        }
+    }
+}
+
 /// A type to manage state of textarea.
 ///
 /// [`TextArea::default`] creates an empty textarea. [`TextArea::new`] creates a textarea with given text lines.
@@ -51,7 +87,9 @@ pub struct TextArea<'a> {
     cursor_style: Style,
     yank: String,
     #[cfg(feature = "search")]
-    search: Option<Regex>,
+    search_pat: Option<Regex>,
+    #[cfg(feature = "search")]
+    search_style: Style,
 }
 
 /// Convert any iterator whose elements can be converted into [`String`] into [`TextArea`]. Each [`String`] element is
@@ -147,7 +185,9 @@ impl<'a> TextArea<'a> {
             cursor_style: Style::default().add_modifier(Modifier::REVERSED),
             yank: String::new(),
             #[cfg(feature = "search")]
-            search: None,
+            search_pat: None,
+            #[cfg(feature = "search")]
+            search_style: Style::default().bg(Color::Blue),
         }
     }
 
@@ -942,6 +982,77 @@ impl<'a> TextArea<'a> {
         }
     }
 
+    fn line_spans<'b>(&'b self, line: &'b str, row: usize, lnum_len: u8) -> Vec<Span<'b>> {
+        let mut spans = vec![];
+
+        if let Some(style) = self.line_number_style {
+            let pad = spaces(lnum_len - num_digits(row + 1) + 1);
+            spans.push(Span::styled(format!("{}{} ", pad, row + 1), style));
+        }
+
+        let mut boundaries = vec![]; // TODO: Consider smallvec
+        let mut cursor_at_end = false;
+
+        let style_begin = if row == self.cursor.0 {
+            if let Some((start, c)) = line.char_indices().nth(self.cursor.1) {
+                boundaries.push((Boundary::Cursor(self.cursor_style), start));
+                boundaries.push((Boundary::End, start + c.len_utf8()));
+            } else {
+                cursor_at_end = true;
+            }
+            self.cursor_line_style
+        } else {
+            Style::default()
+        };
+
+        #[cfg(feature = "search")]
+        if let Some(pat) = &self.search_pat {
+            for m in pat.find_iter(line) {
+                boundaries.push((Boundary::Search(self.search_style), m.start()));
+                boundaries.push((Boundary::End, m.end()));
+            }
+        }
+
+        if boundaries.is_empty() {
+            spans.push(Span::raw(self.replace_tabs(line)));
+            return spans;
+        }
+
+        boundaries.sort_unstable_by(|(l, i), (r, j)| match i.cmp(j) {
+            cmp::Ordering::Equal => l.cmp(r),
+            o => o,
+        });
+
+        let mut boundaries = boundaries.into_iter();
+        let mut style = style_begin;
+        let mut start = 0;
+        let mut stack = vec![];
+
+        loop {
+            if let Some((next_boundary, end)) = boundaries.next() {
+                if start < end {
+                    spans.push(Span::styled(self.replace_tabs(&line[start..end]), style));
+                }
+
+                style = if let Some(s) = next_boundary.style() {
+                    stack.push(style);
+                    s
+                } else {
+                    stack.pop().unwrap_or(style_begin)
+                };
+                start = end;
+            } else {
+                if start != line.len() {
+                    spans.push(Span::styled(self.replace_tabs(&line[start..]), style));
+                }
+                if cursor_at_end {
+                    spans.push(Span::styled(" ", self.cursor_style));
+                }
+                return spans;
+            }
+        }
+    }
+
     /// Build a tui-rs widget to render the current state of the textarea. The widget instance returned from this
     /// method can be rendered with [`tui::terminal::Frame::render_widget`].
     /// ```no_run
@@ -969,39 +1080,10 @@ impl<'a> TextArea<'a> {
     /// }
     /// ```
     pub fn widget(&'a self) -> impl Widget + 'a {
-        fn num_digits(i: usize) -> u8 {
-            f64::log10(i as f64) as u8 + 1
-        }
-
         let mut lines = Vec::with_capacity(self.lines.len());
-        let line_number_len = num_digits(self.lines.len());
+        let lnum_len = num_digits(self.lines.len());
         for (i, l) in self.lines.iter().map(String::as_str).enumerate() {
-            let mut spans = vec![];
-
-            if let Some(style) = self.line_number_style {
-                let pad = spaces(line_number_len - num_digits(i + 1) + 1);
-                spans.push(Span::styled(format!("{}{} ", pad, i + 1), style));
-            }
-
-            if i == self.cursor.0 {
-                if let Some((i, c)) = l.char_indices().nth(self.cursor.1) {
-                    let j = i + c.len_utf8();
-                    spans.extend_from_slice(&[
-                        Span::styled(self.replace_tabs(&l[..i]), self.cursor_line_style),
-                        Span::styled(self.replace_tabs(&l[i..j]), self.cursor_style),
-                        Span::styled(self.replace_tabs(&l[j..]), self.cursor_line_style),
-                    ]);
-                } else {
-                    // When cursor is at the end of line
-                    spans.extend_from_slice(&[
-                        Span::styled(self.replace_tabs(l), self.cursor_line_style),
-                        Span::styled(" ", self.cursor_style),
-                    ]);
-                }
-            } else {
-                spans.push(Span::raw(self.replace_tabs(l)));
-            }
-
+            let spans = self.line_spans(l, i, lnum_len);
             lines.push(Spans::from(spans));
         }
 
@@ -1336,17 +1418,17 @@ impl<'a> TextArea<'a> {
     #[cfg(feature = "search")]
     pub fn set_search_pattern(&mut self, query: impl AsRef<str>) -> Result<(), regex::Error> {
         let query = query.as_ref();
-        match &self.search {
+        match &self.search_pat {
             Some(r) if r.as_str() == query => {}
-            _ if query.is_empty() => self.search = None,
-            _ => self.search = Some(Regex::new(query)?),
+            _ if query.is_empty() => self.search_pat = None,
+            _ => self.search_pat = Some(Regex::new(query)?),
         }
         Ok(())
     }
 
     #[cfg(feature = "search")]
     pub fn search_forward(&mut self) -> bool {
-        let pat = if let Some(pat) = &self.search {
+        let pat = if let Some(pat) = &self.search_pat {
             pat
         } else {
             return false;
@@ -1389,7 +1471,7 @@ impl<'a> TextArea<'a> {
 
     #[cfg(feature = "search")]
     pub fn search_back(&mut self) -> bool {
-        let pat = if let Some(pat) = &self.search {
+        let pat = if let Some(pat) = &self.search_pat {
             pat
         } else {
             return false;
@@ -1429,6 +1511,16 @@ impl<'a> TextArea<'a> {
 
         false
     }
+
+    #[cfg(feature = "search")]
+    pub fn search_style(&self) -> Style {
+        self.search_style
+    }
+
+    #[cfg(feature = "search")]
+    pub fn set_search_style(&mut self, style: Style) {
+        self.search_style = style;
+    }
 }
 
 struct Renderer<'a> {

From 0ed3dc2081ac37880195ec5ffd11324bab9dbd94 Mon Sep 17 00:00:00 2001
From: rhysd <lin90162@yahoo.co.jp>
Date: Thu, 7 Jul 2022 13:02:06 +0900
Subject: [PATCH 03/18] add `match_current` parameter to
 `search_forward`/`search_back`

---
 src/textarea.rs | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/textarea.rs b/src/textarea.rs
index 1983c66..f066f1d 100644
--- a/src/textarea.rs
+++ b/src/textarea.rs
@@ -1427,7 +1427,7 @@ impl<'a> TextArea<'a> {
     }
 
     #[cfg(feature = "search")]
-    pub fn search_forward(&mut self) -> bool {
+    pub fn search_forward(&mut self, match_current: bool) -> bool {
         let pat = if let Some(pat) = &self.search_pat {
             pat
         } else {
@@ -1435,13 +1435,13 @@ impl<'a> TextArea<'a> {
         };
         let (row, col) = self.cursor;
 
-        // Search current line
+        // Search current line after cursor
         {
             let line = &self.lines[row];
-            // Avoid matching to current cursor position
-            if let Some((i, _)) = line.char_indices().nth(col + 1) {
+            let start_col = if match_current { col } else { col + 1 };
+            if let Some((i, _)) = line.char_indices().nth(start_col) {
                 if let Some(m) = pat.find_at(line, i) {
-                    let col = col + 1 + line[i..m.start()].chars().count();
+                    let col = start_col + line[i..m.start()].chars().count();
                     self.cursor = (row, col);
                     return true;
                 }
@@ -1470,7 +1470,7 @@ impl<'a> TextArea<'a> {
     }
 
     #[cfg(feature = "search")]
-    pub fn search_back(&mut self) -> bool {
+    pub fn search_back(&mut self, match_current: bool) -> bool {
         let pat = if let Some(pat) = &self.search_pat {
             pat
         } else {
@@ -1478,11 +1478,11 @@ impl<'a> TextArea<'a> {
         };
         let (row, col) = self.cursor;
 
-        // Search current line
+        // Search current line before cursor
         if col > 0 {
+            let start_col = if match_current { col } else { col - 1 };
             let line = &self.lines[row];
-            // Avoid matching to current cursor position
-            if let Some((i, _)) = line.char_indices().nth(col - 1) {
+            if let Some((i, _)) = line.char_indices().nth(start_col) {
                 if let Some(m) = pat.find_iter(line).take_while(|m| m.start() <= i).last() {
                     let col = line[..m.start()].chars().count();
                     self.cursor = (row, col);

From 043f5b9525d789e0c381e7111e6dd035f5fc2194 Mon Sep 17 00:00:00 2001
From: rhysd <lin90162@yahoo.co.jp>
Date: Thu, 7 Jul 2022 15:49:53 +0900
Subject: [PATCH 04/18] fix rendering cursor at end of line

---
 src/textarea.rs | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/textarea.rs b/src/textarea.rs
index f066f1d..86d62a1 100644
--- a/src/textarea.rs
+++ b/src/textarea.rs
@@ -1015,6 +1015,9 @@ impl<'a> TextArea<'a> {
 
         if boundaries.is_empty() {
             spans.push(Span::raw(self.replace_tabs(line)));
+            if cursor_at_end {
+                spans.push(Span::styled(" ", self.cursor_style));
+            }
             return spans;
         }
 

From 4bd2b0819d5040c39a0a0ac415a97479a59327b0 Mon Sep 17 00:00:00 2001
From: rhysd <lin90162@yahoo.co.jp>
Date: Thu, 7 Jul 2022 20:08:45 +0900
Subject: [PATCH 05/18] search rest of current line on
 `search_forward`/`search_back`

---
 src/textarea.rs | 62 +++++++++++++++++++++++++++++++++++++------------
 1 file changed, 47 insertions(+), 15 deletions(-)

diff --git a/src/textarea.rs b/src/textarea.rs
index 86d62a1..9b01aa9 100644
--- a/src/textarea.rs
+++ b/src/textarea.rs
@@ -1437,17 +1437,15 @@ impl<'a> TextArea<'a> {
             return false;
         };
         let (row, col) = self.cursor;
+        let current_line = &self.lines[row];
 
         // Search current line after cursor
-        {
-            let line = &self.lines[row];
-            let start_col = if match_current { col } else { col + 1 };
-            if let Some((i, _)) = line.char_indices().nth(start_col) {
-                if let Some(m) = pat.find_at(line, i) {
-                    let col = start_col + line[i..m.start()].chars().count();
-                    self.cursor = (row, col);
-                    return true;
-                }
+        let start_col = if match_current { col } else { col + 1 };
+        if let Some((i, _)) = current_line.char_indices().nth(start_col) {
+            if let Some(m) = pat.find_at(current_line, i) {
+                let col = start_col + current_line[i..m.start()].chars().count();
+                self.cursor = (row, col);
+                return true;
             }
         }
 
@@ -1469,6 +1467,23 @@ impl<'a> TextArea<'a> {
             }
         }
 
+        // Search current line before cursor
+        if col > 0 {
+            let col_idx = current_line
+                .char_indices()
+                .nth(col - 1)
+                .map(|(i, _)| i)
+                .unwrap_or(current_line.len());
+            if let Some(m) = pat.find(current_line) {
+                let i = m.start();
+                if i <= col_idx {
+                    let col = current_line[..i].chars().count();
+                    self.cursor = (row, col);
+                    return true;
+                }
+            }
+        }
+
         false
     }
 
@@ -1480,14 +1495,18 @@ impl<'a> TextArea<'a> {
             return false;
         };
         let (row, col) = self.cursor;
+        let current_line = &self.lines[row];
 
         // Search current line before cursor
         if col > 0 {
             let start_col = if match_current { col } else { col - 1 };
-            let line = &self.lines[row];
-            if let Some((i, _)) = line.char_indices().nth(start_col) {
-                if let Some(m) = pat.find_iter(line).take_while(|m| m.start() <= i).last() {
-                    let col = line[..m.start()].chars().count();
+            if let Some((i, _)) = current_line.char_indices().nth(start_col) {
+                if let Some(m) = pat
+                    .find_iter(current_line)
+                    .take_while(|m| m.start() <= i)
+                    .last()
+                {
+                    let col = current_line[..m.start()].chars().count();
                     self.cursor = (row, col);
                     return true;
                 }
@@ -1496,7 +1515,7 @@ impl<'a> TextArea<'a> {
 
         // Search lines before cursor
         for (i, line) in self.lines[..row].iter().enumerate().rev() {
-            if let Some(m) = pat.find(line) {
+            if let Some(m) = pat.find_iter(line).last() {
                 let col = line[..m.start()].chars().count();
                 self.cursor = (i, col);
                 return true;
@@ -1505,13 +1524,26 @@ impl<'a> TextArea<'a> {
 
         // Search lines after cursor (wrap)
         for (i, line) in self.lines[row + 1..].iter().enumerate().rev() {
-            if let Some(m) = pat.find(line) {
+            if let Some(m) = pat.find_iter(line).last() {
                 let col = line[..m.start()].chars().count();
                 self.cursor = (row + 1 + i, col);
                 return true;
             }
         }
 
+        // Search current line after cursor
+        if let Some((i, _)) = current_line.char_indices().nth(col + 1) {
+            if let Some(m) = pat
+                .find_iter(current_line)
+                .skip_while(|m| m.start() < i)
+                .last()
+            {
+                let col = col + 1 + current_line[i..m.start()].chars().count();
+                self.cursor = (row, col);
+                return true;
+            }
+        }
+
         false
     }
 

From 460c51a796a8fa7f0a0d2ca842eea67f42fe72ad Mon Sep 17 00:00:00 2001
From: rhysd <lin90162@yahoo.co.jp>
Date: Thu, 7 Jul 2022 23:03:01 +0900
Subject: [PATCH 06/18] fix warnings when no feature is enabled

---
 .github/workflows/ci.yml | 10 ++++------
 src/textarea.rs          |  4 ++--
 2 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 6d38f15..a4aa681 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -35,9 +35,7 @@ jobs:
           components: rustfmt, clippy
           override: true
       - uses: Swatinem/rust-cache@v1
-      - name: rustfmt
-        run: cargo fmt -- --check
-      - name: clippy
-        run: cargo clippy --examples --all-features -- -D warnings
-      - name: clippy with --no-default-features
-        run: cargo clippy --no-default-features -- -D warnings
+      - run: cargo fmt -- --check
+      - run: cargo clippy --examples --all-features -- -D warnings
+      - run: cargo clippy --no-default-features -- -D warnings
+      - run: cargo clippy --no-default-features --features termion -- -D warnings
diff --git a/src/textarea.rs b/src/textarea.rs
index 9b01aa9..3a5c495 100644
--- a/src/textarea.rs
+++ b/src/textarea.rs
@@ -9,7 +9,7 @@ use std::cmp;
 use std::sync::atomic::{AtomicU16, Ordering};
 use tui::buffer::Buffer;
 use tui::layout::Rect;
-use tui::style::{Color, Modifier, Style};
+use tui::style::{Modifier, Style};
 use tui::text::{Span, Spans, Text};
 use tui::widgets::{Block, Paragraph, Widget};
 
@@ -187,7 +187,7 @@ impl<'a> TextArea<'a> {
             #[cfg(feature = "search")]
             search_pat: None,
             #[cfg(feature = "search")]
-            search_style: Style::default().bg(Color::Blue),
+            search_style: Style::default().bg(tui::style::Color::Blue),
         }
     }
 

From 5b08d16214f6290cfd7e02a3e5f21ddec716119e Mon Sep 17 00:00:00 2001
From: rhysd <lin90162@yahoo.co.jp>
Date: Fri, 8 Jul 2022 10:05:53 +0900
Subject: [PATCH 07/18] implement text search in editor example

---
 examples/editor.rs | 218 ++++++++++++++++++++++++++++++++++++---------
 1 file changed, 178 insertions(+), 40 deletions(-)

diff --git a/examples/editor.rs b/examples/editor.rs
index b8cdcd8..e807018 100644
--- a/examples/editor.rs
+++ b/examples/editor.rs
@@ -13,7 +13,7 @@ use tui::backend::CrosstermBackend;
 use tui::layout::{Constraint, Direction, Layout};
 use tui::style::{Color, Modifier, Style};
 use tui::text::{Span, Spans};
-use tui::widgets::Paragraph;
+use tui::widgets::{Block, Borders, Paragraph};
 use tui::Terminal;
 use tui_textarea::{Input, Key, TextArea};
 
@@ -23,6 +23,60 @@ macro_rules! error {
     }};
 }
 
+struct SearchBox<'a> {
+    textarea: TextArea<'a>,
+    open: bool,
+}
+
+impl<'a> Default for SearchBox<'a> {
+    fn default() -> Self {
+        let mut textarea = TextArea::default();
+        textarea.set_block(Block::default().borders(Borders::ALL).title("Search"));
+        Self {
+            textarea,
+            open: false,
+        }
+    }
+}
+
+impl<'a> SearchBox<'a> {
+    fn open(&mut self) {
+        self.open = true;
+    }
+
+    fn close(&mut self) {
+        self.open = false;
+        let block = self.textarea.block().unwrap().clone();
+        self.textarea = TextArea::default();
+        self.textarea.set_block(block);
+    }
+
+    fn height(&self) -> u16 {
+        if self.open {
+            3
+        } else {
+            0
+        }
+    }
+
+    fn input(&mut self, input: Input) -> Option<&'_ str> {
+        match input {
+            Input {
+                key: Key::Enter, ..
+            }
+            | Input {
+                key: Key::Char('m'),
+                ctrl: true,
+                ..
+            } => None,
+            input => {
+                let modified = self.textarea.input(input);
+                modified.then(|| self.textarea.lines()[0].as_str())
+            }
+        }
+    }
+}
+
 struct Buffer<'a> {
     textarea: TextArea<'a>,
     path: PathBuf,
@@ -73,6 +127,7 @@ struct Editor<'a> {
     buffers: Vec<Buffer<'a>>,
     term: Terminal<CrosstermBackend<io::Stdout>>,
     message: Option<Cow<'static, str>>,
+    search: SearchBox<'a>,
 }
 
 impl<'a> Editor<'a> {
@@ -99,28 +154,36 @@ impl<'a> Editor<'a> {
             buffers,
             term,
             message: None,
+            search: SearchBox::default(),
         })
     }
 
     fn run(&mut self) -> io::Result<()> {
-        let layout = Layout::default()
-            .direction(Direction::Vertical)
-            .constraints(
-                [
-                    Constraint::Min(1),
-                    Constraint::Length(1),
-                    Constraint::Length(1),
-                ]
-                .as_ref(),
-            );
-
         loop {
+            let search_height = self.search.height();
+            let layout = Layout::default()
+                .direction(Direction::Vertical)
+                .constraints(
+                    [
+                        Constraint::Length(search_height),
+                        Constraint::Min(1),
+                        Constraint::Length(1),
+                        Constraint::Length(1),
+                    ]
+                    .as_ref(),
+                );
+
             self.term.draw(|f| {
+                let chunks = layout.split(f.size());
+
+                if search_height > 0 {
+                    f.render_widget(self.search.textarea.widget(), chunks[0]);
+                }
+
                 let buffer = &self.buffers[self.current];
                 let textarea = &buffer.textarea;
-                let chunks = layout.split(f.size());
                 let widget = textarea.widget();
-                f.render_widget(widget, chunks[0]);
+                f.render_widget(widget, chunks[1]);
 
                 // Render status line
                 let modified = if buffer.modified { " [modified]" } else { "" };
@@ -138,7 +201,7 @@ impl<'a> Editor<'a> {
                         ]
                         .as_ref(),
                     )
-                    .split(chunks[1]);
+                    .split(chunks[2]);
                 let status_style = Style::default().add_modifier(Modifier::REVERSED);
                 f.render_widget(Paragraph::new(slot).style(status_style), status_chunks[0]);
                 f.render_widget(Paragraph::new(path).style(status_style), status_chunks[1]);
@@ -147,6 +210,18 @@ impl<'a> Editor<'a> {
                 // Render message at bottom
                 let message = if let Some(message) = self.message.take() {
                     Spans::from(Span::raw(message))
+                } else if search_height > 0 {
+                    Spans::from(vec![
+                        Span::raw("Press "),
+                        Span::styled("Enter", Style::default().add_modifier(Modifier::BOLD)),
+                        Span::raw(" to jump to first match and close, "),
+                        Span::styled("Esc", Style::default().add_modifier(Modifier::BOLD)),
+                        Span::raw(" to close, "),
+                        Span::styled("^G or ^→", Style::default().add_modifier(Modifier::BOLD)),
+                        Span::raw(" to search next, "),
+                        Span::styled("M-G or ^←", Style::default().add_modifier(Modifier::BOLD)),
+                        Span::raw(" to search previous"),
+                    ])
                 } else {
                     Spans::from(vec![
                         Span::raw("Press "),
@@ -154,38 +229,101 @@ impl<'a> Editor<'a> {
                         Span::raw(" to quit, "),
                         Span::styled("^S", Style::default().add_modifier(Modifier::BOLD)),
                         Span::raw(" to save, "),
+                        Span::styled("^G", Style::default().add_modifier(Modifier::BOLD)),
+                        Span::raw(" to search, "),
                         Span::styled("^X", Style::default().add_modifier(Modifier::BOLD)),
                         Span::raw(" to switch buffer"),
                     ])
                 };
-                f.render_widget(Paragraph::new(message), chunks[2]);
+                f.render_widget(Paragraph::new(message), chunks[3]);
             })?;
 
-            match Input::from(crossterm::event::read()?) {
-                Input {
-                    key: Key::Char('q'),
-                    ctrl: true,
-                    ..
-                } => break,
-                Input {
-                    key: Key::Char('x'),
-                    ctrl: true,
-                    ..
-                } => {
-                    self.current = (self.current + 1) % self.buffers.len();
-                    self.message = Some(format!("Switched to buffer #{}", self.current + 1).into());
+            if search_height > 0 {
+                let textarea = &mut self.buffers[self.current].textarea;
+                match Input::from(crossterm::event::read()?) {
+                    Input {
+                        key: Key::Char('g'),
+                        ctrl: true,
+                        alt: false,
+                    }
+                    | Input {
+                        key: Key::Left,
+                        ctrl: true,
+                        ..
+                    } => {
+                        if !textarea.search_forward(false) {
+                            self.message = Some("Pattern not found".into());
+                        }
+                    }
+                    Input {
+                        key: Key::Char('g'),
+                        ctrl: false,
+                        alt: true,
+                    }
+                    | Input {
+                        key: Key::Right,
+                        ctrl: true,
+                        ..
+                    } => {
+                        if !textarea.search_back(false) {
+                            self.message = Some("Pattern not found".into());
+                        }
+                    }
+                    Input {
+                        key: Key::Enter, ..
+                    } => {
+                        textarea.search_forward(true);
+                        self.search.close();
+                        textarea.set_search_pattern("").unwrap();
+                    }
+                    Input { key: Key::Esc, .. } => {
+                        self.search.close();
+                        textarea.set_search_pattern("").unwrap();
+                    }
+                    input => {
+                        if let Some(query) = self.search.input(input) {
+                            if let Err(err) = textarea.set_search_pattern(query) {
+                                self.message =
+                                    Some(format!("Invalid search pattern: {}", err).into());
+                            }
+                        }
+                    }
                 }
-                Input {
-                    key: Key::Char('s'),
-                    ctrl: true,
-                    ..
-                } => {
-                    self.buffers[self.current].save()?;
-                    self.message = Some("Saved!".into());
-                }
-                input => {
-                    let buffer = &mut self.buffers[self.current];
-                    buffer.modified = buffer.textarea.input(input);
+            } else {
+                match Input::from(crossterm::event::read()?) {
+                    Input {
+                        key: Key::Char('q'),
+                        ctrl: true,
+                        ..
+                    } => break,
+                    Input {
+                        key: Key::Char('x'),
+                        ctrl: true,
+                        ..
+                    } => {
+                        self.current = (self.current + 1) % self.buffers.len();
+                        self.message =
+                            Some(format!("Switched to buffer #{}", self.current + 1).into());
+                    }
+                    Input {
+                        key: Key::Char('s'),
+                        ctrl: true,
+                        ..
+                    } => {
+                        self.buffers[self.current].save()?;
+                        self.message = Some("Saved!".into());
+                    }
+                    Input {
+                        key: Key::Char('g'),
+                        ctrl: true,
+                        ..
+                    } => {
+                        self.search.open();
+                    }
+                    input => {
+                        let buffer = &mut self.buffers[self.current];
+                        buffer.modified = buffer.textarea.input(input);
+                    }
                 }
             }
         }

From 8008c0ebdacde833c6b28d662cd6d7ca4bf26333 Mon Sep 17 00:00:00 2001
From: rhysd <lin90162@yahoo.co.jp>
Date: Fri, 8 Jul 2022 10:06:26 +0900
Subject: [PATCH 08/18] fix `search_forward`/`search_back` should finally match
 to the cursor position

---
 src/textarea.rs | 34 ++++++++++++++++------------------
 1 file changed, 16 insertions(+), 18 deletions(-)

diff --git a/src/textarea.rs b/src/textarea.rs
index 3a5c495..5231a72 100644
--- a/src/textarea.rs
+++ b/src/textarea.rs
@@ -1430,7 +1430,7 @@ impl<'a> TextArea<'a> {
     }
 
     #[cfg(feature = "search")]
-    pub fn search_forward(&mut self, match_current: bool) -> bool {
+    pub fn search_forward(&mut self, match_cursor: bool) -> bool {
         let pat = if let Some(pat) = &self.search_pat {
             pat
         } else {
@@ -1440,7 +1440,7 @@ impl<'a> TextArea<'a> {
         let current_line = &self.lines[row];
 
         // Search current line after cursor
-        let start_col = if match_current { col } else { col + 1 };
+        let start_col = if match_cursor { col } else { col + 1 };
         if let Some((i, _)) = current_line.char_indices().nth(start_col) {
             if let Some(m) = pat.find_at(current_line, i) {
                 let col = start_col + current_line[i..m.start()].chars().count();
@@ -1468,19 +1468,17 @@ impl<'a> TextArea<'a> {
         }
 
         // Search current line before cursor
-        if col > 0 {
-            let col_idx = current_line
-                .char_indices()
-                .nth(col - 1)
-                .map(|(i, _)| i)
-                .unwrap_or(current_line.len());
-            if let Some(m) = pat.find(current_line) {
-                let i = m.start();
-                if i <= col_idx {
-                    let col = current_line[..i].chars().count();
-                    self.cursor = (row, col);
-                    return true;
-                }
+        let col_idx = current_line
+            .char_indices()
+            .nth(col)
+            .map(|(i, _)| i)
+            .unwrap_or(current_line.len());
+        if let Some(m) = pat.find(current_line) {
+            let i = m.start();
+            if i <= col_idx {
+                let col = current_line[..i].chars().count();
+                self.cursor = (row, col);
+                return true;
             }
         }
 
@@ -1488,7 +1486,7 @@ impl<'a> TextArea<'a> {
     }
 
     #[cfg(feature = "search")]
-    pub fn search_back(&mut self, match_current: bool) -> bool {
+    pub fn search_back(&mut self, match_cursor: bool) -> bool {
         let pat = if let Some(pat) = &self.search_pat {
             pat
         } else {
@@ -1499,7 +1497,7 @@ impl<'a> TextArea<'a> {
 
         // Search current line before cursor
         if col > 0 {
-            let start_col = if match_current { col } else { col - 1 };
+            let start_col = if match_cursor { col } else { col - 1 };
             if let Some((i, _)) = current_line.char_indices().nth(start_col) {
                 if let Some(m) = pat
                     .find_iter(current_line)
@@ -1532,7 +1530,7 @@ impl<'a> TextArea<'a> {
         }
 
         // Search current line after cursor
-        if let Some((i, _)) = current_line.char_indices().nth(col + 1) {
+        if let Some((i, _)) = current_line.char_indices().nth(col) {
             if let Some(m) = pat
                 .find_iter(current_line)
                 .skip_while(|m| m.start() < i)

From 7bc9a959f2e77f53274edda0f895855cd9595235 Mon Sep 17 00:00:00 2001
From: rhysd <lin90162@yahoo.co.jp>
Date: Fri, 8 Jul 2022 10:12:49 +0900
Subject: [PATCH 09/18] keep undo history on closing search box in editor
 example

---
 examples/editor.rs | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/examples/editor.rs b/examples/editor.rs
index e807018..61f66b8 100644
--- a/examples/editor.rs
+++ b/examples/editor.rs
@@ -15,7 +15,7 @@ use tui::style::{Color, Modifier, Style};
 use tui::text::{Span, Spans};
 use tui::widgets::{Block, Borders, Paragraph};
 use tui::Terminal;
-use tui_textarea::{Input, Key, TextArea};
+use tui_textarea::{CursorMove, Input, Key, TextArea};
 
 macro_rules! error {
     ($fmt: expr $(, $args:tt)*) => {{
@@ -46,9 +46,10 @@ impl<'a> SearchBox<'a> {
 
     fn close(&mut self) {
         self.open = false;
-        let block = self.textarea.block().unwrap().clone();
-        self.textarea = TextArea::default();
-        self.textarea.set_block(block);
+        // Remove input for next search. Do not recreate `self.textarea` instance to keep undo history so that users can
+        // restore previous input easily.
+        self.textarea.move_cursor(CursorMove::End);
+        self.textarea.delete_line_by_head();
     }
 
     fn height(&self) -> u16 {

From 86bd8dd6efc415481d74518f08c40bb85ab59283 Mon Sep 17 00:00:00 2001
From: rhysd <lin90162@yahoo.co.jp>
Date: Fri, 8 Jul 2022 10:22:54 +0900
Subject: [PATCH 10/18] report pattern error in title of search box in editor
 example

---
 examples/editor.rs | 19 +++++++++++++++----
 1 file changed, 15 insertions(+), 4 deletions(-)

diff --git a/examples/editor.rs b/examples/editor.rs
index 61f66b8..6fd4d7d 100644
--- a/examples/editor.rs
+++ b/examples/editor.rs
@@ -5,6 +5,7 @@ use crossterm::terminal::{
 };
 use std::borrow::Cow;
 use std::env;
+use std::fmt::Display;
 use std::fs;
 use std::io;
 use std::io::{BufRead, Write};
@@ -76,6 +77,18 @@ impl<'a> SearchBox<'a> {
             }
         }
     }
+
+    fn set_error(&mut self, err: Option<impl Display>) {
+        let b = if let Some(err) = err {
+            Block::default()
+                .borders(Borders::ALL)
+                .title(format!("Search: {}", err))
+                .style(Style::default().fg(Color::Red))
+        } else {
+            Block::default().borders(Borders::ALL).title("Search")
+        };
+        self.textarea.set_block(b);
+    }
 }
 
 struct Buffer<'a> {
@@ -283,10 +296,8 @@ impl<'a> Editor<'a> {
                     }
                     input => {
                         if let Some(query) = self.search.input(input) {
-                            if let Err(err) = textarea.set_search_pattern(query) {
-                                self.message =
-                                    Some(format!("Invalid search pattern: {}", err).into());
-                            }
+                            let maybe_err = textarea.set_search_pattern(query).err();
+                            self.search.set_error(maybe_err);
                         }
                     }
                 }

From 8320fcdbb869c536951974ec4a9924a4b91a481e Mon Sep 17 00:00:00 2001
From: rhysd <lin90162@yahoo.co.jp>
Date: Fri, 8 Jul 2022 11:59:59 +0900
Subject: [PATCH 11/18] add tests and document for text search

---
 .github/workflows/ci.yml |   4 +-
 examples/editor.rs       |   2 +-
 src/textarea.rs          | 141 ++++++++++++++++++++++++++++++++++++++-
 3 files changed, 143 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index a4aa681..f3203cf 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -18,9 +18,9 @@ jobs:
           toolchain: stable
           override: true
       - uses: Swatinem/rust-cache@v1
-      - run: cargo test -- --skip src/lib.rs
+      - run: cargo test --all-features -- --skip src/lib.rs
         if: ${{ matrix.os != 'windows-latest' }}
-      - run: cargo test -- --skip src\lib.rs
+      - run: cargo test --all-features -- --skip src\lib.rs
         if: ${{ matrix.os == 'windows-latest' }}
   lint:
     runs-on: ubuntu-latest
diff --git a/examples/editor.rs b/examples/editor.rs
index 6fd4d7d..a12099a 100644
--- a/examples/editor.rs
+++ b/examples/editor.rs
@@ -70,7 +70,7 @@ impl<'a> SearchBox<'a> {
                 key: Key::Char('m'),
                 ctrl: true,
                 ..
-            } => None,
+            } => None, // Disable shortcuts which inserts a newline. See `single_line` example
             input => {
                 let modified = self.textarea.input(input);
                 modified.then(|| self.textarea.lines()[0].as_str())
diff --git a/src/textarea.rs b/src/textarea.rs
index 5231a72..78a13fa 100644
--- a/src/textarea.rs
+++ b/src/textarea.rs
@@ -1418,6 +1418,35 @@ impl<'a> TextArea<'a> {
         self.yank = text.into();
     }
 
+    /// Set a regular expression pattern for text search. Setting an empty string stops the text search.
+    /// When a valid pattern is set, all matches will be highlighted in the textarea. Note that the cursor does not
+    /// move. To move the cursor, use [`TextArea::search_forward`] and [`TextArea::search_back`].
+    ///
+    /// Grammar of regular expression follows [regex crate](https://docs.rs/regex/latest/regex). Patterns don't match
+    /// to newlines so match passes across no newline.
+    ///
+    /// When the pattern is invalid, the search pattern will not be updated and an error will be returned.
+    ///
+    /// ```
+    /// use tui_textarea::TextArea;
+    ///
+    /// let mut textarea = TextArea::from(["hello, world", "goodbye, world"]);
+    ///
+    /// // Search "world"
+    /// textarea.set_search_pattern("world").unwrap();
+    ///
+    /// assert_eq!(textarea.cursor(), (0, 0));
+    /// textarea.search_forward(false);
+    /// assert_eq!(textarea.cursor(), (0, 7));
+    /// textarea.search_forward(false);
+    /// assert_eq!(textarea.cursor(), (1, 9));
+    ///
+    /// // Stop the text search
+    /// textarea.set_search_pattern("");
+    ///
+    /// // Invalid search pattern
+    /// assert!(textarea.set_search_pattern("(hello").is_err());
+    /// ```
     #[cfg(feature = "search")]
     pub fn set_search_pattern(&mut self, query: impl AsRef<str>) -> Result<(), regex::Error> {
         let query = query.as_ref();
@@ -1429,6 +1458,61 @@ impl<'a> TextArea<'a> {
         Ok(())
     }
 
+    /// Get a regular expression which was set by [`TextArea::set_search_pattern`]. When no text search is ongoing, this
+    /// method returns `None`.
+    ///
+    /// ```
+    /// use tui_textarea::TextArea;
+    ///
+    /// let mut textarea = TextArea::default();
+    ///
+    /// assert!(textarea.search_pattern().is_none());
+    /// textarea.set_search_pattern("hello+").unwrap();
+    /// assert!(textarea.search_pattern().is_some());
+    /// assert_eq!(textarea.search_pattern().unwrap().as_str(), "hello+");
+    /// ```
+    #[cfg(feature = "search")]
+    pub fn search_pattern(&self) -> Option<&Regex> {
+        self.search_pat.as_ref()
+    }
+
+    /// Search the pattern set by [`TextArea::set_search_pattern`] forward and move the cursor to the next match
+    /// position based on the current cursor position. Text search wraps around a text buffer. It returns `true` when
+    /// some match was found. Otherwise it returns `false`.
+    ///
+    /// The `match_cursor` parameter represents if the search matches to the current cursor position or not. When `true`
+    /// is set and the cursor position matches to the pattern, the cursor will not move. When `false`, the cursor will
+    /// move to the next match ignoring the match at the current position.
+    ///
+    /// ```
+    /// use tui_textarea::TextArea;
+    ///
+    /// let mut textarea = TextArea::from(["hello", "helloo", "hellooo"]);
+    ///
+    /// textarea.set_search_pattern("hello+").unwrap();
+    ///
+    /// // Move to next position
+    /// let match_found = textarea.search_forward(false);
+    /// assert!(match_found);
+    /// assert_eq!(textarea.cursor(), (1, 0));
+    ///
+    /// // Since the cursor position matches to "hello+", it does not move
+    /// textarea.search_forward(true);
+    /// assert_eq!(textarea.cursor(), (1, 0));
+    ///
+    /// // When `match_current` parameter is set to `false`, match at the cursor position is ignored
+    /// textarea.search_forward(false);
+    /// assert_eq!(textarea.cursor(), (2, 0));
+    ///
+    /// // Text search wrap around the buffer
+    /// textarea.search_forward(false);
+    /// assert_eq!(textarea.cursor(), (0, 0));
+    ///
+    /// // `false` is returned when no match was found
+    /// textarea.set_search_pattern("bye+").unwrap();
+    /// let match_found = textarea.search_forward(false);
+    /// assert!(!match_found);
+    /// ```
     #[cfg(feature = "search")]
     pub fn search_forward(&mut self, match_cursor: bool) -> bool {
         let pat = if let Some(pat) = &self.search_pat {
@@ -1485,6 +1569,39 @@ impl<'a> TextArea<'a> {
         false
     }
 
+    /// Search the pattern set by [`TextArea::set_search_pattern`] backward and move the cursor to the next match
+    /// position based on the current cursor position. Text search wraps around a text buffer. It returns `true` when
+    /// some match was found. Otherwise it returns `false`.
+    ///
+    /// The `match_cursor` parameter represents if the search matches to the current cursor position or not. When `true`
+    /// is set and the cursor position matches to the pattern, the cursor will not move. When `false`, the cursor will
+    /// move to the next match ignoring the match at the current position.
+    ///
+    /// ```
+    /// use tui_textarea::TextArea;
+    ///
+    /// let mut textarea = TextArea::from(["hello", "helloo", "hellooo"]);
+    ///
+    /// textarea.set_search_pattern("hello+").unwrap();
+    ///
+    /// // Move to next position with wrapping around the text buffer
+    /// let match_found = textarea.search_back(false);
+    /// assert!(match_found);
+    /// assert_eq!(textarea.cursor(), (2, 0));
+    ///
+    /// // Since the cursor position matches to "hello+", it does not move
+    /// textarea.search_back(true);
+    /// assert_eq!(textarea.cursor(), (2, 0));
+    ///
+    /// // When `match_current` parameter is set to `false`, match at the cursor position is ignored
+    /// textarea.search_back(false);
+    /// assert_eq!(textarea.cursor(), (1, 0));
+    ///
+    /// // `false` is returned when no match was found
+    /// textarea.set_search_pattern("bye+").unwrap();
+    /// let match_found = textarea.search_back(false);
+    /// assert!(!match_found);
+    /// ```
     #[cfg(feature = "search")]
     pub fn search_back(&mut self, match_cursor: bool) -> bool {
         let pat = if let Some(pat) = &self.search_pat {
@@ -1496,7 +1613,7 @@ impl<'a> TextArea<'a> {
         let current_line = &self.lines[row];
 
         // Search current line before cursor
-        if col > 0 {
+        if col > 0 || match_cursor {
             let start_col = if match_cursor { col } else { col - 1 };
             if let Some((i, _)) = current_line.char_indices().nth(start_col) {
                 if let Some(m) = pat
@@ -1545,11 +1662,33 @@ impl<'a> TextArea<'a> {
         false
     }
 
+    /// Get the text style at matches of text search. The default style is colored with blue in background.
+    ///
+    /// ```
+    /// use tui::style::{Style, Color};
+    /// use tui_textarea::TextArea;
+    ///
+    /// let textarea = TextArea::default();
+    ///
+    /// assert_eq!(textarea.search_style(), Style::default().bg(Color::Blue));
+    /// ```
     #[cfg(feature = "search")]
     pub fn search_style(&self) -> Style {
         self.search_style
     }
 
+    /// Set the text style at matches of text search. The default style is colored with blue in background.
+    /// ```
+    /// use tui::style::{Style, Color};
+    /// use tui_textarea::TextArea;
+    ///
+    /// let mut textarea = TextArea::default();
+    ///
+    /// let red_bg = Style::default().bg(Color::Red);
+    /// textarea.set_search_style(red_bg);
+    ///
+    /// assert_eq!(textarea.search_style(), red_bg);
+    /// ```
     #[cfg(feature = "search")]
     pub fn set_search_style(&mut self, style: Style) {
         self.search_style = style;

From dd409d6c4d2680a03882c02b98c3ea40cc68acdd Mon Sep 17 00:00:00 2001
From: rhysd <lin90162@yahoo.co.jp>
Date: Fri, 8 Jul 2022 12:08:05 +0900
Subject: [PATCH 12/18] fix search text highlight on zero width match

---
 src/textarea.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/textarea.rs b/src/textarea.rs
index 78a13fa..a0630f9 100644
--- a/src/textarea.rs
+++ b/src/textarea.rs
@@ -1008,8 +1008,10 @@ impl<'a> TextArea<'a> {
         #[cfg(feature = "search")]
         if let Some(pat) = &self.search_pat {
             for m in pat.find_iter(line) {
-                boundaries.push((Boundary::Search(self.search_style), m.start()));
-                boundaries.push((Boundary::End, m.end()));
+                if m.start() != m.end() {
+                    boundaries.push((Boundary::Search(self.search_style), m.start()));
+                    boundaries.push((Boundary::End, m.end()));
+                }
             }
         }
 

From 5aa25ea24d3229d9afd5bbfcf4a688ede8d088da Mon Sep 17 00:00:00 2001
From: rhysd <lin90162@yahoo.co.jp>
Date: Fri, 8 Jul 2022 12:08:38 +0900
Subject: [PATCH 13/18] show 'match not found' error in search box title in
 editor example

---
 examples/editor.rs | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/examples/editor.rs b/examples/editor.rs
index a12099a..f17d51f 100644
--- a/examples/editor.rs
+++ b/examples/editor.rs
@@ -266,7 +266,7 @@ impl<'a> Editor<'a> {
                         ..
                     } => {
                         if !textarea.search_forward(false) {
-                            self.message = Some("Pattern not found".into());
+                            self.search.set_error(Some("Pattern not found"));
                         }
                     }
                     Input {
@@ -280,13 +280,15 @@ impl<'a> Editor<'a> {
                         ..
                     } => {
                         if !textarea.search_back(false) {
-                            self.message = Some("Pattern not found".into());
+                            self.search.set_error(Some("Pattern not found"));
                         }
                     }
                     Input {
                         key: Key::Enter, ..
                     } => {
-                        textarea.search_forward(true);
+                        if !textarea.search_forward(true) {
+                            self.message = Some("Pattern not found".into());
+                        }
                         self.search.close();
                         textarea.set_search_pattern("").unwrap();
                     }

From 358e9dbc52c293fdb60b50092932e8cd5c6c36bb Mon Sep 17 00:00:00 2001
From: rhysd <lin90162@yahoo.co.jp>
Date: Fri, 8 Jul 2022 12:43:07 +0900
Subject: [PATCH 14/18] search forward/back with ^N/^P in editor example

---
 examples/editor.rs | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/examples/editor.rs b/examples/editor.rs
index f17d51f..29cb4bc 100644
--- a/examples/editor.rs
+++ b/examples/editor.rs
@@ -231,9 +231,15 @@ impl<'a> Editor<'a> {
                         Span::raw(" to jump to first match and close, "),
                         Span::styled("Esc", Style::default().add_modifier(Modifier::BOLD)),
                         Span::raw(" to close, "),
-                        Span::styled("^G or ^→", Style::default().add_modifier(Modifier::BOLD)),
+                        Span::styled(
+                            "^G or ^→ or ^N",
+                            Style::default().add_modifier(Modifier::BOLD),
+                        ),
                         Span::raw(" to search next, "),
-                        Span::styled("M-G or ^←", Style::default().add_modifier(Modifier::BOLD)),
+                        Span::styled(
+                            "M-G or ^← or ^P",
+                            Style::default().add_modifier(Modifier::BOLD),
+                        ),
                         Span::raw(" to search previous"),
                     ])
                 } else {
@@ -256,14 +262,9 @@ impl<'a> Editor<'a> {
                 let textarea = &mut self.buffers[self.current].textarea;
                 match Input::from(crossterm::event::read()?) {
                     Input {
-                        key: Key::Char('g'),
+                        key: Key::Char('g' | 'n') | Key::Left,
                         ctrl: true,
                         alt: false,
-                    }
-                    | Input {
-                        key: Key::Left,
-                        ctrl: true,
-                        ..
                     } => {
                         if !textarea.search_forward(false) {
                             self.search.set_error(Some("Pattern not found"));
@@ -275,9 +276,9 @@ impl<'a> Editor<'a> {
                         alt: true,
                     }
                     | Input {
-                        key: Key::Right,
+                        key: Key::Right | Key::Char('p'),
                         ctrl: true,
-                        ..
+                        alt: false,
                     } => {
                         if !textarea.search_back(false) {
                             self.search.set_error(Some("Pattern not found"));

From 1db4830a3cc332a5b091341d029dc586394b3ee2 Mon Sep 17 00:00:00 2001
From: rhysd <lin90162@yahoo.co.jp>
Date: Fri, 8 Jul 2022 12:50:59 +0900
Subject: [PATCH 15/18] fix cursor position on searching backward

---
 src/textarea.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/textarea.rs b/src/textarea.rs
index a0630f9..601e0d1 100644
--- a/src/textarea.rs
+++ b/src/textarea.rs
@@ -1655,7 +1655,7 @@ impl<'a> TextArea<'a> {
                 .skip_while(|m| m.start() < i)
                 .last()
             {
-                let col = col + 1 + current_line[i..m.start()].chars().count();
+                let col = col + current_line[i..m.start()].chars().count();
                 self.cursor = (row, col);
                 return true;
             }

From e78171913afcae4537db011c2bef4e23a9017c4c Mon Sep 17 00:00:00 2001
From: rhysd <lin90162@yahoo.co.jp>
Date: Fri, 8 Jul 2022 12:53:46 +0900
Subject: [PATCH 16/18] fix CI failure since termion does not support Windows

---
 .github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index f3203cf..e63c1df 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -20,7 +20,7 @@ jobs:
       - uses: Swatinem/rust-cache@v1
       - run: cargo test --all-features -- --skip src/lib.rs
         if: ${{ matrix.os != 'windows-latest' }}
-      - run: cargo test --all-features -- --skip src\lib.rs
+      - run: cargo test --features=search -- --skip src\lib.rs
         if: ${{ matrix.os == 'windows-latest' }}
   lint:
     runs-on: ubuntu-latest

From 81da9ce0940d45d7179ae34b0723ffcaa4bb0423 Mon Sep 17 00:00:00 2001
From: rhysd <lin90162@yahoo.co.jp>
Date: Fri, 8 Jul 2022 14:56:29 +0900
Subject: [PATCH 17/18] describe usage for text search in document

---
 CONTRIBUTING.md |   2 +-
 README.md       | 130 +++++++++++++++++++++++++++++++++++++-----------
 2 files changed, 102 insertions(+), 30 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index a120f6f..9067922 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -21,7 +21,7 @@ Please ensure that all tests and linter checks passed on your branch before crea
 To run tests:
 
 ```sh
-cargo test -- --skip src/lib.rs
+cargo test --features=search -- --skip src/lib.rs
 ```
 
 `--skip` is necessary since `cargo test` tries to run code blocks in [README file](./README.md).
diff --git a/README.md b/README.md
index eb974bb..3aea05b 100644
--- a/README.md
+++ b/README.md
@@ -14,6 +14,7 @@ text editor can be easily put as part of your TUI application.
 - Undo/Redo
 - Line number
 - Cursor line highlight
+- Search with regular expressions
 - Yank support. Paste text deleted with `C-k`, `C-j`, ...
 - Backend agnostic. [crossterm][], [termion][], and your own backend are all supported
 - Multiple textarea widgets in the same screen
@@ -24,40 +25,60 @@ text editor can be easily put as part of your TUI application.
 
 Running `cargo run --example` in this repository can demonstrate usage of tui-textarea.
 
+### [`minimal`](./examples/minimal.rs)
+
 ```sh
 cargo run --example minimal
 ```
 
-### [`minimal`](./examples/minimal.rs)
-
 Minimal usage with [crossterm][] support.
 
 <img src="https://raw.githubusercontent.com/rhysd/ss/master/tui-textarea/minimal.gif" width=539 height=172 alt="minimal example">
 
 ### [`editor`](./examples/editor.rs)
 
+```sh
+cargo run --example editor --features search file.txt
+```
+
 Simple text editor to edit multiple files.
 
-<img src="https://raw.githubusercontent.com/rhysd/ss/master/tui-textarea/editor.gif" width=539 height=172 alt="editor example">
+<img src="https://raw.githubusercontent.com/rhysd/ss/master/tui-textarea/editor.gif" width=560 height=236 alt="editor example">
 
 ### [`single_line`](./examples/single_line.rs)
 
+```sh
+cargo run --example single_line
+```
+
 Single-line input form with float number validation.
 
 <img src="https://raw.githubusercontent.com/rhysd/ss/master/tui-textarea/single_line.gif" width=539 height=92 alt="single line example">
 
 ### [`split`](./examples/split.rs)
 
+```sh
+cargo run --example split
+```
+
 Two split textareas in a screen and switch them. An example for multiple textarea instances.
 
 <img src="https://raw.githubusercontent.com/rhysd/ss/master/tui-textarea/split.gif" width=539 height=124 alt="multiple textareas example">
 
 ### [`termion`](./examples/termion.rs)
 
-Minimal usage with [termion][] support. To run this example, `termion` feature needs to be enabled.
+```sh
+cargo run --example termion --features=termion
+```
+
+Minimal usage with [termion][] support.
 
 ### [`variable`](./examples/variable.rs)
 
+```sh
+cargo run --example variable
+```
+
 Simple textarea with variable height following the number of lines.
 
 ## Installation
@@ -70,6 +91,15 @@ tui = "*"
 tui-textarea = "*"
 ```
 
+If you need text search with regular expressions, enable `search` feature. It adds [regex crate][regex] crate as
+dependency.
+
+```toml
+[dependencies]
+tui = "*"
+tui-textarea = { version = "*", features = ["search"] }
+```
+
 If you're using tui-rs with [termion][], enable `termion` feature instead of `crossterm` feature.
 
 ```toml
@@ -278,6 +308,44 @@ Setting 0 disables undo/redo.
 textarea.set_max_histories(0);
 ```
 
+### Text search with regular expressions
+
+To search text in textarea, set a regular expression pattern with `TextArea::set_search_pattern()` and move cursor with
+`TextArea::search_forward()` for forward search or `TextArea::search_back()` backward search. The regular expression is
+handled by [`regex` crate][regex].
+
+Text search wraps around the textarea. When searching forward and no match found until the end of textarea, it searches
+the pattern from start of the file.
+
+Matches are highlighted in textarea. The text style to highlight matches can be changed with
+`TextArea::set_search_style()`. Setting an empty string to `TextArea::set_search_pattern()` stops the text search.
+
+```rust
+// Start text search matching to "hello" or "hi". This highlights matches in textarea but does not move cursor.
+// `regex::Error` is returned on invalid pattern.
+textarea.set_search_pattern("(hello|hi)").unwrap();
+
+textarea.search_forward(false); // Move cursor to the next match
+textarea.search_back(false);    // Move cursor to the previous match
+
+// Setting empty string stops the search
+textarea.set_search_pattern("").unwrap();
+```
+
+No UI is provided for text search. You need to provide your own UI to input search query. It is recommended to use
+another `TextArea` for search form. To build a single-line input form, see 'Single-line input like `<input>` in HTML' in
+'Advanced Usage' section below.
+
+[`editor` example](./examples/editor.rs) implements a text search with search form built on `TextArea`. See the
+implementation for working example.
+
+To use text search, `search` feature needs to be enabled in your `Cargo.toml`. It is disabled by default to avoid
+depending on `regex` crate until it is necessary.
+
+```toml
+tui-textarea = { version = "*", features = ["search"] }
+```
+
 ## Advanced Usage
 
 ### Single-line input like `<input>` in HTML
@@ -317,31 +385,34 @@ See [`single_line` example](./examples/single_line.rs) for working example.
 All editor operations are defined as public methods of `TextArea`. To move cursor, use `tui_textarea::CursorMove` to
 notify how to move the cursor.
 
-| Method                                               | Operation                                 |
-|------------------------------------------------------|-------------------------------------------|
-| `textarea.delete_char()`                             | Delete one character before cursor        |
-| `textarea.delete_next_char()`                        | Delete one character next to cursor       |
-| `textarea.insert_newline()`                          | Insert newline                            |
-| `textarea.delete_line_by_end()`                      | Delete from cursor until the end of line  |
-| `textarea.delete_line_by_head()`                     | Delete from cursor until the head of line |
-| `textarea.delete_word()`                             | Delete one word before cursor             |
-| `textarea.delete_next_word()`                        | Delete one word next to cursor            |
-| `textarea.undo()`                                    | Undo                                      |
-| `textarea.redo()`                                    | Redo                                      |
-| `textarea.paste()`                                   | Paste yanked text                         |
-| `textarea.move_cursor(CursorMove::Forward)`          | Move cursor forward by one character      |
-| `textarea.move_cursor(CursorMove::Back)`             | Move cursor backward by one character     |
-| `textarea.move_cursor(CursorMove::Up)`               | Move cursor up by one line                |
-| `textarea.move_cursor(CursorMove::Down)`             | Move cursor down by one line              |
-| `textarea.move_cursor(CursorMove::WordForward)`      | Move cursor forward by word               |
-| `textarea.move_cursor(CursorMove::WordBack)`         | Move cursor backward by word              |
-| `textarea.move_cursor(CursorMove::ParagraphForward)` | Move cursor up by paragraph               |
-| `textarea.move_cursor(CursorMove::ParagraphBack)`    | Move cursor down by paragraph             |
-| `textarea.move_cursor(CursorMove::End)`              | Move cursor to the end of line            |
-| `textarea.move_cursor(CursorMove::Head)`             | Move cursor to the head of line           |
-| `textarea.move_cursor(CursorMove::Top)`              | Move cursor to top of lines               |
-| `textarea.move_cursor(CursorMove::Bottom)`           | Move cursor to bottom of lines            |
-| `textarea.move_cursor(CursorMove::Jump(row, col))`   | Move cursor to (row, col) position        |
+| Method                                               | Operation                                    |
+|------------------------------------------------------|----------------------------------------------|
+| `textarea.delete_char()`                             | Delete one character before cursor           |
+| `textarea.delete_next_char()`                        | Delete one character next to cursor          |
+| `textarea.insert_newline()`                          | Insert newline                               |
+| `textarea.delete_line_by_end()`                      | Delete from cursor until the end of line     |
+| `textarea.delete_line_by_head()`                     | Delete from cursor until the head of line    |
+| `textarea.delete_word()`                             | Delete one word before cursor                |
+| `textarea.delete_next_word()`                        | Delete one word next to cursor               |
+| `textarea.undo()`                                    | Undo                                         |
+| `textarea.redo()`                                    | Redo                                         |
+| `textarea.paste()`                                   | Paste yanked text                            |
+| `textarea.move_cursor(CursorMove::Forward)`          | Move cursor forward by one character         |
+| `textarea.move_cursor(CursorMove::Back)`             | Move cursor backward by one character        |
+| `textarea.move_cursor(CursorMove::Up)`               | Move cursor up by one line                   |
+| `textarea.move_cursor(CursorMove::Down)`             | Move cursor down by one line                 |
+| `textarea.move_cursor(CursorMove::WordForward)`      | Move cursor forward by word                  |
+| `textarea.move_cursor(CursorMove::WordBack)`         | Move cursor backward by word                 |
+| `textarea.move_cursor(CursorMove::ParagraphForward)` | Move cursor up by paragraph                  |
+| `textarea.move_cursor(CursorMove::ParagraphBack)`    | Move cursor down by paragraph                |
+| `textarea.move_cursor(CursorMove::End)`              | Move cursor to the end of line               |
+| `textarea.move_cursor(CursorMove::Head)`             | Move cursor to the head of line              |
+| `textarea.move_cursor(CursorMove::Top)`              | Move cursor to top of lines                  |
+| `textarea.move_cursor(CursorMove::Bottom)`           | Move cursor to bottom of lines               |
+| `textarea.move_cursor(CursorMove::Jump(row, col))`   | Move cursor to (row, col) position           |
+| `textarea.set_search_pattern(pattern)`               | Set a pattern for text search                |
+| `textarea.search_forward(match_cursor)`              | Move cursor to next match of text search     |
+| `textarea.search_back(match_cursor)`                 | Move cursor to previous match of text search |
 
 To define your own key mappings, simply call the above methods in your code instead of `TextArea::input()` method. The
 following example defines modal key mappings like Vim.
@@ -549,3 +620,4 @@ tui-textarea is distributed under [The MIT License](./LICENSE.txt).
 [repo]: https://github.com/rhysd/tui-textarea
 [new-issue]: https://github.com/rhysd/tui-textarea/issues/new
 [pulls]: https://github.com/rhysd/tui-textarea/pulls
+[regex]: https://docs.rs/regex/latest/regex/

From fee107847e5b838b353d945d6b4eaab3880ab802 Mon Sep 17 00:00:00 2001
From: rhysd <lin90162@yahoo.co.jp>
Date: Fri, 8 Jul 2022 14:58:51 +0900
Subject: [PATCH 18/18] =?UTF-8?q?use=20=E2=86=93/=E2=86=91=20instead=20of?=
 =?UTF-8?q?=20^=E2=86=90/^=E2=86=92=20to=20search=20next/previous=20in=20e?=
 =?UTF-8?q?ditor=20example?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 examples/editor.rs | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/examples/editor.rs b/examples/editor.rs
index 29cb4bc..7c7dac4 100644
--- a/examples/editor.rs
+++ b/examples/editor.rs
@@ -232,12 +232,12 @@ impl<'a> Editor<'a> {
                         Span::styled("Esc", Style::default().add_modifier(Modifier::BOLD)),
                         Span::raw(" to close, "),
                         Span::styled(
-                            "^G or ^→ or ^N",
+                            "^G or ↓ or ^N",
                             Style::default().add_modifier(Modifier::BOLD),
                         ),
                         Span::raw(" to search next, "),
                         Span::styled(
-                            "M-G or ^← or ^P",
+                            "M-G or ↑ or ^P",
                             Style::default().add_modifier(Modifier::BOLD),
                         ),
                         Span::raw(" to search previous"),
@@ -262,10 +262,11 @@ impl<'a> Editor<'a> {
                 let textarea = &mut self.buffers[self.current].textarea;
                 match Input::from(crossterm::event::read()?) {
                     Input {
-                        key: Key::Char('g' | 'n') | Key::Left,
+                        key: Key::Char('g' | 'n'),
                         ctrl: true,
                         alt: false,
-                    } => {
+                    }
+                    | Input { key: Key::Down, .. } => {
                         if !textarea.search_forward(false) {
                             self.search.set_error(Some("Pattern not found"));
                         }
@@ -276,10 +277,11 @@ impl<'a> Editor<'a> {
                         alt: true,
                     }
                     | Input {
-                        key: Key::Right | Key::Char('p'),
+                        key: Key::Char('p'),
                         ctrl: true,
                         alt: false,
-                    } => {
+                    }
+                    | Input { key: Key::Up, .. } => {
                         if !textarea.search_back(false) {
                             self.search.set_error(Some("Pattern not found"));
                         }