pythonic 0.3.0

pythonic is a Rust AST builder that generates Python
Documentation 
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

use std::fmt::{Display, Formatter, Result};

use {Argument, Assignment, Class, Comment, Function, FunctionCall, KeywordArgument};

#[derive(Debug, Clone)]
pub enum Statement {
    Argument(Argument),
    Assignment(Assignment),
    Class(Class),
    Comment(Comment),
    Function(Function),
    FunctionCall(FunctionCall),
    KeywordArgument(KeywordArgument),
}

impl Display for Statement {
    fn fmt(&self, f: &mut Formatter) -> Result {
        let s: String = match self {
            &Statement::Argument(ref s) => format!("{}", s),
            &Statement::Assignment(ref s) => format!("{}", s),
            &Statement::Comment(ref s) => format!("{}", s),
            &Statement::Class(ref s) => format!("{}", s),
            &Statement::FunctionCall(ref s) => format!("{}", s),
            &Statement::Function(ref s) => format!("{}", s),
            &Statement::KeywordArgument(ref s) => format!("{}", s),
        };
        write!(f, "{}", s)
    }
}

impl Statement {
    pub fn variable<T: Display>(name: T) -> Statement {
        Statement::Argument(Argument::variable(name))
    }

    pub fn unnamed_variable<T: Display>(value: T) -> Statement {
        Statement::Argument(Argument::Unnamed(value.to_string()))
    }

    pub fn function_call<T: Display>(name: T, arguments: Vec<Statement>) -> Statement {
        Statement::FunctionCall(FunctionCall {
            name: name.to_string(),
            arguments: arguments,
        })
    }
}