factorio-exporter 0.3.0

A library to export prototype definitions from Factorio (http://www.factorio.com)
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
78
79
80
81
82

use crate::api::{is_number, HasAttributes};
use crate::api::{Api, Attribute, Type};

use super::script_builder::ScriptBuilder;

pub struct ScriptGenerator<'a> {
    api: &'a Api,
    script: ScriptBuilder,
}

impl<'a> ScriptGenerator<'a> {
    pub fn new(api: &'a Api) -> ScriptGenerator<'a> {
        let script = ScriptBuilder::new();
        ScriptGenerator { api, script }
    }

    pub fn generate(mut self, object: &str, attributes: Vec<&Attribute>) -> String {
        self.export_attrs(object, attributes, 0);
        self.script.build()
    }

    fn export_attrs(&mut self, object: &str, attrs: Vec<&Attribute>, depth: usize) {
        for attr in attrs {
            // TODO: Reading fails, but the documentation only says so in prose.
            if attr.name == "order_in_recipe" || attr.name == "subgroups" {
                continue;
            }

            use self::Type::*;
            match &attr.r#type {
                String => {
                    self.script.export_string_attr(object, &attr.name);
                }

                r#type if is_number(r#type) => {
                    self.script.export_number_attr(object, &attr.name);
                }

                Boolean => {
                    self.script.export_bool_attr(object, &attr.name);
                }

                Array { value } => {
                    let element = self.script.begin_array(object, &attr.name);
                    self.export_value(&element, value, depth);
                    self.script.end_array();
                }

                LuaCustomTable { value, .. } | Dictionary { value, .. } => {
                    let table = format!("{object}.{}", attr.name);
                    let element = self.script.begin_table(&table, &attr.name);
                    self.export_value(&element, value, depth);
                    self.script.end_table();
                }

                _ => {}
            }
        }
    }

    fn export_value(&mut self, object: &str, ty: &Type, depth: usize) {
        let depth = depth + 1;
        match ty {
            Type::NamedType { name } => {
                if let Some(class) = self.api.classes.get(name) {
                    let mut attrs = class.attributes();
                    // TODO: Cut infinite recursion in a more principled way
                    if depth > 1 {
                        attrs.retain(|a| a.name == "name")
                    }
                    self.export_attrs(object, attrs, depth);
                }

                if let Some(concept) = self.api.concepts.get(name) {
                    self.export_attrs(object, concept.attributes(), depth);
                }
            }
            Type::Boolean => self.script.export_bool_value(object),
            _ => (),
        };
    }
}