mj 0.4.3

My Journal - personal tool to capture ideas, work with journals, notes and tasks in your favourite text $EDITOR.
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

mod prelude;
mod processor;
mod query;
mod state;
mod view;

use prelude::*;

pub fn start(vault: &Vault) -> Result<()> {
  let mut state = State::SearchIdeas(
    Query::new(vault.list_ideas().unwrap_or(vec![]))
  );
  let mut update_status: Option<UpdateStatus> = None; // Some(UpdateStatus::StartIdeaEditor(String::from("my-journal")));
  loop {
    match update_status {
      None => {
        let mut stdin: Keys<AsyncReader> = termion::async_stdin().keys();
        let stdout = io::stdout();
        let mut term = init_term(stdout.lock())?;
        term.clear()?;
        term.hide_cursor()?;
        let mut first_run = true;
        loop {
          let status = update(&mut stdin, &vault, &mut state)?;
          update_status = Some(status.copy());
          match status {
            UpdateStatus::Changed => view::render(&mut term, &vault, &state)?,
            UpdateStatus::Unchanged => if first_run {
              first_run = false;
              view::render(&mut term, &vault, &state)?;
            }
            UpdateStatus::Quit
              | UpdateStatus::StartIdeaEditor(_)
              | UpdateStatus::StartJournalEditor(_)
              | UpdateStatus::StartNoteEditor(_, _)
              | UpdateStatus::StartTaskEditor(_)
              => break,
          }
          sleep(Duration::from_millis(10));
        }
        term.clear()?;
      },
      Some(UpdateStatus::StartIdeaEditor(name)) => {
        // NOTE: consuming from stdin might resolve the issue of extra input generated into the
        // EDITOR's buffer (apparent the most with `EDITOR="emacs -nw"`)
        // ---
        // let stdin = io::stdin();
        // let mut data = String::new();
        // stdin.read_line(&mut data).unwrap_or(0);
        // ---
        let saved = ideas::edit(&vault, name.to_owned())?;
        if saved {
          if let State::SearchIdeas(query) = &mut state {
            query.results = vault.list_ideas().unwrap_or(vec![]);
            for (i, (x, _)) in query.results.iter().enumerate() {
              if x == &name {
                query.selected_result_index = Some(i);
                break;
              }
            }
            query.input = String::from("");
          }
        }
        update_status = None;
      },
      Some(UpdateStatus::StartJournalEditor(date)) => {
        let saved = journals::edit(&vault, &date)?;
        if saved {
          if let State::SearchJournals(query) = &mut state {
            let name = date.format();
            query.results = vault.list_journals().unwrap_or(vec![]);
            for (i, (x, _)) in query.results.iter().enumerate() {
              if x == &name {
                query.selected_result_index = Some(i);
                break;
              }
            }
            query.input = String::from("");
          }
        }
        update_status = None;
      },
      Some(UpdateStatus::StartNoteEditor(category, name)) => {
        let saved = notes::edit(&vault, &category, &name)?;
        if saved {
          if let State::SearchNotes(query) = &mut state {
            query.results = vault.list_notes(true, &None).unwrap_or(vec![]);
            let results = query.flatten_results();
            for (i, (x, y, _, _)) in results.iter().enumerate() {
              if x == &category && y == &name {
                query.selected_result_index = Some(i);
                break;
              }
            }
            query.input = String::from("");
          }
        }
        update_status = None;
      },
      Some(UpdateStatus::StartTaskEditor(project)) => {
        let saved = tasks::edit(&vault, &project)?;
        if saved {
          if let State::SearchTasks(query) = &mut state {
            query.results = vault.list_tasks(true, &None).unwrap_or(vec![]);
            for (i, (x, _)) in query.results.iter().enumerate() {
              if x == &project {
                query.selected_result_index = Some(i);
                break;
              }
            }
            query.input = String::from("");
          }
        }
        update_status = None;
      },
      Some(UpdateStatus::Quit) | _ => break,
    }
  }
  Ok(())
}

fn init_term<'a>(stdout: io::StdoutLock<'a>) -> Result<Term<'a>> {
  let raw_stdout = stdout.into_raw_mode()?;
  let backend = TermionBackend::new(raw_stdout);
  Ok(Terminal::new(backend)?)
}

fn update(stdin: &mut Keys<AsyncReader>, vault: &Vault, state: &mut State) -> Result<UpdateStatus> {
  if let Some(key) = stdin.next() {
    let key = key?;
    Ok(process(vault, state, key))
  } else {
    Ok(UpdateStatus::Unchanged)
  }
}