Initial commit.

Author: steveklabnik

.gitignore

@@ -0,0 +1,2 @@
+target
+Cargo.lock

Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+authors = ["steveklabnik <steve@steveklabnik.com>"]
+name = "dir-diff"
+version = "0.1.0"
+
+[dependencies]
+diff = "0.1.10"
+walkdir = "1.0.7"

src/lib.rs

@@ -0,0 +1,103 @@
+//! Determine if two directories have different contents.
+//!
+//! For now, only one function exists: are they different, or not? In the future,
+//! more functionality to actually determine the difference may be added.
+//!
+//! # Examples
+//!
+//! ```no_run
+//! extern crate dir_diff;
+//! 
+//! assert!(dir_diff::is_different("dir/a", "dir/b").unwrap());
+//! ```
+
+extern crate diff;
+extern crate walkdir;
+
+use std::fs::File;
+use std::io::prelude::*;
+use std::path::Path;
+
+use walkdir::WalkDir;
+
+/// The various errors that can happen when diffing two directories
+#[derive(Debug)]
+pub enum Error {
+    Io(std::io::Error),
+    StripPrefix(std::path::StripPrefixError),
+    WalkDir(walkdir::Error),
+}
+
+/// Are two directories different?
+///
+/// # Examples
+///
+/// ```no_run
+/// extern crate dir_diff;
+/// 
+/// assert!(dir_diff::is_different("dir/a", "dir/b").unwrap());
+/// ```
+pub fn is_different<A: AsRef<Path>, B: AsRef<Path>>(a_base: A, b_base: B) -> Result<bool, Error> {
+    let a_base = a_base.as_ref();
+    let b_base = b_base.as_ref();
+
+    for entry in WalkDir::new(a_base) {
+        let entry = entry?;
+        let a = entry.path();
+
+        // calculate just the part of the path relative to a
+        let no_prefix = a.strip_prefix(a_base)?;
+
+        // and then join that with b to get the path in b
+        let b = b_base.join(no_prefix);
+
+        if a.is_dir() {
+            if b.is_dir() {
+                // can't compare the contents of directories, so just continue
+                continue;
+            } else {
+                // if one is a file and one is a directory, we have a difference!
+                return Ok(false)
+            }
+        }
+
+        let a_text = read_to_string(a)?;
+        let b_text = read_to_string(b)?;
+
+        for result in diff::lines(&a_text, &b_text) {
+            match result {
+                diff::Result::Both(..) => (),
+                _ => return Ok(false),
+            }
+        }
+    }
+
+    Ok(true)
+}
+
+fn read_to_string<P: AsRef<Path>>(file: P) -> Result<String, std::io::Error> {
+    let mut data = String::new();
+    let mut file = File::open(file.as_ref())?;
+
+    file.read_to_string(&mut data)?;
+
+    Ok(data)
+}
+
+impl From<std::io::Error> for Error {
+    fn from(e: std::io::Error) -> Error {
+        Error::Io(e)
+    }
+}
+
+impl From<std::path::StripPrefixError> for Error {
+    fn from(e: std::path::StripPrefixError) -> Error {
+        Error::StripPrefix(e)
+    }
+}
+
+impl From<walkdir::Error> for Error {
+    fn from(e: walkdir::Error) -> Error {
+        Error::WalkDir(e)
+    }
+}

tests/easy/bad/dir1/test.txt

@@ -0,0 +1 @@
+testing testing

tests/easy/bad/dir2/test.txt

@@ -0,0 +1 @@
+oh no!

tests/easy/good/dir1/test.txt

@@ -0,0 +1 @@
+testing testing

tests/easy/good/dir2/test.txt

@@ -0,0 +1 @@
+testing testing

tests/smoke.rs

@@ -0,0 +1,11 @@
+extern crate dir_diff;
+
+#[test]
+fn easy_good() {
+    assert!(dir_diff::is_different("tests/easy/good/dir1", "tests/easy/good/dir2").unwrap());
+}
+
+#[test]
+fn easy_bad() {
+    assert!(!dir_diff::is_different("tests/easy/bad/dir1", "tests/easy/bad/dir2").unwrap());
+}