mdsplode 0.4.1

A CLI tool for exploding and serialising Markdown files (metadata, AST, rendered parts, and rendered whole)
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

use std::io::prelude::*;
use std::{fs, io};

use anyhow::{anyhow, Error, Result};
use markdown::mdast::Node;

use crate::cli::opts::Opts;
use crate::json::{jq, print};
use crate::md::converter;

use super::parser;
use super::types::CompoundNode;

pub fn process(in_file: String, out_file: String, cli: Opts) -> Result<(), Error> {
    log::info!("Processing file: {}", in_file);
    let mut json: String;
    // --skip-process
    if cli.skip_process {
        json = read_to_string(in_file)?;
    } else {
        // --input - already taken care of in validation
        let tree = read_to_parsed(in_file)?;
        json = tree.to_json();
    }
    // --query
    if let Some(ref query) = cli.query {
        if let Ok(result) = jq::query(json.clone(), query.to_string()) {
            json = result;
        };
    };
    // --pretty
    if cli.pretty {
        json = print::pretty(json.clone())?
    }
    // --output
    if cli.is_stdout() {
        let stdout = io::stdout();
        let mut stdout = stdout.lock();
        match writeln!(stdout, "{}", json.clone()) {
            Err(e) => Err(anyhow!("{:}", e)),
            _ => Ok(()),
        }
    } else {
        let mut out = fs::File::create(out_file)?;
        match write!(out, "{}", json) {
            Err(e) => Err(anyhow!("{:}", e)),
            _ => Ok(()),
        }
    }
}

pub fn read_to_string(filename: String) -> Result<String, Error> {
    match fs::read_to_string(filename.as_str()) {
        Err(e) => Err(anyhow!("{:}", e)),
        Ok(data) => Ok(data),
    }
}

pub fn read_to_mdast(filename: String) -> Result<Node, Error> {
    let md = read_to_string(filename)?;
    Ok(converter::string_to_mdast(md))
}

pub fn read_to_parsed(filename: String) -> Result<CompoundNode, Error> {
    let node = read_to_mdast(filename)?;
    Ok(parser::parse_node(&node))
}