obsidian-logging 1.3.2

A journaling/logging CLI that stores logs in Obsidian markdown files
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
140
141
142
143
144
145
146
147
148
149

use crate::config::Config;
use crate::utils::{extract_log_entries, get_log_path_for_date};
use chrono::{Duration, Local};
use std::fs::read_to_string;

pub fn list_log_for_day(
    relative_day: i64,
    config: &Config,
    silent: bool,
    include_header: bool,
    categories: &[String],
) {
    let date = Local::now().date_naive() - Duration::days(relative_day);
    let log_path = get_log_path_for_date(date, config);

    if !log_path.exists() {
        if !silent {
            println!("No log found for {}", date);
        }
        return;
    }

    let content = read_to_string(&log_path).unwrap_or_else(|_| {
        if !silent {
            println!("Error reading log file");
        }
        String::new()
    });

    // Handle different category scenarios
    if categories.is_empty() {
        // No categories specified - list default section only
        let section_header = config.get_section_header_for_category(None);
        let (_, _, entries, _) = extract_log_entries(
            &content,
            section_header,
            &config.list_type,
            config,
            include_header,
        );

        if entries.is_empty() {
            if !silent {
                println!("No entries found for {}", date);
            }
            return;
        }

        if !silent {
            println!("Log entries for {}:", date);
            for entry in entries {
                println!("{}", entry);
            }
        }
    } else if categories.len() == 1 && categories[0] == "all" {
        // Special case: list all categories
        list_all_categories(&content, config, silent, include_header, date);
    } else {
        // List specific categories
        list_specific_categories(&content, config, silent, include_header, date, categories);
    }
}

fn list_all_categories(
    content: &str,
    config: &Config,
    silent: bool,
    include_header: bool,
    date: chrono::NaiveDate,
) {
    if silent {
        return;
    }

    println!("Log entries for {} (all categories):", date);

    // List default section first
    let default_header = config.get_section_header_for_category(None);
    let (_, _, default_entries, _) = extract_log_entries(
        content,
        default_header,
        &config.list_type,
        config,
        include_header,
    );

    if !default_entries.is_empty() {
        println!("\n{}", default_header);
        for entry in default_entries {
            println!("{}", entry);
        }
    }

    // List all category sections
    for (key, header) in &config.category_headers {
        if key.starts_with("section_header_") {
            let (_, _, entries, _) =
                extract_log_entries(content, header, &config.list_type, config, include_header);

            if !entries.is_empty() {
                println!("\n{}", header);
                for entry in entries {
                    println!("{}", entry);
                }
            }
        }
    }
}

fn list_specific_categories(
    content: &str,
    config: &Config,
    silent: bool,
    include_header: bool,
    date: chrono::NaiveDate,
    categories: &[String],
) {
    if silent {
        return;
    }

    let category_list = categories.join(", ");
    println!("Log entries for {} (categories: {}):", date, category_list);

    let mut found_any = false;

    for category in categories {
        let section_header = config.get_section_header_for_category(Some(category));
        let (_, _, entries, _) = extract_log_entries(
            content,
            section_header,
            &config.list_type,
            config,
            include_header,
        );

        if !entries.is_empty() {
            found_any = true;
            println!("\n{}", section_header);
            for entry in entries {
                println!("{}", entry);
            }
        }
    }

    if !found_any {
        println!("No entries found for the specified categories.");
    }
}