univert 0.4.0

Universal file converter (library and CLI)
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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

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

use crate::{Error, Job, Result};

pub fn csv_to_json(job: &Job) -> Result<()> {
  if job.options.split {
    return split_rows(job, b',');
  }
  sv_to_json(job, b',')
}

pub fn tsv_to_json(job: &Job) -> Result<()> {
  if job.options.split {
    return split_rows(job, b'\t');
  }
  sv_to_json(job, b'\t')
}

pub fn csv_to_tsv(job: &Job) -> Result<()> {
  sv_to_sv(job.input, job.output, b',', b'\t')
}

pub fn tsv_to_csv(job: &Job) -> Result<()> {
  sv_to_sv(job.input, job.output, b'\t', b',')
}

pub fn csv_to_html(job: &Job) -> Result<()> {
  sv_to_html(job, b',')
}

pub fn tsv_to_html(job: &Job) -> Result<()> {
  sv_to_html(job, b'\t')
}

fn sv_to_json(job: &Job, delimiter: u8) -> Result<()> {
  let mut reader = csv::ReaderBuilder::new()
    .delimiter(delimiter)
    .has_headers(true)
    .from_path(job.input)?;

  let headers = reader.headers()?.clone();
  let mut file = fs::File::create(job.output)?;

  writeln!(file, "[")?;
  let mut first = true;
  for record in reader.records() {
    let record = record?;
    let mut obj = serde_json::Map::with_capacity(headers.len());
    for (header, value) in headers.iter().zip(record.iter()) {
      obj.insert(
        header.to_string(),
        serde_json::Value::String(value.to_string()),
      );
    }
    if !first {
      writeln!(file, ",")?;
    }
    first = false;
    let line = serde_json::to_string(&serde_json::Value::Object(obj))
      .map_err(|e| Error::other(format!("json serialize: {e}")))?;
    write!(file, "{line}")?;
  }
  writeln!(file)?;
  writeln!(file, "]")?;
  Ok(())
}

fn sv_to_sv(input: &Path, output: &Path, from: u8, to: u8) -> Result<()> {
  let mut reader = csv::ReaderBuilder::new()
    .delimiter(from)
    .has_headers(false)
    .from_path(input)?;
  let mut writer = csv::WriterBuilder::new().delimiter(to).from_path(output)?;

  for record in reader.records() {
    let record = record?;
    writer.write_record(&record)?;
  }
  writer.flush()?;
  Ok(())
}

fn sv_to_html(job: &Job, delimiter: u8) -> Result<()> {
  let mut reader = csv::ReaderBuilder::new()
    .delimiter(delimiter)
    .has_headers(false)
    .from_path(job.input)?;

  let mut out = String::from(
    "<!doctype html><html><head><title>csv2</title></head><body><table>",
  );
  for record in reader.records() {
    let record = record?;
    out.push_str("<tr>");
    for cell in record.iter() {
      out.push_str("<td>");
      push_html_escaped(&mut out, cell);
      out.push_str("</td>");
    }
    out.push_str("</tr>");
  }
  out.push_str("</table></body></html>");
  fs::write(job.output, out)?;
  Ok(())
}

fn push_html_escaped(out: &mut String, s: &str) {
  for c in s.chars() {
    match c {
      '&' => out.push_str("&amp;"),
      '<' => out.push_str("&lt;"),
      '>' => out.push_str("&gt;"),
      '"' => out.push_str("&quot;"),
      '\'' => out.push_str("&#39;"),
      c => out.push(c),
    }
  }
}

fn split_rows(job: &Job, delimiter: u8) -> Result<()> {
  // Matches javascript/src/modules/sv2json.js --split semantics:
  // create a directory named after the output's stem and write 0.json, 1.json, ...
  let dir = job
    .output
    .file_stem()
    .map(|s| job.output.with_file_name(s))
    .ok_or_else(|| Error::other("output has no file stem"))?;

  fs::create_dir_all(&dir)?;

  let mut reader = csv::ReaderBuilder::new()
    .delimiter(delimiter)
    .has_headers(true)
    .from_path(job.input)?;
  let headers = reader.headers()?.clone();

  for (i, record) in reader.records().enumerate() {
    let record = record?;
    let mut obj = serde_json::Map::with_capacity(headers.len());
    for (header, value) in headers.iter().zip(record.iter()) {
      obj.insert(
        header.to_string(),
        serde_json::Value::String(value.to_string()),
      );
    }
    let path = dir.join(format!("{i}.json"));
    let json = serde_json::to_string_pretty(&serde_json::Value::Object(obj))
      .map_err(|e| Error::other(format!("json serialize: {e}")))?;
    fs::write(path, json)?;
  }
  Ok(())
}