timeblok 0.5.0

A language for event scheduling in plain text
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

use std::fs;
use chrono::NaiveDateTime;
use anyhow::{Result, anyhow};

extern crate pest;
#[macro_use]
extern crate pest_derive;
extern crate core;

mod converter;
mod environment;
pub mod importer;
pub mod ir;
mod output;
mod parser;
mod preset;
mod resolver;
mod utils;
#[cfg(test)]
mod tests;

use ir::ExactDateTime;
use parser::{BlokParser, Rule};
use pest::Parser;

pub fn tb_to_records(tb: &String) -> Result<Vec<ir::Record>> {
    if let Some(parsed) = BlokParser::parse(Rule::FILE, tb)?.next(){
        let records = parser::parse_file(parsed)?;
        Ok(records)
    }else{
        Err(anyhow!("Could not parse file"))
    }
}

pub fn records_to_resolved(records: Vec<ir::Record>, base_time: ExactDateTime) -> Result<Vec<ir::ExactRecord>> {
    let resolved = resolver::resolve(records, base_time);
    Ok(resolved)
}

pub fn resolved_to_ical(resolved: Vec<ir::ExactRecord>) -> Result<String> {
    let ical = converter::to_ical(resolved, None);
    Ok(ical)
}

pub fn resolved_to_ical_deterministic(resolved: Vec<ir::ExactRecord>, base_time: ExactDateTime) -> Result<String> {
    let ical = converter::to_ical(resolved, Some(base_time.to_chrono()?));
    Ok(ical)
}

pub fn resolved_to_csv(resolved: Vec<ir::ExactRecord>) -> Result<String> {
    let csv = converter::to_csv(resolved)?;
    Ok(csv)
}

pub fn compile(source: &str, base_time: ExactDateTime) -> Result<String> {
    let records = tb_to_records(&source.to_string())?;
    let resolved = records_to_resolved(records, base_time)?;
    let ical = resolved_to_ical(resolved)?;
    Ok(ical)
}

pub fn compile_deterministic(source: &str, base_time: ExactDateTime) -> Result<String> {
    let records = tb_to_records(&source.to_string())?;
    let resolved = records_to_resolved(records, base_time.clone())?;
    let ical = resolved_to_ical_deterministic(resolved, base_time)?;
    Ok(ical)
}