Move all optional features into features module

This module provides feature-specific implementations, and also dummy implementations for when they aren't supported by the system or OS.

Doing it this way limits all the #[cfg(feature)] annotations, as we can now just include the module or not.

1 files changed, 6 insertions, 105 deletions

diff --git a/src/dir.rs b/src/dir.rs
index 9799ab3..623ff3e 100644
--- a/src/dir.rs
+++ b/src/dir.rs
@@ -1,11 +1,9 @@
 use std::old_io::{fs, IoResult};
 use std::old_path::GenericPath;
 use std::old_path::posix::Path;
-use file::{File, GREY};
 
-#[cfg(feature="git")] use ansi_term::{ANSIString, ANSIStrings};
-#[cfg(feature="git")] use ansi_term::Colour::*;
-#[cfg(feature="git")] use git2;
+use feature::Git;
+use file::{File, GREY};
 
 /// A **Dir** provides a cached list of the file paths in a directory that's
 /// being listed.
@@ -20,6 +18,7 @@ pub struct Dir {
 }
 
 impl Dir {
+
     /// Create a new Dir object filled with all the files in the directory
     /// pointed to by the given path. Fails if the directory can't be read, or
     /// isn't actually a directory.
@@ -67,107 +66,9 @@ impl Dir {
     /// Get a string describing the Git status of the given file.
     pub fn git_status(&self, path: &Path, prefix_lookup: bool) -> String {
         match (&self.git, prefix_lookup) {
-            (&Some(ref git), false) => git.status(path),
-            (&Some(ref git), true)  => git.dir_status(path),
-            (&None, _)              => GREY.paint("--").to_string(),
-        }
-    }
-}
-
-/// Container of Git statuses for all the files in this folder's Git repository.
-#[cfg(feature="git")]
-struct Git {
-    statuses: Vec<(Path, git2::Status)>,
-}
-
-#[cfg(feature="git")]
-impl Git {
-
-    /// Discover a Git repository on or above this directory, scanning it for
-    /// the files' statuses if one is found.
-    fn scan(path: &Path) -> Result<Git, git2::Error> {
-        use std::os::unix::ffi::OsStrExt;
-        use std::ffi::AsOsStr;
-
-        // TODO: libgit2-rs uses the new Path module, but exa still uses the
-        // old_path one, and will have to continue to do so until the new IO
-        // module gets a bit more developed. So we have to turn Paths into
-        // old_path::Paths. Yes, this is hacky, but hopefully temporary.
-        let repo = try!(git2::Repository::discover(path));
-        let workdir = match repo.workdir() {
-            Some(w) => Path::new(w.as_os_str().as_bytes()),
-            None => return Ok(Git { statuses: vec![] }),  // bare repo
-        };
-
-        let statuses = try!(repo.statuses(None)).iter()
-                                                .map(|e| (workdir.join(e.path_bytes()), e.status()))
-                                                .collect();
-        Ok(Git { statuses: statuses })
-    }
-
-    /// Get the status for the file at the given path, if present.
-    fn status(&self, path: &Path) -> String {
-        let status = self.statuses.iter()
-                                  .find(|p| &p.0 == path);
-        match status {
-            Some(&(_, s)) => ANSIStrings( &[Git::index_status(s), Git::working_tree_status(s) ]).to_string(),
-            None => GREY.paint("--").to_string(),
+            (&Some(ref git), false)  => git.status(path),
+            (&Some(ref git), true)   => git.dir_status(path),
+            (&None, _)               => GREY.paint("--").to_string(),
         }
     }
-
-    /// Get the combined status for all the files whose paths begin with the
-    /// path that gets passed in. This is used for getting the status of
-    /// directories, which don't really have an 'official' status.
-    fn dir_status(&self, dir: &Path) -> String {
-        let s = self.statuses.iter()
-                             .filter(|p| dir.is_ancestor_of(&p.0))
-                             .fold(git2::Status::empty(), |a, b| a | b.1);
-
-        ANSIStrings( &[Git::index_status(s), Git::working_tree_status(s)] ).to_string()
-    }
-
-    /// The character to display if the file has been modified, but not staged.
-    fn working_tree_status(status: git2::Status) -> ANSIString<'static> {
-        match status {
-            s if s.contains(git2::STATUS_WT_NEW) => Green.paint("A"),
-            s if s.contains(git2::STATUS_WT_MODIFIED) => Blue.paint("M"),
-            s if s.contains(git2::STATUS_WT_DELETED) => Red.paint("D"),
-            s if s.contains(git2::STATUS_WT_RENAMED) => Yellow.paint("R"),
-            s if s.contains(git2::STATUS_WT_TYPECHANGE) => Purple.paint("T"),
-            _ => GREY.paint("-"),
-        }
-    }
-
-    /// The character to display if the file has been modified, and the change
-    /// has been staged.
-    fn index_status(status: git2::Status) -> ANSIString<'static> {
-        match status {
-            s if s.contains(git2::STATUS_INDEX_NEW) => Green.paint("A"),
-            s if s.contains(git2::STATUS_INDEX_MODIFIED) => Blue.paint("M"),
-            s if s.contains(git2::STATUS_INDEX_DELETED) => Red.paint("D"),
-            s if s.contains(git2::STATUS_INDEX_RENAMED) => Yellow.paint("R"),
-            s if s.contains(git2::STATUS_INDEX_TYPECHANGE) => Purple.paint("T"),
-            _ => GREY.paint("-"),
-        }
-    }
-}
-
-#[cfg(not(feature="git"))]
-struct Git;
-
-#[cfg(not(feature="git"))]
-impl Git {
-    fn scan(_: &Path) -> Result<Git, ()> {
-        // Don't do anything without Git support
-        Err(())
-    }
-
-    fn status(&self, _: &Path) -> String {
-        // The Err above means that this should never happen
-        panic!("Tried to access a Git repo without Git support!");
-    }
-
-    fn dir_status(&self, path: &Path) -> String {
-        self.status(path)
-    }
 }