build.rs

#[macro_use]
extern crate serde;

use flate2::Compression;
use flate2::write::GzEncoder;
use reqwest::Client;
use serde_json::Value;
use std::env;
use std::fs;
use std::fs::File;
use std::io::Write;
use std::path::Path;

#[derive(Debug, Deserialize)]
#[serde(rename_all(deserialize = "camelCase"))]
enum LicenseSource {
    Url,
    Github,
}

#[derive(Debug, Deserialize)]
struct LicenseReplace {
    year: Option<String>,
    name: Option<String>,
}

#[derive(Debug, Deserialize)]
struct License {
    id: String,
    source: LicenseSource,
    value: String,
    replace: Option<LicenseReplace>,
}

fn fetch_url_to_string(url: &str, client: &Client, token: &Option<String>) -> String {
    let request = client.get(url);
    if let Some(token) = token {
        request.header("Authorization", format!("token {}", token))
    } else {
        request
    }
    .send()
    .expect("Can't fetch url")
    .text()
    .expect("Can't convert fetched contents to string")
}

fn gz_encode_str(src: &str, level: Compression) -> Vec<u8> {
    let mut encoder = GzEncoder::new(Vec::new(), level);
    encoder.write_all(src.as_bytes()).expect("Can't write to gzip encoder");
    encoder.finish().expect("Can't finish gzip encoding")
}

fn main() {
    let mut module_contents =
        "{ let mut hm: HashMap<&'static str, &'static [u8]> = HashMap::new(); ".to_owned();

    let licenses_file_contents =
        fs::read_to_string("./resources/licenses.json").expect("Can't read licenses.json");
    let licenses: Vec<License> =
        serde_json::from_str(&licenses_file_contents).expect("Can't deserialized licenses.json");

    let http_client = Client::new();
    let gh_token = if let Ok(token) = env::var("GITHUB_TOKEN") {
        Some(token)
    } else {
        None
    };

    for license in licenses {
        eprintln!("Processing info for {}...", &license.id);

        let mut contents = String::new();
        match license.source {
            LicenseSource::Url => {
                let fetched_contents = fetch_url_to_string(&license.value, &http_client, &None);
                contents.push_str(&fetched_contents);
            }
            LicenseSource::Github => {
                let fetched_contents = fetch_url_to_string(
                    &format!("https://api.github.com/licenses/{}", &license.value),
                    &http_client,
                    &gh_token,
                );
                let fetched_json: Value = serde_json::from_str(&fetched_contents)
                    .expect("Can't deserialized fetched GitHub license info");
                contents.push_str(
                    fetched_json["body"]
                        .as_str()
                        .expect("Can't find body field on fetched GitHub license info"),
                );
            }
        }
        if let Some(replace) = license.replace {
            if let Some(year) = replace.year {
                contents = contents.replace(&year, "{{ year }}");
            }
            if let Some(name) = replace.name {
                contents = contents.replace(&name, "{{ name }}");
            }
        }
        contents = contents.replace("\r", "");
        if !contents.ends_with("\n") {
            contents.push('\n');
        }

        let gz_contents = gz_encode_str(&contents, Compression::best());
        let to_insert = format!("hm.insert({:?}, &{:?});", &license.id, gz_contents.as_slice());
        module_contents.push_str(&to_insert);
    }

    module_contents.push_str(" hm };");

    let out_dir = env::var("OUT_DIR").expect("OUT_DIR is not defined");
    let dest_path = Path::new(&out_dir).join("licenses.rs");
    let mut out_file = File::create(&dest_path).expect("Can't create output file");
    out_file
        .write_all(module_contents.as_bytes())
        .expect("Can't write to output file");

    eprint!("{}", &module_contents);
}