essential-app-utils 0.7.0

Utilities for building Essential applications
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
109
110
111
112
113
114
115
116
117
118

use std::path::Path;

use essential_debugger::Source;
use essential_server_types::{QueryStateReads, StateReadRequestType};
use essential_types::solution::Solution;

use crate::compile::{get_contracts, NamedContract};

#[cfg(test)]
mod tests;

#[derive(Clone, Debug)]
pub struct Target {
    pub contract: String,
    pub predicate: String,
    pub data_index: usize,
    pub constraint: usize,
}

pub async fn debug(
    pint_directory: &Path,
    server_address: &str,
    solution: &Solution,
    target: Target,
) {
    let contracts = get_contracts(pint_directory.to_owned(), &[&target.contract])
        .await
        .unwrap();
    let predicate = contracts
        .get_contract(&target.contract)
        .unwrap()
        .get_predicate(&target.predicate)
        .unwrap()
        .clone();
    let query = QueryStateReads::from_solution(
        solution.clone(),
        target.data_index as u16,
        &predicate,
        StateReadRequestType::Reads,
    );

    let r = essential_rest_client::EssentialClient::new(server_address.to_string())
        .unwrap()
        .query_state_reads(query)
        .await
        .unwrap();
    let state = match r {
        essential_server_types::QueryStateReadsOutput::Reads(r) => r,
        _ => unreachable!(),
    };
    let state = state.into_iter().collect();
    let contract = contracts.get_contract(&target.contract).unwrap();
    let source = get_source(contract, &target.predicate, target.constraint);

    essential_debugger::run_with_source(
        solution.clone(),
        target.data_index as u16,
        predicate,
        target.constraint,
        state,
        source,
    )
    .await
    .unwrap();
}

impl Target {
    pub fn new(contract: &str, predicate: &str, data_index: usize, constraint: usize) -> Self {
        Self {
            contract: contract.to_string(),
            predicate: predicate.to_string(),
            data_index,
            constraint,
        }
    }

    pub async fn debug(self, pint_directory: &Path, server_address: &str, solution: &Solution) {
        debug(pint_directory, server_address, solution, self).await
    }
}

fn get_source(contract: &NamedContract, predicate_name: &str, constraint_num: usize) -> Source {
    let other: String = contract
        .source
        .lines()
        .take_while(|l| !l.starts_with("predicate "))
        .fold(String::new(), |acc, l| acc + l + "\n");
    let predicate_name = predicate_name
        .trim()
        .trim_start_matches("::")
        .to_lowercase();

    let mut count = 0;
    let predicate: String = contract
        .source
        .lines()
        .skip_while(|l| {
            if l.starts_with("predicate ") {
                let Some(name) = l.trim().split(' ').nth(1) else {
                    return true;
                };
                name.trim().trim_start_matches("::").to_lowercase() != predicate_name
            } else {
                true
            }
        })
        .take_while(|l| {
            if l.starts_with("predicate ") {
                count += 1;
            }
            count < 2
        })
        .fold(String::new(), |acc, l| acc + l + "\n");

    Source::default()
        .with_other_code(other)
        .with_predicate_find_line(predicate, constraint_num)
}