Struct JsonEdit

pub struct JsonEdit {
    pub json: String,
    pub program: String,
    pub pretty_output: bool,
}

The processor configuration.

Fields

json: String

The JSON string that will be parsed by the program value.

program: String

The program to run against the provided json string.

A program can either filter the JSON down to a subset of data, or can mutate the data before returning a value.

To learn about the supported syntax, see the jq documentation:

https://stedolan.github.io/jq/manual/v1.6/

pretty_output: bool

“Pretty print” the JSON output.

If set to false, the JSON will be printed in a compact format, without any indentation, spacing or newlines.

Trait Implementations

impl Clone for JsonEdit

fn clone(&self) -> JsonEdit

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for JsonEdit

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for JsonEdit

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for JsonEdit

fn eq(&self, other: &JsonEdit) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Processor<'a> for JsonEdit

fn validate(&self) -> Result<(), Self::Error>

Validate that the provided program syntax is valid.

Errors

If the program contains invalid syntax, the Error::Json error variant is returned.

fn run(&self, _context: &Context) -> Result<Option<Self::Output>, Self::Error>

Run the provided program against the json data.

Output

If the final output is a string, the surrounding JSON quotes are removed. This makes it easier to show raw strings in the UI, without having to use the regex processor to remove extra quotes.

This output:

"world"

Becomes this:

world

If pretty_output is set, any JSON object or array is pretty printed, by including newlines, indentation and spacing around the key/value pairs.

This output:

{"hello":"world"}

Becomes this:

{
  "hello": "world"
}

When unwrapping arrays in the program, each line is processed according to the above rules.

So this output:

[{"hello":"world"},"hello",2]

Becomes this:

{"hello":"world"}
hello
2

When using the program .[].

Errors

This method returns the Error::Json error variant if the provided json input or the program has invalid syntax.

The Error::Serde error variant is returned if the processor failed to serialize or deserialize the input/output JSON.

const NAME: &'static str = "JSON Edit"

The human-formatted name of the processor, used to visually identify this processor amongst others.

type Error = Error

If a processor fails its intended purpose, the returned error is turned into a string, and shown in the automaat-web-client application.

type Output = String

The processor can return any (successful) output it wants, as long as that type implements the std::fmt::Display trait.

impl Serialize for JsonEdit

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for JsonEdit

impl StructuralPartialEq for JsonEdit