chartr 0.1.1

A library and cli for working with charts
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
102
103
104
105
106
107
108

use chartr_core::{event, load, render};
use clap::{Args, Parser, Subcommand};
use std::path::PathBuf;

#[derive(Parser, Debug)]
#[command(version, about, long_about = None)]
struct Cli {
    /// What mode to run the program in
    #[command(subcommand)]
    mode: Command,

    path: PathBuf,
}

#[derive(Clone, Debug, Subcommand)]
enum Command {
    Create(CreateArgs),
    AddActor(AddActorArgs),
    AddEvent(AddEventArgs),
}

#[derive(Args, Clone, Debug)]
struct CreateArgs {
    #[arg(long)]
    heading: Option<String>,
}

#[derive(Args, Clone, Debug)]
struct AddActorArgs {
    identity: String,

    #[arg(short, long, allow_hyphen_values = true)]
    tooltip: Option<String>,
}

#[derive(Args, Clone, Debug)]
struct AddEventArgs {
    actor: String,
    start: i64,
    duration: Option<u32>,

    #[arg(short, long, default_value = "false")]
    endless: bool,

    #[arg(short, long)]
    color: Option<String>,

    #[arg(short, long, allow_hyphen_values = true)]
    tooltip: Option<String>,
}

fn main() {
    let cli = Cli::parse();

    match cli.mode {
        Command::Create(args) => {
            let mut builder = render::RendererBuilder::default();

            if let Some(heading) = args.heading {
                builder = builder.heading(heading)
            }

            let renderer = builder.build();
            let store = event::EventStore::default();
            renderer.render(cli.path, store).unwrap();
        }
        Command::AddActor(args) => {
            let (r, mut events) = load(&cli.path).unwrap();
            events
                .register_actor(event::Actor {
                    identity: args.identity,
                    tooltip: args.tooltip
                })
                .unwrap();
            r.render(cli.path, events).unwrap();
        }
        Command::AddEvent(args) => {
            let (r, mut events) = load(&cli.path).unwrap();

            let kind = match args.duration {
                Some(duration) => event::EventKind::Span(args.start, Some(duration)),
                None => {
                    if args.endless {
                        event::EventKind::Span(args.start, None)
                    } else {
                        event::EventKind::Instant(args.start)
                    }
                }
            };

            let mut fields = std::collections::BTreeMap::default();

            if let Some(color) = args.color {
                fields.insert("fill".into(), color);
            }

            let e = event::Event {
                fields,
                value: "".into(),
                kind,
                tooltip: args.tooltip
            };

            events.add_event(&args.actor, e).unwrap();
            r.render(cli.path, events).unwrap();
        }
    }
}