fast-search 1.0.1

⚡ A blazingly fast, cross-platform CLI tool for searching files and file contents
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

// File: src\output.rs
// Author: Hadi Cahyadi <cumulus13@gmail.com>
// Date: 2026-05-11
// Description: 
// License: MIT

use crate::colors::{bold_hex, hex_color};
use crate::config::Config;
use crate::searcher::SearchMatch;
use colored::Colorize;
use std::time::Duration;

pub struct Printer<'a> {
    cfg: &'a Config,
}

impl<'a> Printer<'a> {
    pub fn new(cfg: &'a Config) -> Self {
        Self { cfg }
    }

    pub fn print_banner(&self) {
        eprintln!(
            "⚡ {} v{}",
            bold_hex("fsearch", &self.cfg.color_info),
            bold_hex(env!("CARGO_PKG_VERSION"), &self.cfg.color_count),
        );
    }

    pub fn print_searching(&self, dir: &str, pattern: &str) {
        eprintln!(
            "🔍 Searching {} for {}",
            bold_hex(dir, &self.cfg.color_path),
            bold_hex(pattern, &self.cfg.color_pattern),
        );
    }

    pub fn print_results(
        &self,
        results: &[SearchMatch],
        _search_in_files: bool,
        elapsed: Duration,
    ) {
        if results.is_empty() {
            println!(
                "\nđŸ•ŗī¸  {}\n",
                bold_hex("No results found.", &self.cfg.color_warn)
            );
            return;
        }

        let count_str = results.len().to_string();
        let ms = elapsed.as_millis();

        println!(
            "\n{} {}  {} {} {}",
            "📋".bold(),
            bold_hex("FOUND:", &self.cfg.color_header),
            bold_hex(&count_str, &self.cfg.color_count),
            hex_color("result(s)", &self.cfg.color_info),
            hex_color(format!("[{ms}ms]"), "#888888"),
        );
        println!();

        let zfill = count_str.len();

        for (idx, item) in results.iter().enumerate() {
            let num = format!("{:0>width$}", idx + 1, width = zfill);
            let num_str = bold_hex(&num, &self.cfg.color_index);

            match item {
                SearchMatch::Path(path) => {
                    println!(
                        "{}. {}",
                        num_str,
                        bold_hex(path.display().to_string(), &self.cfg.color_path)
                    );
                }
                SearchMatch::Content { path, lines } => {
                    println!(
                        "{}. {}",
                        num_str,
                        bold_hex(path.display().to_string(), &self.cfg.color_path)
                    );
                    for (line_num, line_text) in lines {
                        println!(
                            "   {} {} {}",
                            bold_hex(format!("{:>5}", line_num), &self.cfg.color_line_num),
                            hex_color("│", "#555555"),
                            hex_color(line_text.trim_end(), &self.cfg.color_line_text),
                        );
                    }
                }
            }
        }
        println!();
    }

    pub fn print_error(&self, msg: &str) {
        eprintln!("❌ {} {}", bold_hex("Error:", &self.cfg.color_error), msg);
    }

    pub fn print_warn(&self, msg: &str) {
        eprintln!("⚠ī¸  {}", hex_color(msg, &self.cfg.color_warn));
    }

    pub fn print_info(&self, msg: &str) {
        eprintln!("ℹī¸  {}", hex_color(msg, &self.cfg.color_info));
    }
}