pythonic 0.2.4

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
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

extern crate pythonic;

use pythonic::{Argument, Assignment, Block, Class, Function, FunctionCall, KeywordArgument, Statement};

fn main() {
    let mut program = Block::new();
    let mut class = Class::new("Greeter", &program);
    class.add_docstring("Greeter is a class to say Hello!");
    let arguments = vec![
      Argument::new("self", None, None, None),
      Argument::new("name", Some("\"World\""), Some("str"), Some("The name to greet")),
    ];
    let mut init = Function::new("__init__", arguments, &class.block);
    init.add_docstring("Set up name variable for the Greeter");
    init.add_statement(
      Statement::Assignment(
        Assignment::new(
          Argument::input("self.name"), Statement::Argument(Argument::input("name")))));
    class.add_statement(Statement::Function(init));
    let arguments = vec![
      Argument::new("self", None, None, None),
    ];
    let mut hello = Function::new("hello", arguments, &class.block);
    hello.add_docstring("Say hello to self.name");
    let print = FunctionCall::new(
      "print",
      vec![
        Statement::Argument(Argument::bare("Hello")),
        Statement::Argument(Argument::input("self.name")),
        Statement::Argument(Argument::bare("!")),
      ]);
    hello.add_statement(Statement::FunctionCall(print));
    class.add_statement(Statement::Function(hello));
    program.add_statement(Statement::Class(class));
    program.add_statement(
        Statement::Assignment(Assignment::new(
        Argument::input("g"),
        Statement::FunctionCall(FunctionCall::new(
            "Greeter",
            vec![
                Statement::KeywordArgument(KeywordArgument::new("name", "\"Chris\""))
            ]
        ))
    )));
    let function_call = FunctionCall::new(
      "g.hello",
      vec![]);
    program.add_statement(Statement::FunctionCall(function_call));
    let expected = r#"class Greeter:
    """
    Greeter is a class to say Hello!
    """

    def __init__(self, name="World"):
        """
        Set up name variable for the Greeter

        :param name: str The name to greet
        """
        self.name = name

    def hello(self):
        """
        Say hello to self.name
        """
        print("Hello", self.name, "!")


g = Greeter(name="Chris")
g.hello()
"#;
    let actual = format!("{}", program);

    assert_eq!(expected, actual);

    println!("{}", actual);
}