rustex 0.1.0

A library to make simple auto-generated LaTeX files in Rust.
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
121
122
123
124
125
126
127
128
129
130
131
132
133

use super::def_syntax::*;
use crate::components::document::*;
use std::io::{Write, Error};
use regex::*;


const BOLD_REGEX: &str = r"\*{2}(?P<text>[^\*]+?)\*{2}";
const ITALIC_REGEX: &str = r"_(?P<text>[^_]+?)_";
const COLOR_REGEX: &str = r"#(?P<color>[^{} ]+)\{(?P<text>[^{}]+)\}";

pub fn into_braces(string: &String) -> String {
    let mut str_with_braces: String = String::from("{");
    str_with_braces = format!("{}{}", str_with_braces, string);
    format!("{}{}", str_with_braces, "}")
}

pub fn into_brackets(string: &String) -> String {
    let mut str_with_brackets: String = String::from("[");
    str_with_brackets = format!("{}{}", str_with_brackets, string);
    format!("{}{}", str_with_brackets, "]")
}

pub fn into_label(label_name: &String) -> String {
    format!("{}{}", DEF_LABEL, into_braces(label_name))
}

fn into_bold(string: &String) -> String {
    format!("{}{}", DEF_BOLD, into_braces(string))
}

fn into_italic(string: &String) -> String {
    format!("{}{}", DEF_ITALIC, into_braces(string) )
}

fn into_color(string: &String, color: &String) -> String {
    let formatted_string = format!("{}{}{}", DEF_COLOR, into_braces(color), into_braces(string));
    into_braces(&formatted_string)
}

pub fn indent_line(doc: &Document, num_tabs: &usize) -> Result<(), Error> {
    let tabs_str: String = "\t".repeat(*num_tabs);
    write!(doc.get_file(), "{}", tabs_str)
}

pub fn write_indented_line(doc: &Document, num_tabs: &usize, text: &str) -> Result<(), Error> {
    indent_line(&doc, num_tabs)?;
    writeln!(doc.get_file(), "{}", text)
}

enum FormatType {
    Bold,
    Italic,
    Color
}

impl FormatType {
    fn handle_formatting(&self, text: &String, color: Option<&String>) -> String {
        match self {
            FormatType::Bold => into_bold(text),
            FormatType::Italic => into_italic(text),
            FormatType::Color => into_color(text, color.unwrap())
        }
    }
}

pub fn format_text(text: String) -> String {
    handle_color(handle_italic(handle_bold(text)))
}

fn handle_bold(text: String) -> String {
    let bold_regex: Result<Regex, regex::Error> = Regex::new(BOLD_REGEX);

    match bold_regex {
        Ok(regex) => replace_matches(text, regex, FormatType::Bold),

        Err(error) => {
            println!("Bold regex error: {}", error);
            text
        }
    }
}

fn handle_italic(text: String) -> String {
    let italic_regex: Result<Regex, regex::Error> = Regex::new(ITALIC_REGEX);

    match italic_regex {
        Ok(regex) => replace_matches(text, regex, FormatType::Italic),

        Err(error) => {
            println!("Italic regex error: {}", error);
            text
        }
    }
}

fn handle_color(text: String) -> String {
    let color_regex: Result<Regex, regex::Error> = Regex::new(COLOR_REGEX);

    match color_regex {
        Ok(regex) => replace_matches(text, regex, FormatType::Color),

        Err(error) => {
            println!("Color regex error: {}", error);
            text
        }
    }
}

fn replace_matches(text: String, regex: Regex, format_type: FormatType) -> String {
    let captures = regex.captures_iter(&text);
    let mut new_text = text.clone();

    for capture in captures {
        match format_type {
            FormatType::Color => {
                new_text = regex
                    .replace(&new_text, format_type.handle_formatting(
                        &capture["text"].to_string(),
                        Some(&capture["color"].to_string())
                    ))
                    .into_owned();
            }

            _ => {
                new_text = regex
                    .replace(&new_text, format_type.handle_formatting(&capture["text"].to_string(), None))
                    .into_owned();
            }
        }
    }

    new_text
}