pub(crate) fn register(inotify: &mut Inotify, processor: &Processor) -> Option<WatchDescriptor> {
    println!(
        "Registering {:?} for \"{} {}\"",
        processor.path,
        processor.command,
        processor.args.join(" ")
    );
    inotify
        .add_watch(
            &processor.path,
            WatchMask::CLOSE_WRITE
                | WatchMask::MOVED_TO
                | WatchMask::MOVED_FROM
                | WatchMask::CREATE
                | WatchMask::DELETE,
        )
        .map_err(|e| eprintln!("Error: {}", e))
        .ok()
}

impl Processor {
    pub(crate) fn register(&self, inotify: &mut Inotify) -> Option<WatchDescriptor> {
        println!(
            "Registering {:?} for \"{} {}\"",
            self.path,
            self.command,
            self.args.join(" ")
        );
        inotify
            .add_watch(
                &self.path,
                WatchMask::CLOSE_WRITE
                    | WatchMask::MOVED_TO
                    | WatchMask::MOVED_FROM
                    | WatchMask::CREATE
                    | WatchMask::DELETE,
            )
            .map_err(|e| eprintln!("Error: {}", e))
            .ok()
    }

pub(crate) fn process(
    filename: &Path,
    command: &str,
    args: &[String],
    keep_file: bool,
) -> Result<(), Box<dyn Error>> {
    let bfilename = <[u8]>::from_path(filename).unwrap();
    let args = args.iter().map(|arg| {
        arg.as_bytes()
            .replace("%f", bfilename)
            .into_os_string()
            .unwrap()
    });
    Command::new(command).args(args).status()?.exit_ok()?;
    if !keep_file {
        println!("Removing {:?}", filename);
        fs::remove_file(filename)?;

    pub(crate) fn process(&self, filename: &Path) -> Result<(), Box<dyn Error>> {
        let bfilename = <[u8]>::from_path(filename).unwrap();
        let args = self.args.iter().map(|arg| {
            arg.as_bytes()
                .replace("%f", bfilename)
                .into_os_string()
                .unwrap()
        });
        Command::new(&self.command).args(args).status()?.exit_ok()?;
        if !self.keep_file {
            println!("Removing {:?}", filename);
            fs::remove_file(filename)?;
        }
        Ok(())

    Ok(())

            .filter_map(|p| processor::register(inotify, &p).map(|d| (d, p)))

            .filter_map(|p| p.register(inotify).map(|d| (d, p)))

            processor::process(
                &filename,
                &processor.command,
                &processor.args[..],
                processor.keep_file,
            )
            .unwrap_or_else(|e| eprintln!("Error: {}", e));

            processor
                .process(&filename)
                .unwrap_or_else(|e| eprintln!("Error: {}", e));