backyard-generator 0.1.10

Convert AST node back to PHP code.
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

use backyard_nodes::{ cast_node, Node, NodeType, NodeWrapper };

use crate::generator::{ Builder, EndMode, Generator, GeneratorArgument };

use super::{
  consts::ConstGenerator,
  identifier::IdentifierGenerator,
  method::MethodGenerator,
  types::TypeGenerator,
};

pub struct EnumGenerator;

impl EnumGenerator {
  pub fn generate<'arena>(
    generator: &mut Generator<'arena, '_>,
    builder: &mut Builder,
    node: &Node<'arena>
  ) {
    let node = cast_node!(Enum, &node.wrapper);
    builder.push("enum ");
    IdentifierGenerator::generate(generator, builder, &node.name);
    if let Some(n) = &node.enum_type {
      builder.push(": ");
      TypeGenerator::generate(generator, builder, n);
    }
    if let Some(n) = &node.implements {
      builder.push(" implements ");
      IdentifierGenerator::generate(generator, builder, n);
    }
    let mut body = generator.generate_nodes_new(
      &node.body,
      &mut GeneratorArgument::new(
        EndMode::SemicolonDynamic,
        &[
          (NodeType::ConstProperty, ConstGenerator::generate_property),
          (NodeType::Method, MethodGenerator::generate),
          (NodeType::EnumItem, Self::generate_item),
        ]
      )
    );
    builder.push(" {");
    body.indent();
    builder.extend(body);
    builder.new_line();
    builder.push("}");
  }

  pub fn generate_item<'arena>(
    generator: &mut Generator<'arena, '_>,
    builder: &mut Builder,
    node: &Node<'arena>
  ) {
    let node = cast_node!(EnumItem, &node.wrapper);
    builder.push("case ");
    generator.generate_node(builder, &node.value, &mut GeneratorArgument::default());
  }
}