txtx-core 0.4.10

Primitives for parsing, analyzing and executing Txtx runbooks
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

use txtx_addon_kit::types::AuthorizationContext;
use txtx_addon_kit::{
    define_function, indoc,
    types::{
        diagnostics::Diagnostic,
        functions::{FunctionImplementation, FunctionSpecification},
        types::{Type, Value},
    },
};

lazy_static! {
    pub static ref LIST_FUNCTIONS: Vec<FunctionSpecification> = vec![define_function! {
        Index => {
            name: "index",
            documentation: "`index` gets the entry from a list at the specified index.",
            example: indoc!{r#"
            output "entry" { 
                value = index(['a', 'b', 'c'], 1)
            }
            > entry: b
          "#},
            inputs: [
                list: {
                    documentation: "The list to retrieve an entry from.",
                    typing: vec![Type::array(Type::string()), Type::array(Type::integer()), Type::array(Type::buffer())] // todo: needs to be any
                },
                index: {
                    documentation: "The index of the entry to retrieve.",
                    typing: vec![Type::integer()]
                }
            ],
            output: {
                documentation: "The entry from list at the specified index",
                typing: Type::string() // todo: the result can be any type, but our types don't have an any
            },
        }
    },];
}

pub struct Index;
impl FunctionImplementation for Index {
    fn check_instantiability(
        _fn_spec: &FunctionSpecification,
        _auth_ctx: &AuthorizationContext,
        _args: &Vec<Type>,
    ) -> Result<Type, Diagnostic> {
        unimplemented!()
    }

    fn run(
        _fn_spec: &FunctionSpecification,
        _auth_ctx: &AuthorizationContext,
        args: &Vec<Value>,
    ) -> Result<Value, Diagnostic> {
        let Value::Array(list) = args.get(0).unwrap() else {
            panic!("index function requires list for first input")
        };
        let Value::Integer(index) = args.get(1).unwrap() else {
            panic!("index function requires uint for second input")
        };
        match list.get(*index as usize) {
            Some(r) => Ok(r.clone()),
            None => panic!("index {} exceeds list bounds: {:?}", index, list),
        }
    }
}