topcat 0.1.0

A tool for concatenating files in topological order
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

use std::env;
use std::fs::File;
use std::io::Write;
use std::path::Path;

use log::info;

use crate::config::Config;
use crate::exceptions::TopCatError;
use crate::file_dag::TCGraph;
use crate::fs::FileSystem;

/// Append a string to the end of the file content.
///
/// Trim the whitespaces at the end of the file content and append the given string if it
/// does not already end with it. Finally, add a newline character at the end of the content.
///
/// This is handy when joining sql files, where the last statement should end with a semicolon,
/// but when working on individual files, it's easy to forget to add it. But if it's not there,
/// it will cause an error when trying to execute the concatenated file.
///
/// # Arguments
///
/// * `file_content` - The original content of the file.
/// * `append_str` - The string to append to the file content.
///
/// # Returns
///
/// The new file content with the string appended.
///
/// # Example
///
/// ```rust
/// let file_content = "Hello, world!";
/// let append_str = ", goodbye!";
///
/// let new_content = append_string_to_file_content(file_content.to_string(), append_str);
///
/// assert_eq!(new_content, "Hello, world!, goodbye!\n")
/// ```
fn append_string_to_file_content(file_content: String, append_str: &str) -> String {
    let mut content = file_content.trim_end().to_string();

    if !content.ends_with(append_str) {
        content.push_str(append_str);
    }

    content.push('\n');
    content
}

trait OutputDestination {
    fn write_line(&mut self, content: &str) -> std::io::Result<()>;
    fn write_str(&mut self, content: &str) -> std::io::Result<()>;
}

struct FileOutput {
    writer: Box<dyn Write>,
}

impl FileOutput {
    fn new(file_path: &Path) -> Result<Self, TopCatError> {
        let file = File::create(file_path)?;
        Ok(Self {
            writer: Box::new(file),
        })
    }
}

impl OutputDestination for FileOutput {
    fn write_line(&mut self, content: &str) -> std::io::Result<()> {
        writeln!(self.writer, "{}", content)
    }

    fn write_str(&mut self, content: &str) -> std::io::Result<()> {
        write!(self.writer, "{}", content)
    }
}

struct ConsoleOutput;

impl OutputDestination for ConsoleOutput {
    fn write_line(&mut self, content: &str) -> std::io::Result<()> {
        println!("{}", content);
        Ok(())
    }

    fn write_str(&mut self, content: &str) -> std::io::Result<()> {
        print!("{}", content);
        Ok(())
    }
}

/// Generate output based on the given graph and configuration.
///
/// # Arguments
///
/// * `graph` - The TCGraph representing the files and their dependencies.
/// * `config` - The configuration settings.
/// * `fs` - The file system to read from and write to.
///
/// # Returns
///
/// Returns `Ok(())` if the generation is successful, otherwise returns a `TopCatError`.
pub fn generate(
    graph: TCGraph,
    config: Config,
    fs: &mut dyn FileSystem,
) -> Result<(), TopCatError> {
    info!("Generating output");

    let mut output_dest: Box<dyn OutputDestination>;
    if config.dry_run {
        info!("Dry run enabled, not writing to file");
        output_dest = Box::new(ConsoleOutput {});
    } else {
        output_dest = Box::new(FileOutput::new(&config.output)?);
    }

    let command = env::args().skip(1).collect::<Vec<_>>().join(" ");
    output_dest.write_line(&format!(
        "{0} This file was generated by topcat. To regenerate run:\n{0}\n{0} topcat {1}\n",
        config.comment_str, command
    ))?;
    let file_sep_str = config.file_separator_str.as_str();

    for file_name in graph.get_sorted_files()? {
        let contents = fs.read_to_string(&file_name)?;

        output_dest.write_line(file_sep_str)?;
        output_dest
            .write_line(format!("{} {}", config.comment_str, file_name.display()).as_str())?;
        output_dest.write_str(&append_string_to_file_content(
            contents,
            &config.file_end_str,
        ))?;
        output_dest.write_line("")?;
    }

    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_ensure_file_separator() {
        let d = append_string_to_file_content("SELECT 1 FROM table".to_string(), ";");
        assert_eq!(d, "SELECT 1 FROM table;\n");

        let d = append_string_to_file_content("SELECT 1 FROM table;".to_string(), ";");
        assert_eq!(d, "SELECT 1 FROM table;\n");

        let d = append_string_to_file_content("SELECT 1 FROM table;\n\n\n".to_string(), "\\");
        assert_eq!(d, "SELECT 1 FROM table;\n");
    }
}