export struct ChangeData {
    hash: string,
    // TODO display all authors
    // authors: [string],
    author: string,
    timestamp: string,
    message: string,
}
component ChangeEntry {
    in-out property <string> hash;
    in-out property <string> author;
    in-out property <string> timestamp;
    in-out property <string> message;
    VerticalBox {
        spacing: 0;
        Text {
            text: "hash \{root.hash}";
        }
        Text {
            text: "author \{root.author}";
        }

        Text {
            text: "timestamp \{root.timestamp}";
        }
        HorizontalBox {
            alignment: start;
            spacing: 0;
            padding: 5px;
            Rectangle {
                width: 10px;
                visible: false;
            }
            Text {
                text: "\{root.message}";
            }
        }
    }
}

    in-out property <string> changes_log: "";

    in-out property <[ChangeData]> changes_log: [];

                    Text {
                        text: "\{root.changes_log}";

                    for change in root.changes_log: ChangeEntry {
                        hash: change.hash;
                        author: change.author;
                        timestamp: change.timestamp;
                        message: change.message;

use slint::SharedString;

use slint::{ModelRc, SharedString};

            ui.set_changes_log(SharedString::from(&log));

            let log_strs: Vec<ChangeData> = log
                .into_iter()
                .map(|change| ChangeData {
                    hash: change.hash.into(),
                    author: change
                        .authors
                        .first()
                        .unwrap_or(&String::new())
                        .clone()
                        .into(),
                    timestamp: change.timestamp.into(),
                    message: change.message.into(),
                })
                .collect();
            ui.set_changes_log((&log_strs[..]).into());

pub fn log(exe: &std::path::Path, repo: &std::path::Path) -> Result<String, Error> {

pub fn log(exe: &std::path::Path, repo: &std::path::Path) -> Result<Vec<ChangelogEntry>, Error> {

        .arg(repo);

        .arg(repo)
        .arg("--output-format")
        .arg("json");

    Ok(String::from_utf8(output.stdout)?)

    Ok(serde_json::from_slice(&output.stdout)?)

}
#[derive(serde::Serialize, serde::Deserialize, Debug)]
pub struct ChangelogEntry {
    pub(crate) hash: String,
    pub(crate) authors: Vec<String>,
    pub(crate) timestamp: String,
    pub(crate) message: String,

serde = { version = "1.0.210", features = ["derive"] }
serde_json = "1.0.128"

 "serde",
 "serde_json",