meld 0.1.1

Deterministic filesystem state management using Merkle trees
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

//! Editor integration hooks for filesystem change notifications.

use crate::api::ContextApi;
use crate::error::ApiError;
use crate::types::NodeID;
use notify::{Event, EventKind, RecommendedWatcher, RecursiveMode, Watcher};
use std::path::PathBuf;
use std::sync::mpsc;
use tracing::error;

/// Editor integration hooks
pub struct EditorHooks {
    #[allow(dead_code)]
    api: ContextApi,
    workspace_root: PathBuf,
}

impl EditorHooks {
    /// Create new editor hooks
    pub fn new(api: ContextApi, workspace_root: PathBuf) -> Self {
        Self {
            api,
            workspace_root,
        }
    }

    /// Start watching for filesystem changes
    pub fn watch(
        &self,
    ) -> Result<(mpsc::Receiver<notify::Result<Event>>, RecommendedWatcher), ApiError> {
        let (tx, rx) = mpsc::channel();

        let mut watcher = notify::recommended_watcher(move |res| {
            if let Err(e) = tx.send(res) {
                error!("Error sending watch event: {}", e);
            }
        })
        .map_err(|e| {
            ApiError::StorageError(crate::error::StorageError::IoError(std::io::Error::new(
                std::io::ErrorKind::Other,
                format!("Failed to create watcher: {}", e),
            )))
        })?;

        watcher
            .watch(&self.workspace_root, RecursiveMode::Recursive)
            .map_err(|e| {
                ApiError::StorageError(crate::error::StorageError::IoError(std::io::Error::new(
                    std::io::ErrorKind::Other,
                    format!("Failed to watch directory: {}", e),
                )))
            })?;

        Ok((rx, watcher))
    }

    /// Handle a filesystem change event
    pub fn handle_event(&self, event: Event) -> Result<Option<NodeID>, ApiError> {
        match event.kind {
            EventKind::Modify(_) | EventKind::Create(_) | EventKind::Remove(_) => Ok(None),
            _ => Ok(None),
        }
    }

    /// Register a callback for node changes
    pub fn on_node_change<F>(&self, _callback: F)
    where
        F: Fn(NodeID) + Send + Sync + 'static,
    {
        // Placeholder for future implementation
    }
}