Struct Class

pub struct Class {
    pub docstring: Option<Comment>,
    pub name: String,
    pub block: Block,
    pub inherit_from: Option<String>,
}

Fields

docstring: Option<Comment>

name: String

block: Block

inherit_from: Option<String>

Implementations

impl Class

pub fn new<T: Display>(name: T, parent: &Block) -> Class

Examples found in repository

examples/classes.rs (line 7)

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::variable("self.name"), Statement::variable("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 = Statement::function_call(
      "print",
      vec![
        Statement::unnamed_variable("Hello"),
        Statement::variable("self.name"),
        Statement::unnamed_variable("!"),
      ]);
    hello.add_statement(print);
    class.add_statement(Statement::Function(hello));
    program.add_statement(Statement::Class(class));
    program.add_statement(
        Statement::Assignment(Assignment::new(
            Argument::variable("g"),
            Statement::function_call(
                "Greeter",
                vec![
                    Statement::KeywordArgument(KeywordArgument::new("name", "\"Chris\""))
                ]
            )
    )));
    let function_call = Statement::function_call(
      "g.hello",
      vec![]);
    program.add_statement(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);
}

pub fn inherit_from<T: Display>(&mut self, inherit: T)

pub fn add_statement(&mut self, statement: Statement)

Examples found in repository

examples/classes.rs (line 20)

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::variable("self.name"), Statement::variable("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 = Statement::function_call(
      "print",
      vec![
        Statement::unnamed_variable("Hello"),
        Statement::variable("self.name"),
        Statement::unnamed_variable("!"),
      ]);
    hello.add_statement(print);
    class.add_statement(Statement::Function(hello));
    program.add_statement(Statement::Class(class));
    program.add_statement(
        Statement::Assignment(Assignment::new(
            Argument::variable("g"),
            Statement::function_call(
                "Greeter",
                vec![
                    Statement::KeywordArgument(KeywordArgument::new("name", "\"Chris\""))
                ]
            )
    )));
    let function_call = Statement::function_call(
      "g.hello",
      vec![]);
    program.add_statement(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);
}

pub fn add_docstring<T: Display>(&mut self, doc: T)

Examples found in repository

examples/classes.rs (line 8)

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::variable("self.name"), Statement::variable("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 = Statement::function_call(
      "print",
      vec![
        Statement::unnamed_variable("Hello"),
        Statement::variable("self.name"),
        Statement::unnamed_variable("!"),
      ]);
    hello.add_statement(print);
    class.add_statement(Statement::Function(hello));
    program.add_statement(Statement::Class(class));
    program.add_statement(
        Statement::Assignment(Assignment::new(
            Argument::variable("g"),
            Statement::function_call(
                "Greeter",
                vec![
                    Statement::KeywordArgument(KeywordArgument::new("name", "\"Chris\""))
                ]
            )
    )));
    let function_call = Statement::function_call(
      "g.hello",
      vec![]);
    program.add_statement(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);
}

Trait Implementations

impl Clone for Class

fn clone(&self) -> Class

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Class

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Class

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.