flerp 0.1.0

CLI tool that does XYZ
Documentation 
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

use std::collections::HashMap;
use std::env;
use std::error::Error;
use std::fs;

pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
    
    println!("  .--.  ");
    println!(" /  _ \\ ");
    println!("|  o o |");
    println!(" \\  ^ / ");
    println!("  `--'  ");
    println!("   ||   ");
    println!("        "); 

    println!("    _________________________");
    println!("   /                        //");
    println!("  /   Flerp Text Analysis  //");
    println!(" /    Content & Insights  //");
    println!("/________________________//");
    println!("(________________________(/");
    println!("   \\                      \\");
    println!("    \\   Keywords, Stats,    \\");
    println!("     \\   Search Results...  \\");
    println!("      \\______________________\\");
    println!(""); 

    let contents = fs::read_to_string(config.file_name)?;

    let structural_analysis_results = analyze_structure(&contents);
    println!("Structural Analysis:");
    println!("  Lines: {}", structural_analysis_results.lines);
    println!("  Words: {}", structural_analysis_results.words);
    println!("  Stanzas: {}", structural_analysis_results.stanzas);

    let keywords = extract_keywords(&contents, 5); // Extract top 5 keywords
    println!("\nKeywords (Top 5):");
    for (keyword, count) in keywords {
        println!("  {}: {}", keyword, count);
    }

    let res = if config.case_sensitive {
        search(&config.query, &contents)
    } else {
        search_case_insensitive(&config.query, &contents)
    };

    for line in res {
        println!("{}", line);
    }

    Ok(())
}

pub struct Config {
    pub query: String,
    pub file_name: String,
    pub case_sensitive: bool,
}

impl Config {
    pub fn new(args: &[String]) -> Result<Config, &str> {
        if args.len() < 3 {
            return Err("Looks like you passed some wonky doohickeys");
        }
        let query = args[1].clone();
        let file_name = args[2].clone();

        let case_sensitive = env::var("CASE_INSENSITIVE").is_err();

        Ok(Config {
            query,
            file_name,
            case_sensitive,
        })
    }
}

pub fn search<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
    let mut res = Vec::new();

    for line in contents.lines() {
        if line.contains(query) {
            res.push(line);
        }
    }
    res
}

pub fn search_case_insensitive<'a>(query: &str, contents: &'a str) -> Vec<&'a str> {
    let query = query.to_lowercase();
    let mut res = Vec::new();

    for line in contents.lines() {
        if line.to_lowercase().contains(&query) {
            res.push(line);
        }
    }

    res
}

pub struct StructuralAnalysisResults {
    pub lines: usize,
    pub words: usize,
    pub stanzas: usize,
}

// New public function for structural analysis
pub fn analyze_structure(contents: &str) -> StructuralAnalysisResults {
    let lines = contents.lines().count();
    let words = contents.split_whitespace().count();
    let stanzas = contents.split("\n\n").count();

    StructuralAnalysisResults {
        lines,
        words,
        stanzas,
    }
}

pub fn extract_keywords(contents: &str, top_n: usize) -> Vec<(String, usize)> {
    let mut word_counts = HashMap::new();
    for word in contents.split_whitespace() {
        let cleaned_word = word
            .to_lowercase()
            .chars()
            .filter(|c| c.is_alphanumeric())
            .collect::<String>();
        if !cleaned_word.is_empty() {
            *word_counts.entry(cleaned_word).or_insert(0) += 1;
        }
    }

    let mut sorted_keywords: Vec<(String, usize)> = word_counts.into_iter().collect();
    sorted_keywords.sort_by(|a, b| b.1.cmp(&a.1));
    sorted_keywords.truncate(top_n);
    sorted_keywords
}