htmli 0.1.3

Statically resolved include directives for HTML. 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

// Copyright 2017 Nathan Sizemore <nathanrsizemore@gmail.com>
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this file,
// you can obtain one at http://mozilla.org/MPL/2.0/.


extern crate docopt;
extern crate minifier;
#[macro_use]
extern crate serde_derive;


use std::error::Error;
use std::fmt::Debug;
use std::fs::File;
use std::io::{self, Write};
use std::path::Path;

use docopt::Docopt;
use minifier::html;


mod parser;


const VERSION_STR: &'static str = "htmli 0.1.3

Copyright (c) 2017 Nathan Sizemore <nathanrsizemore@gmail.com>
License: MPL-2.0 https://www.mozilla.org/en-US/MPL/2.0
This is free software: you are free to change and redistribute it.";


const USAGE: &'static str = "
htmli - Utility to statically resolve html-include directives.

Usage:
    htmli <file> [--minify] [--output=<f>]
    htmli (-h | --help)
    htmli --version

Options:
    -m --minify        Minifies output.
    -o --output=<f>    Direct output to file.

    -h --help          Show this screen.
    --version          Show version.
";


#[derive(Debug, Deserialize)]
pub struct Args {
    pub arg_file: String,
    pub flag_minify: bool,
    pub flag_output: String,
    pub flag_version: bool
}


fn main() {
    let args: Args = Docopt::new(USAGE)
        .and_then(|d| d.deserialize())
        .unwrap_or_else(|e| e.exit());

    match handle_input(&args) {
        Ok(_) => std::process::exit(0),
        Err(e) => {
            println!("{}", e);
            std::process::exit(-1);
        }
    };
}

fn handle_input(args: &Args) -> Result<(), String> {
    if args.flag_version {
        println!("{}", VERSION_STR);
        return Ok(());
    }

    let (input_path, mut input_file) = try!(open_as_file(&args.arg_file));
    let mut html_str = try!(parser::parse(input_path, &mut input_file));

    if args.flag_minify {
        html_str = html::minify(&html_str);
    }

    if args.flag_output.len() == 0 {
        println!("{}", html_str);
        return Ok(());
    }

    let output_path = Path::new(&args.flag_output);
    let mut output_file = try!(create_file(output_path));
    let result = try!(write_to_file(&mut output_file, html_str.as_bytes()));

    Ok(result)
}

fn open_as_file(s: &String) -> Result<(&Path, File), String> {
    let path = Path::new(s);
    let result = File::open(path);
    if result.is_err() { return Err(desc_from_err(result)); }
    let file = result.unwrap();

    Ok((path, file))
}

fn create_file(path: &Path) -> Result<File, String> {
    let result = File::create(path);
    if result.is_err() { return Err(desc_from_err(result)); }
    let file = result.unwrap();

    Ok(file)
}

fn write_to_file(file: &mut File, bytes: &[u8]) -> Result<(), String> {
    let result = file.write_all(bytes);
    if result.is_err() { Err(desc_from_err(result)) } else { Ok(()) }
}

fn desc_from_err<T: Debug>(result: Result<T, io::Error>) -> String {
    let err = result.unwrap_err();
    format!("{}", err.description())
}