let file = fs::File::open(to_path(url))
        .expect("Failed to open the file.");

    match url.scheme() {
        "file" => {
            let file = fs::File::open(to_path(url))
                .expect("Failed to open the file.");
            serde_yaml::from_reader(file)
                .expect("Failed to parse the file.")
        }
        _ => {
            panic!("Failed to par {url}, remote files are not implemented yet.");
        }
    }
}

    serde_yaml::from_reader(file)
        .expect("Failed to parse the file.")

fn resolve_dir(url: &Url) -> Url {
    match url.scheme() {
        "file" => {
            let mut path = to_path(&url);
            if path.is_dir() {
                path.push("karbon.yml");
                if path.is_file() {
                    return to_url(&path);
                }
                path.set_extension("yaml");
                if path.is_file() {
                    return to_url(&path);
                }
                panic!("Failed to find any karbonfile.[yml|yaml] files in {url}");
            }
            if path.is_file() {
                return url.to_owned();
            }
            panic!("{url} is not a valid file or directory");
        }
        _ => {
            panic!("Remote files are not implemented yet.");
        }
    }

fn merge_url(base: &url, s: &str) -> Url {

fn merge_url(base: &Url, s: &str) -> Url {
    base.join(s)
        .expect("Failed to merge {url} and {s}")

    url: Url,

    original_url: Url,

    let url = resolve_dir(&original_url);

    let maybeKarbonfile = Karbonfile::from_value(&url, &doc);
    println!("{:#?}", maybeKarbonfile);
    if let Ok(karbonfile) = maybeKarbonfile {

    if let Ok(karbonfile) = serde_yaml::from_value(doc) {

            println!("Doesn't have resources");

            println!("Has resources. Iterating:");

                let next = merge_url(url, &r.url);
                build_variants(next_path, variant.clone(), result);

                let next = merge_url(&url, &r);
                build_variants(next, variant.clone(), result);

fn push_transformations(variant: &mut Variant, url: &Url, kfile: &Karbonfile) {
    variant
        .transformations
        .iter_mut()
        .map(|t| t.push(
                (&url, kfile.transformations.to_owned())
                )

fn push_transformations(variant: &mut Variant, url: &Url, karbonfile: &Karbonfile) {
    let new = (
        url.to_owned(),
        karbonfile.transformations.to_owned()
    );
    println!("{:#?}", &new);
    match &variant.transformations {
        None => {
            variant.transformations = Some(
                vec!(new)

        }
        Some(t) => {
            let mut new_t = t.to_owned();
            new_t.push(new);
            variant.transformations = Some(new_t);
        }
    }

    v.url = Some(url);

    v.url = Some(url.to_owned());

            build_variants(path, Variant::new(), &mut result);

            
            build_variants(to_url(&path), Variant::new(), &mut result);

            //println!("{:#?}", &result);

            println!("{}", serde_yaml::to_string(&result).unwrap());

            for r in result.iter() {
                println!("{:#?}", r.transformations);
            }

            //for t in &result {
            //    println!("{}", serde_yaml::to_string(&t.transformations).unwrap());
            //}

use serde::Deserialize;

use serde::{Deserialize, Serialize};

#[derive(Deserialize, Clone, Debug)]

#[derive(Deserialize, Serialize, Clone, Debug)]

use serde::{Deserialize, Deserializer, de::IntoDeserializer};

use serde::{Deserialize, Serialize};

#[derive(Deserialize, Clone, Debug)]

#[derive(Deserialize, Serialize, Clone, Debug)]
#[serde(rename_all = "camelCase")]
#[serde(deny_unknown_fields)]

    pub api_version: String,
    pub kind: String,

    pub api_version: ApiVersion,
    pub kind: Kind,

impl Karbonfile {
    pub fn from_value(url: &Url, doc: &Value) -> Result<Karbonfile, serde_yaml::Error> {
        let mut v = doc.to_owned();
        println!("{:#?}", &v);
        v["fileUrl"] = serde_yaml::from_str(url.as_str()).unwrap();
        serde_yaml::from_value::<Karbonfile>(v)
    }
}
#[derive(Deserialize)]

#[derive(Deserialize, Serialize, Clone, Debug)]

pub struct RawKarbonfile {
    file_url: Url,
    api_version: String,
    kind: String,

struct RawKarbonfile {
    pub api_version: ApiVersion,
    pub kind: Kind,

    resources: HashMap<String, ()>, 

    pub resources: HashMap<Resource, ()>, 

    generators: Vec<Generator>,

    pub generators: Vec<Generator>,

    transformations: Vec<Transformation>,

    pub transformations: Vec<Transformation>,

        let r = t
                .resources
                .into_iter()
                .map(|(k, v)| {
                    if let Ok(url) = Url::parse(&k) {
                        return url;
                    } else {
                        let path = Path::new(&k);
                        let base = t.file_url.to_file_path().unwrap();
                        let canonical = base.join(path).canonicalize().unwrap();
                        if canonical.is_file() {
                            return Url::from_file_path(canonical).unwrap();
                        } else {
                            println!("{:#?}", &path);
                            return Url::from_directory_path(canonical).unwrap();
                        }
                    }
                })
                .collect();

            resources: r, 

            resources: t
                .resources
                .into_keys()
                .collect(),

pub type Resource = Url;

pub type ApiVersion = String;
pub type Kind = String;
pub type Resource = String;

#[derive(Deserialize, Clone, Debug)]

#[derive(Deserialize, Serialize, Clone, Debug)]

#[derive(Clone, Debug)]

#[derive(Deserialize, Serialize, Clone, Debug)]