X-up utility for EVE Online

match foo {
    Some(x) => x,
    None => panic!("a message"),
}

extern crate clap;
extern crate yaml_rust;

use std::collections::HashMap;
use std::env::home_dir;
use std::fs::File;
use std::io::Read;
use std::path::{Path, PathBuf};

use clap::{App, Arg, SubCommand};

use self::yaml_rust::{Yaml, YamlLoader};

mod doctrine;

fn yaml_cfg_path() -> PathBuf {
    let yaml_cfg_relative_path = "Dropbox/Log/Xup/xup/src/xup.yaml";
    let mut home_dir = home_dir().expect("Could not resolve home directory.");
    home_dir.push(yaml_cfg_relative_path);
    home_dir
}

fn file_contents(path: &Path) -> String {
    let mut file = File::open(&path).expect("Can't open file");
    let mut contents = String::new();
    file.read_to_string(&mut contents).expect("Can't read file");
    contents
}

fn load_yaml_cfg() -> Yaml {
    let yaml_cfg_path = yaml_cfg_path();
    let file_contents = file_contents(&yaml_cfg_path);
    let mut contents = YamlLoader::load_from_str(&file_contents).expect("Couldn't load");

    let num_documents = contents.len();
    if num_documents > 1 {
        println!("{} documents found in {} ...", num_documents, yaml_cfg_path.display());
        println!("Reading doctrines from the first document and ignoring the rest.");
    }
    contents.swap_remove(0)
}

type DoctrineName = String;

fn load_doctrines() -> HashMap<DoctrineName, doctrine::Doctrine> {
    let doctrines = doctrine::Doctrine::many_from_yaml(&load_yaml_cfg()).expect("Something");
    doctrines.into_iter().map(|d| (d.name.clone(), d)).collect()
}

fn ships(doctrine: &doctrine::Doctrine) -> Vec<String> {
    doctrine.categories.iter().flat_map(|c| c.ships.iter().cloned()).collect()
}

fn xup(doctrine: &doctrine::Doctrine) -> String {
    "x ".to_string() + &ships(doctrine).join(" / ")
}

fn main() {
    let matches = App::new("xup")
        .about("Outputs x-up string for given doctrine")
        .arg(Arg::with_name("doctrine")
            .short("d")
            .long("doctrine")
            .value_name("DOCTRINE")
            .takes_value(true))
        .subcommand(SubCommand::with_name("ls").about("Lists available doctrines"))
        .get_matches();

    let doctrines = load_doctrines();

    if let Some(_) = matches.subcommand_matches("ls") {
        for doctrine_name in doctrines.keys() {
            println!("{}", doctrine_name);
        }
        return;
    }

    match matches.value_of("doctrine") {
        Some(doctrine_name) => {
            match doctrines.get(doctrine_name) {
                Some(doctrine) => println!("{}", xup(&doctrine)),
                None => println!("Requested doctrine {} not found.", doctrine_name),
            }
        }
        None => println!("No doctrine requested."),
    }
}

extern crate yaml_rust;

use self::yaml_rust::{yaml, Yaml};

#[derive(Debug, Clone, PartialEq)]
pub struct Doctrine {
    pub name: String,
    pub categories: Vec<Category>,
}

#[derive(Debug, Clone, PartialEq)]
pub struct Category {
    pub ships: Vec<String>,
}

pub type Result<T> = ::std::result::Result<T, &'static str>; //' just fixing the CR pretty-printer

fn load_name(doctrine: &yaml::Hash) -> Result<&str> {
    let name_key = Yaml::String("name".into());
    doctrine.get(&name_key)
        .ok_or("Doctrine name not a string.")
        .and_then(|name| {
            name.as_str().ok_or("Doctrine name not a string.")
        })
}

fn load_categories(doctrine: &yaml::Hash) -> Result<Vec<Category>> {
    let categories_key = Yaml::String("categories".into());
    doctrine.get(&categories_key)
        .ok_or("Doctrine has no categories.")
        .and_then(Category::many_from_yaml)
}

impl Doctrine {
    fn from_yaml(yaml: &Yaml) -> Result<Self> {
        yaml.as_hash()
            .ok_or("Expected doctrine.")
            .and_then(|doctrine| {
                let name = try!(load_name(&doctrine));
                let categories = try!(load_categories(&doctrine));

                Ok(Doctrine {
                    name: name.to_string(),
                    categories: categories,
                })
            })
    }

    pub fn many_from_yaml(doctrines: &Yaml) -> Result<Vec<Self>> {
        doctrines.as_vec()
            .ok_or("Expected list of doctrines.")
            .and_then(|doctrines| {
                doctrines.iter().map(Doctrine::from_yaml).collect()
            })
    }
}

fn load_ships(category_ships: &Yaml) -> Vec<String> {
    category_ships.as_vec()
        .map(|ships| {
            ships.iter().map(|ship| {
                let name = ship.as_str().expect("Ship name was not a string");
                String::from(name)
            }).collect()
        })
        .unwrap_or_else(Vec::new)
}

fn load_category(category: &yaml::Hash) -> Result<Category> {
    let category_key = Yaml::String("category".into());
    category.get(&category_key)
        .ok_or("Could not find category.")
        .map(|category_ships| {
            let ships = load_ships(&category_ships);
            Category { ships: ships }
        })
}

impl Category {
    fn from_yaml(yaml: &Yaml) -> Result<Self> {
        yaml.as_hash()
            .ok_or("Expected category.")
            .and_then(load_category)
    }

    fn many_from_yaml(categories: &Yaml) -> Result<Vec<Self>> {
        categories.as_vec()
            .ok_or("Expected list of categories.")
            .and_then(|categories| {
                categories.iter().map(Category::from_yaml).collect()
            })
    }
}

#[cfg(test)]
mod test {
    use super::*;
    use super::yaml_rust::{Yaml, YamlLoader};

    fn quick_parse(s: &str) -> Yaml {
        YamlLoader::load_from_str(&s).expect("Couldn't parse test YAML").swap_remove(0)
    }

    #[test]
    fn test_parse_categories() {
        l