Fs watcher (#113)

fs watcher

src/system/watcher/change.rs

@@ -0,0 +1,312 @@
+//! ## File system change
+//!
+//! this module exposes the types to describe a change to sync on the remote file system
+
+use crate::utils::path as path_utils;
+
+use std::path::{Path, PathBuf};
+
+/// Describes an operation on the remote file system to sync
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum FsChange {
+    /// Move file on remote
+    Move(FileToRename),
+    /// Remove file from remote
+    Remove(FileToRemove),
+    /// Upload file to remote
+    Update(FileUpdate),
+}
+
+impl FsChange {
+    /// Instantiate a new `FsChange::Move`
+    pub fn mov(
+        source: PathBuf,
+        destination: PathBuf,
+        local_watched_path: &Path,
+        remote_synched_path: &Path,
+    ) -> Self {
+        Self::Move(FileToRename::new(
+            source,
+            destination,
+            local_watched_path,
+            remote_synched_path,
+        ))
+    }
+
+    /// Instantiate a new `FsChange::Remove`
+    pub fn remove(
+        removed_path: PathBuf,
+        local_watched_path: &Path,
+        remote_synched_path: &Path,
+    ) -> Self {
+        Self::Remove(FileToRemove::new(
+            removed_path,
+            local_watched_path,
+            remote_synched_path,
+        ))
+    }
+
+    /// Instantiate a new `FsChange::Update`
+    pub fn update(
+        changed_path: PathBuf,
+        local_watched_path: &Path,
+        remote_synched_path: &Path,
+    ) -> Self {
+        Self::Update(FileUpdate::new(
+            changed_path,
+            local_watched_path,
+            remote_synched_path,
+        ))
+    }
+}
+
+/// Describes a file to rename on the remote fs
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct FileToRename {
+    /// Path to file which has to be renamed
+    source: PathBuf,
+    /// new filename
+    destination: PathBuf,
+}
+
+impl FileToRename {
+    /// Instantiate a new `FileToRename` given
+    ///
+    /// - the path of the source on local fs
+    /// - the path of the destination on local fs
+    /// - the path of the file/directory watched on the local fs
+    /// - the path of the remote file/directory synched with the local fs
+    ///
+    /// the `remote` is resolved pushing to `remote_synched_path` the diff between `changed_path` and `local_watched_path`
+    fn new(
+        source: PathBuf,
+        destination: PathBuf,
+        local_watched_path: &Path,
+        remote_synched_path: &Path,
+    ) -> Self {
+        Self {
+            source: remote_relative_path(&source, local_watched_path, remote_synched_path),
+            destination: remote_relative_path(
+                &destination,
+                local_watched_path,
+                remote_synched_path,
+            ),
+        }
+    }
+
+    /// Get path to the source to rename
+    pub fn source(&self) -> &Path {
+        self.source.as_path()
+    }
+
+    /// Get path to the destination name
+    pub fn destination(&self) -> &Path {
+        self.destination.as_path()
+    }
+}
+
+/// Describes a file to remove on remote fs
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct FileToRemove {
+    /// Path to the file which has to be removed
+    path: PathBuf,
+}
+
+impl FileToRemove {
+    /// Instantiate a new `FileToRemove` given
+    ///
+    /// - the path of the file which has been removed on localhost
+    /// - the path of the file/directory watched on the local fs
+    /// - the path of the remote file/directory synched with the local fs
+    ///
+    /// the `remote` is resolved pushing to `remote_synched_path` the diff between `removed_path` and `local_watched_path`
+    fn new(removed_path: PathBuf, local_watched_path: &Path, remote_synched_path: &Path) -> Self {
+        Self {
+            path: remote_relative_path(&removed_path, local_watched_path, remote_synched_path),
+        }
+    }
+
+    /// Get path to the file to unlink
+    pub fn path(&self) -> &Path {
+        self.path.as_path()
+    }
+}
+
+/// Describes a file changed to sync
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct FileUpdate {
+    /// Path to file which has changed
+    local: PathBuf,
+    /// Path to remote file to update
+    remote: PathBuf,
+}
+
+impl FileUpdate {
+    /// Instantiate a new `FileUpdate` given
+    ///
+    /// - the path of the file which has changed
+    /// - the path of the file/directory watched on the local fs
+    /// - the path of the remote file/directory synched with the local fs
+    ///
+    /// the `remote` is resolved pushing to `remote_synched_path` the diff between `changed_path` and `local_watched_path`
+    fn new(changed_path: PathBuf, local_watched_path: &Path, remote_synched_path: &Path) -> Self {
+        Self {
+            remote: remote_relative_path(&changed_path, local_watched_path, remote_synched_path),
+            local: changed_path,
+        }
+    }
+
+    /// Get path to local file to sync
+    pub fn local(&self) -> &Path {
+        self.local.as_path()
+    }
+
+    /// Get path to remote file to sync
+    pub fn remote(&self) -> &Path {
+        self.remote.as_path()
+    }
+}
+
+// -- utils
+
+/// Get remote relative path, given the local target, the path of the local watched path and the path of the remote synched directory/file
+fn remote_relative_path(
+    target: &Path,
+    local_watched_path: &Path,
+    remote_synched_path: &Path,
+) -> PathBuf {
+    let local_diff = path_utils::diff_paths(target, local_watched_path);
+    // get absolute path to remote file associated to local file
+    match local_diff {
+        None => remote_synched_path.to_path_buf(),
+        Some(p) => {
+            let mut remote = remote_synched_path.to_path_buf();
+            remote.push(p);
+            remote
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+
+    use super::*;
+
+    use pretty_assertions::assert_eq;
+
+    #[test]
+    fn should_get_remote_relative_path_from_subdir() {
+        assert_eq!(
+            remote_relative_path(
+                Path::new("/tmp/abc/test.txt"),
+                Path::new("/tmp"),
+                Path::new("/home/foo")
+            )
+            .as_path(),
+            Path::new("/home/foo/abc/test.txt")
+        );
+    }
+
+    #[test]
+    fn should_get_remote_relative_path_same_path() {
+        assert_eq!(
+            remote_relative_path(
+                Path::new("/tmp/abc/test.txt"),
+                Path::new("/tmp/abc/test.txt"),
+                Path::new("/home/foo/test.txt")
+            )
+            .as_path(),
+            Path::new("/home/foo/test.txt")
+        );
+    }
+
+    #[test]
+    fn should_make_fs_change_move_from_same_directory() {
+        let change = FsChange::mov(
+            PathBuf::from("/tmp/foo.txt"),
+            PathBuf::from("/tmp/bar.txt"),
+            Path::new("/tmp"),
+            Path::new("/home/foo"),
+        );
+        if let FsChange::Move(change) = change {
+            assert_eq!(change.source(), Path::new("/home/foo/foo.txt"));
+            assert_eq!(change.destination(), Path::new("/home/foo/bar.txt"));
+        } else {
+            panic!("not a Move");
+        }
+    }
+
+    #[test]
+    fn should_make_fs_change_move_from_subdirectory() {
+        let change = FsChange::mov(
+            PathBuf::from("/tmp/abc/foo.txt"),
+            PathBuf::from("/tmp/abc/bar.txt"),
+            Path::new("/tmp/abc"),
+            Path::new("/home/foo"),
+        );
+        if let FsChange::Move(change) = change {
+            assert_eq!(change.source(), Path::new("/home/foo/foo.txt"));
+            assert_eq!(change.destination(), Path::new("/home/foo/bar.txt"));
+        } else {
+            panic!("not a Move");
+        }
+    }
+
+    #[test]
+    fn should_make_fs_change_remove_from_same_directory() {
+        let change = FsChange::remove(
+            PathBuf::from("/tmp/bar.txt"),
+            Path::new("/tmp/bar.txt"),
+            Path::new("/home/foo/bar.txt"),
+        );
+        if let FsChange::Remove(change) = change {
+            assert_eq!(change.path(), Path::new("/home/foo/bar.txt"));
+        } else {
+            panic!("not a remove");
+        }
+    }
+
+    #[test]
+    fn should_make_fs_change_remove_from_subdirectory() {
+        let change = FsChange::remove(
+            PathBuf::from("/tmp/abc/bar.txt"),
+            Path::new("/tmp/abc"),
+            Path::new("/home/foo"),
+        );
+        if let FsChange::Remove(change) = change {
+            assert_eq!(change.path(), Path::new("/home/foo/bar.txt"));
+        } else {
+            panic!("not a remove");
+        }
+    }
+
+    #[test]
+    fn should_make_fs_change_update_from_same_directory() {
+        let change = FsChange::update(
+            PathBuf::from("/tmp/bar.txt"),
+            Path::new("/tmp/bar.txt"),
+            Path::new("/home/foo/bar.txt"),
+        );
+        if let FsChange::Update(change) = change {
+            assert_eq!(change.local(), Path::new("/tmp/bar.txt"),);
+            assert_eq!(change.remote(), Path::new("/home/foo/bar.txt"));
+        } else {
+            panic!("not an update");
+        }
+    }
+
+    #[test]
+    fn should_make_fs_change_update_from_subdirectory() {
+        let change = FsChange::update(
+            PathBuf::from("/tmp/abc/foo.txt"),
+            Path::new("/tmp"),
+            Path::new("/home/foo/temp"),
+        );
+        if let FsChange::Update(change) = change {
+            assert_eq!(change.local(), Path::new("/tmp/abc/foo.txt"),);
+            assert_eq!(change.remote(), Path::new("/home/foo/temp/abc/foo.txt"));
+        } else {
+            panic!("not an update");
+        }
+    }
+}