Method parse

src/shell/handler.rs:53–98

TODO: this should return a Result >, Error>

(&mut self, command: &str)

    // TODO: this should return a Result<Option<Vec<u8>>, Error>
    pub fn parse(&mut self, command: &str) -> Option<Vec<u8>> {
        if command == EXIT_HANDLER_TOKEN {
            return Some(command.as_bytes().to_owned());
        }

        if self.compiled.is_none() {
            self.compiled = Some(
                Regex::new(&self.parser)
                    .unwrap_or_else(|_| panic!("could not compile '{}'", &self.parser)),
            );
        }

        // check command for matches
        if let Some(captures) = self.compiled.as_ref().unwrap().captures(command) {
            let handler = self.handle_with_captures(&captures);

            // check cache first
            if let Some(out) = self.cache.get(&handler) {
                debug!("'{}' from cache: {}", &handler, out.len());
                return Some(out.to_owned());
            }

            // docker exec?
            if let Some(exec) = DOCKER_HANDLER_PARSER.captures(&handler) {
                let (container_id, command) = (&exec[1], &exec[2]);
                match docker::exec(container_id, command) {
                    Ok(data) => {
                        debug!("docker_exec('{}') -> {:?}", command, data);
                        self.cache.insert(handler, data.clone());
                        return Some(data);
                    }
                    Err(e) => {
                        error!(
                            "error running '{}' inside container '{}': {}",
                            command, container_id, e
                        );
                        return Some("".as_bytes().to_owned());
                    }
                }
            }

            return Some(handler.as_bytes().to_owned());
        }
        // this is not the handler you're looking for ...
        None
    }
}