foreignc_template 0.1.1

Templating language for the foreignc crate
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
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

use crate::*;
use crate::py_types::*;
use std::ffi::OsStr;
use std::path::Path;
use tera::{Context, Tera};
use std::fs::write;
use foreignc_util::to_camel_case;
use serde::{Deserialize, Serialize};

#[derive(Default, Deserialize, Serialize, Debug)]
pub struct RustContext {
    pub structs: Vec<RustStructure>,
    pub funcs: Vec<RustFunction>,
    pub free_funcs: Vec<RustFreeFunction>,
}

impl RustContext {
    pub fn new() -> RustContext {
        RustContext::default()
    }

    fn create_context(&self, lib_name: Option<String>) -> TResult<Context> {
        // Check if any method or function returns a string
        let return_string = self.funcs
            .iter()
            .any(|f| 
                f.output

                    .as_ref()
                    .map_or(false, |t| t.is_string()))
                || self.structs
                    .iter()
                    .any(|s| s.ty == StructTypes::Json)
                || self.structs
                    .iter()
                    .any(|s| s.methods.iter()

                    .any(|f| f.output.as_ref().map_or(false, |t| t.is_string())));
        
        // if a string is returned check if free_string is set
        if return_string {
            let has_free_string = self.free_funcs
                .iter()
                .any(|f| &f.func.name == "free_string")
                || self.funcs
                    .iter()
                    .any(|f| &f.name == "free_string");
            
            // Throw error
            if !has_free_string {
                return Err(TemplateError::MessageErr("Returned string without methods of deletion please add a free_string function or use foreignc_derive::generate_free_methods to generate it".to_owned()))
            }
        }
        
        let mut structs = self.structs.clone();
        let abi: Vec<FunctionABI> = self.funcs
            .iter()
            .map(|a| FunctionABI::from_rust(a, &mut structs))
            .collect();
        
        // Currently we dont add the free function explicitly
        //let mut free_abi: Vec<FunctionABI> = self.free_funcs.iter().map(|a| FunctionABI::from_rust(&a.func, &mut structs)).collect();
        //abi.append(&mut free_abi);

        let mut added: Vec<StructureABI> = Vec::new();
        while !structs.is_empty() {
            let current = structs.pop().unwrap();
            if added.iter().any(|a| a.self_ty == current.self_ty) {
                continue
            }
            let converted = StructureABI::from_rust(current, &mut structs);
            added.push(converted);
        } 
        
        type Partition = (Vec<StructureABI>, Vec<StructureABI>);
        let (boxes, others): Partition = added.into_iter().partition(|s| s.ty == StructTypes::Boxed);
        let (json, pointers): Partition = others.into_iter().partition(|s| s.ty == StructTypes::Json);
        
        let mut ncon = Context::new();
        ncon.insert("abis", &abi);
        ncon.insert("boxes", &boxes);
        ncon.insert("jsons", &json);
        ncon.insert("pointers", &pointers);
        let final_name = if let Some(name) = lib_name {
            name.to_owned()
        }else {
            format!("{}Lib", to_camel_case(env!("CARGO_PKG_NAME").to_owned()))
        };
        ncon.insert("lib_name", &final_name);
        Ok(ncon)
    }

    pub fn generate_python_api<P>(&self, path: P, lib_name: Option<String>) -> TResult<()> 
    where
        P: AsRef<OsStr> + Sized
    {
        let context = self.create_context(lib_name)?;
        let content = Tera::one_off(
            &include_str!("../templates/py.jinja"), 
            &context,
            false
        )?;
        write(Path::new(&path), content)?;
        Ok(())
    }
}