Ntree: a reimplementation of the tree utility

pub trait PathFilter {
    fn filter(&self, path: &Path) -> bool;
}

#[macro_use]
extern crate clap;
extern crate ntree;

use std::path::Path;
use std::process;
use ntree::print_processor::{PrintProcessor, SummaryFormat};
use ntree::tree;
use ntree::filters::{filter_hidden_files, filter_non_dirs, GitignoreFilter, AllFilters};

fn main() {
    let argv_matches = clap::App::new("ntree")
        .version(crate_version!())
        .author(crate_authors!())
        .about("New tree -- a modern reimplementation of tree.")
        .arg(clap::Arg::with_name("DIR")
            .help("The directory to list")
            .index(1))
        .arg(clap::Arg::with_name("a")
             .help("Show hidden files")
             .short("a"))
        .arg(clap::Arg::with_name("d")
             .help("List directories only")
             .short("d"))
        .arg(clap::Arg::with_name("git-ignore")
             .help("Do not list git ignored files")
             .short("g"))
        .get_matches();

    let dir = Path::new(argv_matches.value_of("DIR").unwrap_or("."));

    let mut filters = AllFilters::default();
    let mut procor = PrintProcessor::new();

    if !argv_matches.is_present("a") {
        filters.push(filter_hidden_files);
    }

    if argv_matches.is_present("d") {
        filters.push(filter_non_dirs);
        procor.set_summary_format(SummaryFormat::DirCount);
    }

    if argv_matches.is_present("git-ignore") {
        match GitignoreFilter::new(dir) {
            Ok(filter_gitignore) => {
                filters.push(filter_gitignore);
            },
            Err(err) => {
                println!("{}", err);
                process::exit(1);
            },
        }
    }

    if let Err(err) = tree::process(&dir, &mut procor, &filters) {
        println!("error: {}", err);
        process::exit(1);
    }
}

extern crate git2;

use std::path::Path;
use std::os::unix::ffi::OsStrExt;
use self::git2::Repository;

pub trait PathFilter {
    fn filter(&self, path: &Path) -> bool;
}

impl<F> PathFilter for F
    where F: Fn(&Path) -> bool
{
    fn filter(&self, path: &Path) -> bool {
        (self)(path)
    }
}

pub struct AllFilters {
    filters: Vec<Box<PathFilter>>,
}

impl AllFilters {
    pub fn push<F>(&mut self, f: F)
        where F: PathFilter + 'static
    {
        self.filters.push(Box::new(f))
    }
}

impl Default for AllFilters {
    fn default() -> Self {
        AllFilters {
            filters: Vec::new(),
        }
    }
}

impl PathFilter for AllFilters {
    fn filter(&self, path: &Path) -> bool {
        self.filters.iter().all(|f| f.filter(path))
    }
}

pub struct GitignoreFilter {
    repo: Repository,
}

impl GitignoreFilter {
    pub fn new(path: &Path) -> Result<Self, git2::Error> {
        Repository::discover(path).map(|repo| GitignoreFilter { repo: repo })
    }
}

impl PathFilter for GitignoreFilter {
    fn filter(&self, path: &Path) -> bool {
        // ./filename paths doesn't seem to work with should_ignore
        let path = path.canonicalize().unwrap();
        self.repo.status_should_ignore(&path)
            .map(|result| !result)
            .unwrap_or(false)
    }
}

pub fn filter_hidden_files(path: &Path) -> bool {
    // Is this implementation sound?
    path.file_name()
        .map(|name| !name.as_bytes().starts_with(b"."))
        .unwrap_or(false)
}

pub fn filter_non_dirs(path: &Path) -> bool {
    path.metadata()
        .map(|data| data.is_dir())
        .unwrap_or(false)
}

use std::io;
use std::fs;
use std::path::Path;
use super::tree_processor::TreeProcessor;
use super::filters::PathFilter;

pub fn process<T, F>(dir: &Path, procor: &mut T, filter: &F) -> io::Result<()>
    where T: TreeProcessor,
          F: PathFilter,
{
    let read_entries = try!(fs::read_dir(dir));

    let mut entries: Vec<_> = try!(read_entries.collect());
    entries.retain(|x| filter.filter(&x.path()));
    procor.open_dir(dir, entries.len());

    for entry in entries {
        let path = entry.path();

        let file_type = try!(entry.file_type());

        if file_type.is_dir() {
            try!(process(&path, procor, filter));
        } else {
            procor.file(&path);
        }
    }

    procor.close_dir();

    Ok(())
}