init

1 files changed, 102 insertions, 0 deletions

diff --git a/src/main.rs b/src/main.rs
new file mode 100644
index 0000000..ce7c84c
--- /dev/null
+++ b/src/main.rs
@@ -0,0 +1,102 @@
+mod app;
+mod config;
+
+use std::{
+    env, fs,
+    path::Path,
+    sync::{mpsc, Arc, RwLock},
+    thread,
+    time::Duration,
+};
+
+use app::App;
+use console::{Key, Term};
+use notify::{Event as WatchEvent, EventKind as WatchEventKind, RecursiveMode, Watcher};
+
+fn main() {
+    let mut args = env::args();
+    let _ = args.next();
+
+    let language = match args.next().as_ref().map(|s| s.as_str()) {
+        Some("rust") => tree_sitter_rust::language(),
+        Some("tsx") | Some("typescript") => tree_sitter_typescript::language_tsx(),
+        Some("javascript") => tree_sitter_javascript::language(),
+        Some("python") => tree_sitter_python::language(),
+        Some("ruby") => tree_sitter_ruby::language(),
+        Some("markdown") => tree_sitter_md::language(),
+        Some(s) => panic!("invalid language passed: {s}"),
+        None => panic!("no language passed"),
+    };
+    let path = args.next().expect("no arg passed");
+    let query_path = args.next();
+    let src = fs::read_to_string(&path).expect("unable to read file");
+
+    let app = Arc::new(RwLock::new(App::new(
+        src.as_bytes(),
+        &path,
+        query_path.as_ref(),
+        language,
+    )));
+
+    let watch_fn = |watcher_app: Arc<RwLock<App>>| {
+        move |ev| {
+            if let Ok(WatchEvent {
+                kind: WatchEventKind::Modify(..),
+                ..
+            }) = ev
+            {
+                if let Ok(mut locked) = watcher_app.try_write() {
+                    locked.reload();
+                    locked.draw();
+                };
+            }
+        }
+    };
+
+    let mut watcher1 = notify::recommended_watcher(watch_fn(Arc::clone(&app))).unwrap();
+    watcher1
+        .watch(Path::new(&path), RecursiveMode::NonRecursive)
+        .unwrap();
+
+    let mut watcher2 = notify::recommended_watcher(watch_fn(Arc::clone(&app))).unwrap();
+    if let Some(query_path) = query_path {
+        watcher2
+            .watch(Path::new(&query_path), RecursiveMode::NonRecursive)
+            .unwrap();
+    }
+
+    let (tx, rx) = mpsc::channel();
+    let tx0 = tx.clone();
+    thread::spawn(move || {
+        let term = Term::stdout();
+        loop {
+            if let Ok(Key::Char(ev)) = term.read_key() {
+                tx0.send(ev).unwrap();
+            }
+        }
+    });
+
+    if let Ok(locked) = app.try_read() {
+        locked.draw();
+    }
+
+    loop {
+        match rx.try_recv() {
+            Ok(ev) => {
+                if let Ok(mut locked) = app.try_write() {
+                    match ev {
+                        '>' => locked.increase_indent(),
+                        '<' => locked.decrease_indent(),
+                        'n' => locked.toggle_ranges(),
+                        's' => locked.toggle_source(),
+                        'r' => locked.reload(),
+                        _ => (),
+                    }
+                    locked.draw();
+                }
+            }
+            _ => (),
+        }
+        thread::sleep(Duration::from_millis(10));
+    }
+}