icon-pie 0.1.4-beta

A simple command-line tool for generating application icons.
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

use std::{path::PathBuf, iter::{Iterator, Peekable, Enumerate}, slice::Iter};
use crate::{Command, IconType, ResamplingFilter, Entries, Output, syntax, error::{Error, SyntaxError}};
use token::{Flag};
pub use token::Token;

mod token;
type TokenStream<'a> = Peekable<Enumerate<Iter<'a, Token>>>;

macro_rules! icon {
    ($entries:expr, $type:expr) => {
        Command::Icon($entries, $type, Output::Stdout)
    };
    ($entries:expr, $type:expr, $path:expr) => {
        Command::Icon($entries, $type, Output::Path($path))
    };
}

pub fn args() -> Result<Command, Error> {
    let args = crate::args();

    if args.is_empty() { return Ok(Command::Help); }

    let n_entries = args.iter().fold(0, |sum, arg| if arg == "-e" { sum + 1 } else { sum });
    let mut entries = Vec::with_capacity(n_entries);

    let tokens = tokens(args);
    let mut it = tokens.iter().enumerate().peekable();

    while let Some(&(c, token)) = it.peek() {
        match token {
            Token::Flag(Flag::Entry)   => add_entry(&mut it, &mut entries)?,
            Token::Flag(Flag::Help)    => return expect_end(&mut it, Command::Help),
            Token::Flag(Flag::Version) => return expect_end(&mut it, Command::Version),
            Token::Flag(Flag::Ico) | Token::Flag(Flag::Icns) | Token::Flag(Flag::Png)
                => return command(&mut it, entries),
            _   => return syntax!(SyntaxError::UnexpectedToken(c))
        }
    }

    syntax!(SyntaxError::UnexpectedEnd)
}

#[inline]
fn tokens<'a>(args: Vec<String>) -> Vec<Token> {
    args.iter().map(|arg| Token::from(arg.as_ref())).collect()
}

fn entry(it: &mut TokenStream, entries: &mut Entries, path: &PathBuf) -> Result<(), Error> {
    // TODO Preallocate this Vec
    let mut sizes = Vec::with_capacity(0);

    it.next();
    match it.peek() {
        Some(&(_, Token::Size(_))) => while let Some(&(_, Token::Size(size))) = it.peek() {
            it.next();
            sizes.push(*size);
        },
        Some(&(c, _)) => return syntax!(SyntaxError::UnexpectedToken(c)),
        None          => return syntax!(SyntaxError::UnexpectedEnd)
    }

    let filter = filter(it)?;

    for size in sizes {
        entries.push((size, path.clone(), filter));
    }

    Ok(())
}

fn add_entry(it: &mut TokenStream, entries: &mut Entries) -> Result<(), Error> {
    it.next();
    match it.peek() {
        Some(&(_, Token::Path(path))) => entry(it, entries, path),
        Some(&(c, _)) => syntax!(SyntaxError::UnexpectedToken(c)),
        None          => syntax!(SyntaxError::UnexpectedEnd)
    }
}

fn filter(it: &mut TokenStream) -> Result<ResamplingFilter, Error> {
    if let Some((_, Token::Flag(Flag::Resample))) = it.peek() {
        it.next();
        match it.peek() {
            Some(&(_, Token::Filter(filter))) => { it.next(); return Ok(*filter); },
            Some(&(c, _)) => return syntax!(SyntaxError::UnexpectedToken(c)),
            None          => return syntax!(SyntaxError::UnexpectedEnd)
        }
    }

    Ok(ResamplingFilter::Nearest)
}

fn command(it: &mut TokenStream, entries: Entries) -> Result<Command, Error> {
    let icon_type = icon_type(it)?;

    it.next();
    match it.peek() {
        Some(&(_, Token::Path(path))) => expect_end(it, icon!(entries, icon_type, path.clone())),
        Some(&(c, _)) => syntax!(SyntaxError::UnexpectedToken(c)),
        None          => Ok(icon!(entries, icon_type))
    }
}

fn icon_type(it: &mut TokenStream) -> Result<IconType, Error> {
    match it.peek() {
        Some(&(_, Token::Flag(Flag::Ico)))  => Ok(IconType::Ico),
        Some(&(_, Token::Flag(Flag::Icns))) => Ok(IconType::Icns),
        Some(&(_, Token::Flag(Flag::Png)))  => Ok(IconType::PngSequence),
        Some(&(c, _))                       => syntax!(SyntaxError::UnexpectedToken(c)),
        None                                => syntax!(SyntaxError::UnexpectedEnd)
    }
}

fn expect_end(it: &mut TokenStream, command: Command) -> Result<Command, Error> {
    it.next();
    match it.peek() {
        Some(&(c, _)) => syntax!(SyntaxError::UnexpectedToken(c)),
        None => Ok(command)
    }
}