writing 0.2.1

Writing, is a simple tool for code-document sync.
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

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct Writing {
    pub code_docs: Vec<CodeSource>,
    pub code_deps: Vec<CodeDep>,
    pub code_sections: Vec<CodeSection>,
    pub code_funcs: Vec<CodeFunc>
}

impl Writing {
    pub fn new() -> Writing {
        Writing {
            code_docs: vec![],
            code_deps: vec![],
            code_sections: vec![],
            code_funcs: vec![]
        }
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct CodeSource {
    pub file: String,
    pub start_line: usize,
    pub end_line: usize,
}

impl CodeSource {
    pub fn new() -> CodeSource {
        CodeSource {
            file: "".to_string(),
            start_line: 1,
            end_line: usize::MAX
        }
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct CodeDep {
    pub name: String,
    pub version: String,
    pub artifact_id: String,
    pub group_id: String,
}

impl CodeDep {
    pub fn new() -> CodeDep {
        CodeDep {
            name: "".to_string(),
            version: "".to_string(),
            artifact_id: "".to_string(),
            group_id: "".to_string()
        }
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct CodeSection {
    pub blocks: Vec<CodeBlock>
}

impl CodeSection {
    pub fn new() -> CodeSection {
        CodeSection {
            blocks: vec![]
        }
    }
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct CodeBlock {
    pub file: String,
    pub name: String,
}

impl CodeBlock {
    pub fn new() -> CodeBlock {
        CodeBlock {
            file: "".to_string(),
            name: "".to_string()
        }
    }
}

// todo: thinking in polymorphism
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct CodeFunc {
    pub file: String,
    pub funcs: Vec<String>,
}

impl CodeFunc {
    pub fn new() -> CodeFunc {
        CodeFunc {
            file: "".to_string(),
            funcs: vec![]
        }
    }
}