m-lamonaca/json-to-env
1
0
Fork 0
mirror of https://github.com/m-lamonaca/json-to-env.git synced 2025-04-05 10:26:40 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

lock stdout for faster writes

Browse source
This commit is contained in:
Marcello 2024-03-09 11:28:28 +01:00
parent c42a606930
commit cfa0b5c8a2
Signed by: m-lamonaca
SSH key fingerprint: SHA256:8db8uii6Gweq7TbKixFBioW2T8CbgtyFETyYL3cr3zk
1 changed files with 220 additions and 221 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

441
src/main.rs
View file

@ -1,221 +1,220 @@
use std::{ use std::{
fmt::Display, fmt::Display,
fs::File, fs::File,
io::{BufRead, BufReader, BufWriter, Read, Write}, io::{BufRead, BufReader, BufWriter, Read, Write},
}; };
use anyhow::{Context, Result}; use anyhow::{Context, Result};
use clap::Parser; use clap::Parser;
use serde_json::Value; use serde_json::Value;
fn main() -> Result<()> { fn main() -> Result<()> {
let args = Args::parse(); let args = Args::parse();
let mut reader: Box<dyn BufRead> = match args.input { let mut reader: Box<dyn BufRead> = match args.input {
None => Box::new(std::io::stdin().lock()), None => Box::new(std::io::stdin().lock()),
Some(ref filename) => { Some(ref filename) => {
let file = File::open(filename) let file = File::open(filename)
.with_context(|| format!("Could not open file `{filename}`"))?; .with_context(|| format!("Could not open file `{filename}`"))?;
Box::new(BufReader::new(file)) Box::new(BufReader::new(file))
} }
}; };
let mut buffer = String::new(); let mut buffer = String::new();
let input = args.input.unwrap_or("STDIN".to_string()); let input = args.input.unwrap_or("STDIN".to_string());
reader reader
.read_to_string(&mut buffer) .read_to_string(&mut buffer)
.with_context(|| format!("Could not read `{input}`"))?; .with_context(|| format!("Could not read `{input}`"))?;
let json: Value = serde_json::from_str(&buffer) let json: Value = serde_json::from_str(&buffer)
.with_context(|| format!("`{input}` does not contain valid JSON"))?; .with_context(|| format!("`{input}` does not contain valid JSON"))?;
let mut vars: Vec<EnvVar> = vec![]; let mut vars: Vec<EnvVar> = vec![];
JsonParser::parse(&mut vars, "", &json, &args.separator); JsonParser::parse(&mut vars, "", &json, &args.separator);
let environ = vars let environ = vars
.iter() .iter()
.map(ToString::to_string) .map(ToString::to_string)
.collect::<Vec<String>>() .collect::<Vec<String>>()
.join("\n"); .join("\n");
let mut writer: Box<dyn Write> = match args.output { let mut writer: Box<dyn Write> = match args.output {
Some(ref filename) => { None => Box::new(std::io::stdout().lock()),
let file = File::create(filename) Some(ref filename) => {
.with_context(|| format!("Could not open file `{filename}`"))?; let file = File::create(filename)
.with_context(|| format!("Could not open file `{filename}`"))?;
Box::new(BufWriter::new(file))
} Box::new(BufWriter::new(file))
None => Box::new(std::io::stdout()), }
}; };
let output = args.output.unwrap_or("STDOUT".to_string()); let output = args.output.unwrap_or("STDOUT".to_string());
writer writer
.write_all(environ.as_bytes()) .write_all(environ.as_bytes())
.with_context(|| format!("Could not write to `{output}`"))?; .with_context(|| format!("Could not write to `{output}`"))?;
Ok(()) Ok(())
} }
#[derive(Debug, Parser)] #[derive(Debug, Parser)]
#[command(name = "json2env", version, about)] #[command(name = "json2env", version, about)]
struct Args { struct Args {
/// Input file, defaults to STDIN if not specified /// Input file, defaults to STDIN if not specified
#[arg(short, long, value_name = "FILE")] #[arg(short, long, value_name = "FILE")]
input: Option<String>, input: Option<String>,
/// Output file, defaults to STDOUT if not specified /// Output file, defaults to STDOUT if not specified
#[arg(short, long, value_name = "FILE")] #[arg(short, long, value_name = "FILE")]
output: Option<String>, output: Option<String>,
/// Separator for nested keys /// Separator for nested keys
#[arg(short, long, value_name = "STRING", default_value = "__")] #[arg(short, long, value_name = "STRING", default_value = "__")]
separator: String, separator: String,
} }
struct JsonParser; struct JsonParser;
impl JsonParser { impl JsonParser {
fn parse(lines: &mut Vec<EnvVar>, key: &str, value: &Value, separator: &str) { fn parse(lines: &mut Vec<EnvVar>, key: &str, value: &Value, separator: &str) {
match value { match value {
Value::Array(array) => { Value::Array(array) => {
for (index, item) in array.iter().enumerate() { for (index, item) in array.iter().enumerate() {
let key = Self::build_key(key, index.to_string().as_str(), separator); let key = Self::build_key(key, index.to_string().as_str(), separator);
Self::parse(lines, &key, item, separator) Self::parse(lines, &key, item, separator)
} }
} }
Value::Object(object) => { Value::Object(object) => {
for (name, value) in object { for (name, value) in object {
let key = Self::build_key(key, name.as_str(), separator); let key = Self::build_key(key, name.as_str(), separator);
Self::parse(lines, &key, value, separator) Self::parse(lines, &key, value, separator)
} }
} }
_ => lines.push(EnvVar(key.trim().to_owned(), value.clone())), _ => lines.push(EnvVar(key.trim().to_owned(), value.clone())),
} }
} }
fn build_key(prefix: &str, key: &str, separator: &str) -> String { fn build_key(prefix: &str, key: &str, separator: &str) -> String {
match prefix.is_empty() { match prefix.is_empty() {
true => key.to_string(), true => key.to_string(),
false => format!("{prefix}{separator}{key}"), false => format!("{prefix}{separator}{key}"),
} }
} }
} }
struct EnvVar(String, Value); struct EnvVar(String, Value);
impl Display for EnvVar {
impl Display for EnvVar { fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
fn fmt(&self, fmt: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self.1 {
match self.1 { Value::Null => write!(fmt, "{key}=null", key = self.0),
Value::Null => write!(fmt, "{key}=null", key = self.0), Value::Bool(bool) => write!(fmt, "{key}={bool}", key = self.0),
Value::Bool(bool) => write!(fmt, "{key}={bool}", key = self.0), Value::Number(ref number) => write!(fmt, "{key}={number}", key = self.0),
Value::Number(ref number) => write!(fmt, "{key}={number}", key = self.0), Value::String(ref string) => write!(
Value::String(ref string) => write!( fmt,
fmt, r#"{key}="{value}""#,
r#"{key}="{value}""#, key = self.0,
key = self.0, value = string.replace('"', r#"\""#)
value = string.replace('"', r#"\""#) ),
), _ => write!(fmt, ""),
_ => write!(fmt, ""), }
} }
} }
}
#[cfg(test)]
#[cfg(test)] mod tests {
mod tests { use serde_json::json;
use serde_json::json;
use crate::{EnvVar, JsonParser};
use crate::{EnvVar, JsonParser};
const KEY: &str = r#""key""#;
const KEY: &str = r#""key""#;
#[test]
#[test] fn build_key_should_leave_key_unchanged_when_prefix_is_empty() {
fn build_key_should_leave_key_unchanged_when_prefix_is_empty() { // ARRANGE
// ARRANGE let separator = "";
let separator = ""; let input = KEY.to_owned();
let input = KEY.to_owned(); let expected = KEY;
let expected = KEY;
// ACT
// ACT let result = JsonParser::build_key("", &input, separator);
let result = JsonParser::build_key("", &input, separator);
// ASSERT
// ASSERT assert_eq!(result, expected);
assert_eq!(result, expected); }
}
#[test]
#[test] fn build_key_should_leave_prepend_prefix_with_separator() {
fn build_key_should_leave_prepend_prefix_with_separator() { // ARRANGE
// ARRANGE let separator = "_";
let separator = "_"; let input = KEY.to_owned();
let input = KEY.to_owned(); let expected = format!("prefix{separator}{KEY}");
let expected = format!("prefix{separator}{KEY}");
// ACT
// ACT let actual = JsonParser::build_key("prefix", &input, separator);
let actual = JsonParser::build_key("prefix", &input, separator);
// ASSERT
// ASSERT assert_eq!(actual, expected);
assert_eq!(actual, expected); }
}
#[test]
#[test] fn bool_env_var_should_be_formatted_correctly() {
fn bool_env_var_should_be_formatted_correctly() { // ARRANGE
// ARRANGE let input = EnvVar(KEY.to_owned(), json!(true));
let input = EnvVar(KEY.to_owned(), json!(true));
// ACT
// ACT let result = input.to_string();
let result = input.to_string();
// ASSERT
// ASSERT assert_eq!(result, r#""key"=true"#)
assert_eq!(result, r#""key"=true"#) }
}
#[test]
#[test] fn numeric_env_var_should_be_formatted_correctly() {
fn numeric_env_var_should_be_formatted_correctly() { // ARRANGE
// ARRANGE let input = EnvVar(KEY.to_owned(), json!(1.0));
let input = EnvVar(KEY.to_owned(), json!(1.0));
// ACT
// ACT let result = input.to_string();
let result = input.to_string();
// ASSERT
// ASSERT assert_eq!(result, r#""key"=1.0"#)
assert_eq!(result, r#""key"=1.0"#) }
}
#[test]
#[test] fn string_env_var_should_be_formatted_correctly() {
fn string_env_var_should_be_formatted_correctly() { // ARRANGE
// ARRANGE let input = EnvVar(KEY.to_owned(), json!("hello"));
let input = EnvVar(KEY.to_owned(), json!("hello"));
// ACT
// ACT let result = input.to_string();
let result = input.to_string();
// ASSERT
// ASSERT assert_eq!(result, r#""key"="hello""#)
assert_eq!(result, r#""key"="hello""#) }
}
#[test]
#[test] fn array_env_var_should_be_formatted_correctly() {
fn array_env_var_should_be_formatted_correctly() { // ARRANGE
// ARRANGE let input = EnvVar(KEY.to_owned(), json!([1, 2]));
let input = EnvVar(KEY.to_owned(), json!([1, 2]));
// ACT
// ACT let result = input.to_string();
let result = input.to_string();
// ASSERT
// ASSERT assert_eq!(result, "")
assert_eq!(result, "") }
}
#[test]
#[test] fn object_env_var_should_be_formatted_correctly() {
fn object_env_var_should_be_formatted_correctly() { // ARRANGE
// ARRANGE let input = EnvVar(KEY.to_owned(), json!({ "key": "value" }));
let input = EnvVar(KEY.to_owned(), json!({ "key": "value" }));
// ACT
// ACT let result = input.to_string();
let result = input.to_string();
// ASSERT
// ASSERT assert_eq!(result, "")
assert_eq!(result, "") }
} }
}