ocpi-tariffs-cli 0.47.0

//! Guess the version of a CDR or tariff.

use std::{fmt, path::PathBuf};

use console::style;
use ocpi_tariffs::{cdr, guess, json, tariff};

use crate::{load_object_file, load_object_from_stdin, print, Error, ObjectKind};

/// The arguments for the `guess` command.
#[derive(clap::Parser)]
pub struct Command {
    /// The arguments for the `guess` command.
    #[command(flatten)]
    args: Arguments,
}

/// The arguments for the `guess` command.
#[derive(clap::Args)]
struct Arguments {
    /// The type of OCPI object contained in the given JSON.
    #[arg(short = 't', long = "type")]
    kind: ObjectKind,

    /// A path to JSON file for the specified object.
    #[arg(short = 'f', long)]
    file: Option<PathBuf>,

    /// Check if all fields are allowed to be there according to the OCPI spec.
    #[arg(long)]
    validate: bool,
}

impl fmt::Display for ObjectKind {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ObjectKind::Cdr => f.write_str("CDR"),
            ObjectKind::Tariff => f.write_str("tariff"),
        }
    }
}

/// The outcome of running the guess command.
struct Outcome<'buf> {
    /// The kind of object given.
    object_kind: ObjectKind,

    /// The guessed version of the object given.
    version: guess::Version<ocpi_tariffs::Version, ()>,

    /// A list of fields that were not expected: The schema did not define them.
    ///
    /// This list will always be empty if the guessed `Version` is `Uncertain`.
    unexpected_fields: Option<json::UnexpectedFields<'buf>>,
}

impl Command {
    /// Run the `guess` Command.
    pub fn run(self) -> Result<(), Error> {
        let Self {
            args:
                Arguments {
                    kind: object_kind,
                    file: path,
                    validate,
                },
        } = self;

        let json = if let Some(path) = path.as_deref() {
            load_object_file(path, object_kind)?
        } else {
            load_object_from_stdin(object_kind)?
        };

        let outcome = match object_kind {
            ObjectKind::Cdr => {
                if validate {
                    let report = cdr::parse_and_report(&json)?;
                    let guess::Report {
                        unexpected_fields,
                        version,
                    } = report;

                    Outcome {
                        object_kind,
                        unexpected_fields: Some(unexpected_fields),
                        version: version.into_version(),
                    }
                } else {
                    let version = cdr::parse(&json)?;
                    Outcome {
                        object_kind,
                        unexpected_fields: None,
                        version: version.into_version(),
                    }
                }
            }
            ObjectKind::Tariff => {
                if validate {
                    let report = tariff::parse_and_report(&json)?;
                    let guess::Report {
                        unexpected_fields,
                        version,
                    } = report;

                    Outcome {
                        object_kind,
                        unexpected_fields: Some(unexpected_fields),
                        version: version.into_version(),
                    }
                } else {
                    let version = tariff::parse(&json)?;
                    Outcome {
                        object_kind,
                        unexpected_fields: None,
                        version: version.into_version(),
                    }
                }
            }
        };

        let Outcome {
            object_kind,
            unexpected_fields,
            version,
        } = outcome;

        if let Some(fields) = unexpected_fields {
            print::unexpected_fields(object_kind, &fields);
        }

        print_version(object_kind, &version);

        Ok(())
    }
}

/// Print the version to the CLI.
fn print_version(object_kind: ObjectKind, version: &guess::Version<ocpi_tariffs::Version, ()>) {
    match version {
        guess::Version::Uncertain(()) => {
            eprintln!(
                "Unable to guess the version of the given {} JSON",
                style(object_kind).green()
            );
        }
        guess::Version::Certain(version) => {
            println!("{version}");
        }
    }
}