jslt 0.0.6

Everyones favorite xslt but for json
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

use std::io::{BufRead, BufReader, Read, Write};

use clap::{Args, Parser};
use clio::{Input, Output};
use jslt::Jslt;

#[derive(Args, Debug)]
#[group(required = true, multiple = false)]
struct SchemaOpts {
  /// Jslt schema content
  #[clap(long, short, conflicts_with = "schema_path")]
  schema: Option<String>,

  /// Jslt schema file
  #[clap(long, short = 'f', conflicts_with = "schema")]
  schema_path: Option<Input>,
}

#[derive(Debug, Parser)]
#[command(version, about, styles = jslt::_binary::get_clap_styles())]
struct Opts {
  #[clap(flatten)]
  schema: SchemaOpts,

  /// Use instead of input
  #[clap(long, conflicts_with = "input")]
  text: Option<String>,

  /// When the input contains json values on each line
  #[clap(long, short, conflicts_with = "text")]
  multiline: bool,

  /// Input file path
  #[clap(value_parser, default_value = "-", conflicts_with = "text")]
  input: Input,

  /// Pretty print output
  #[clap(long, short)]
  pretty: bool,

  /// Output file path
  #[clap(long, short, value_parser, default_value = "-")]
  output: Output,
}

impl SchemaOpts {
  fn into_schema(self) -> std::io::Result<String> {
    match (self.schema_path, self.schema) {
      (Some(mut schema_path), None) => {
        let mut output = String::new();
        schema_path.read_to_string(&mut output)?;

        Ok(output)
      }
      (None, Some(schema)) => Ok(schema),
      _ => unreachable!(),
    }
  }
}

fn entrypoint(mut opts: Opts) -> Result<(), Box<dyn std::error::Error>> {
  let schema = opts.schema.into_schema()?;
  let jslt: Jslt = schema.parse()?;

  if opts.multiline {
    for line in BufReader::new(opts.input).lines().take_while(Result::is_ok) {
      let value = serde_json::from_str(&line.expect("line should be filtered to only success"))?;

      let value = jslt.transform_value(&value)?;

      if opts.pretty {
        writeln!(opts.output, "{}", serde_json::to_string_pretty(&value)?)?;
      } else {
        writeln!(opts.output, "{value}")?;
      }
    }
  } else {
    let value = match opts.text {
      Some(text) => serde_json::from_str(&text)?,
      None => serde_json::from_reader(opts.input)?,
    };

    let value = jslt.transform_value(&value)?;

    if opts.pretty {
      writeln!(opts.output, "{}", serde_json::to_string_pretty(&value)?)?;
    } else {
      writeln!(opts.output, "{value}")?;
    }
  }

  Ok(())
}

fn main() {
  let opts = Opts::parse();

  if let Err(err) = entrypoint(opts) {
    eprintln!("{err}");
  }
}