tslink 0.4.2

Creates typescript definitions based on rust 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
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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120

pub(crate) mod dts;
pub(crate) mod js;
pub(crate) mod offset;
pub(crate) mod ts;

use crate::{
    config,
    context::{Context, Target},
    error::E,
    nature::Natures,
    TS_IMPORTS,
};
pub use offset::*;
use std::{
    collections::HashSet,
    fs::{self, create_dir_all, File, OpenOptions},
    path::PathBuf,
};

pub fn serialize_name<S: AsRef<str>>(s: S) -> String {
    if s.as_ref().starts_with("r#") {
        s.as_ref().replace("r#", "")
    } else {
        s.as_ref().to_string()
    }
}

pub fn create_node_located_file(
    file_name: &str,
    dropped: &mut HashSet<PathBuf>,
) -> Result<File, E> {
    let path = config::get()?
        .node_mod_dist
        .clone()
        .ok_or(E::InvalidConfiguration(String::from(
            "No path to folder with node module. Set correct path in [tslink] of Cargo.toml; field \"node\"",
        )))?
        .join(file_name);
    if dropped.contains(&path) {
        return Ok(OpenOptions::new().append(true).open(&path)?);
    }
    if path.exists() {
        fs::remove_file(&path)?;
        let _ = dropped.insert(path.clone());
    } else if let Some(basepath) = path.parent() {
        if !basepath.exists() {
            create_dir_all(basepath)?;
        }
    } else {
        return Err(E::FileNotFound(format!(
            "Fail to get basepath from: {}",
            path.to_string_lossy()
        )));
    }
    File::create(&path)?;
    Ok(OpenOptions::new().append(true).open(&path)?)
}

pub fn create_target_file(
    context: &Context,
    target: &Target,
    dropped: &mut HashSet<PathBuf>,
) -> Result<Option<(File, PathBuf)>, E> {
    if let Some((_, path)) = context.targets.iter().find(|(t, _)| t == target) {
        if dropped.contains(path) {
            return Ok(Some((
                OpenOptions::new().append(true).open(path)?,
                path.to_owned(),
            )));
        }
        if path.exists() {
            fs::remove_file(path)?;
        } else if let Some(basepath) = path.parent() {
            if !basepath.exists() {
                create_dir_all(basepath)?;
            }
        } else {
            return Err(E::FileNotFound(format!(
                "Fail to get basepath from: {}",
                path.to_string_lossy()
            )));
        }
        let _ = dropped.insert(path.clone());
        File::create(path)?;
        Ok(Some((
            OpenOptions::new().append(true).open(path)?,
            path.to_owned(),
        )))
    } else {
        Ok(None)
    }
}

pub fn ts(natures: &Natures) -> Result<(), E> {
    let mut dropped: HashSet<PathBuf> = HashSet::new();
    for (_name, entity) in natures.iter() {
        let context = entity.get_context()?;
        if let Some((file, file_name)) = create_target_file(context, &Target::Ts, &mut dropped)? {
            let mut writer = ts::Writer::new(file, file_name)?;
            ts::write(entity, natures, &mut writer)?;
        }
    }
    TS_IMPORTS
        .write()
        .map_err(|_| E::ImportsListAccess)?
        .write()?;
    Ok(())
}

pub fn dts(natures: &Natures) -> Result<(), E> {
    let mut dropped: HashSet<PathBuf> = HashSet::new();
    for (_name, entity) in natures.iter() {
        dts::write(entity, natures, &mut dropped)?;
    }
    Ok(())
}

pub fn js(natures: &Natures) -> Result<(), E> {
    js::write(natures)
}