wdl-engine 0.13.2

Execution engine for Workflow Description Language (WDL) documents.
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

//! Implements the `contains` function from the WDL standard library.

use wdl_analysis::types::PrimitiveType;
use wdl_ast::Diagnostic;

use super::CallContext;
use super::Callback;
use super::Function;
use super::Signature;
use crate::Value;

/// Tests whether the given array contains at least one occurrence of the given
/// value.
///
/// https://github.com/openwdl/wdl/blob/wdl-1.2/SPEC.md#-contains
fn contains(context: CallContext<'_>) -> Result<Value, Diagnostic> {
    debug_assert_eq!(context.arguments.len(), 2);
    debug_assert!(context.return_type_eq(PrimitiveType::Boolean));

    let array = context.arguments[0]
        .value
        .as_array()
        .expect("argument should be an array");

    let item = &context.arguments[1].value;

    Ok(array
        .as_slice()
        .iter()
        .any(|e| Value::equals(e, item).unwrap_or(false))
        .into())
}

/// Gets the function describing `contains`.
pub const fn descriptor() -> Function {
    Function::new(
        const {
            &[Signature::new(
                "(array: Array[P], value: P) -> Boolean where `P`: any primitive type",
                Callback::Sync(contains),
            )]
        },
    )
}

#[cfg(test)]
mod test {
    use wdl_ast::version::V1;

    use crate::v1::test::TestEnv;
    use crate::v1::test::eval_v1_expr;

    #[tokio::test]
    async fn contains() {
        let env = TestEnv::default();

        assert!(
            !eval_v1_expr(&env, V1::Two, "contains([], 1)")
                .await
                .unwrap()
                .unwrap_boolean()
        );
        assert!(
            !eval_v1_expr(&env, V1::Two, "contains([], None)")
                .await
                .unwrap()
                .unwrap_boolean()
        );
        assert!(
            eval_v1_expr(&env, V1::Two, "contains([1, None, 3], None)")
                .await
                .unwrap()
                .unwrap_boolean()
        );
        assert!(
            eval_v1_expr(&env, V1::Two, "contains([None], None)")
                .await
                .unwrap()
                .unwrap_boolean()
        );
        assert!(
            eval_v1_expr(&env, V1::Two, "contains([1, 2, 3, 4, 5], 2)")
                .await
                .unwrap()
                .unwrap_boolean()
        );
        assert!(
            !eval_v1_expr(&env, V1::Two, "contains([1, 2, 3, 4, 5], 100)")
                .await
                .unwrap()
                .unwrap_boolean()
        );
        assert!(
            eval_v1_expr(&env, V1::Two, "contains(['foo', 'bar', 'baz'], 'foo')")
                .await
                .unwrap()
                .unwrap_boolean()
        );
        assert!(
            !eval_v1_expr(&env, V1::Two, "contains(['foo', 'bar', 'baz'], 'qux')")
                .await
                .unwrap()
                .unwrap_boolean()
        );
        assert!(
            !eval_v1_expr(&env, V1::Two, "contains(['foo', None, 'baz'], 'bar')")
                .await
                .unwrap()
                .unwrap_boolean()
        );
        assert!(
            eval_v1_expr(&env, V1::Two, "contains(['foo', None, 'baz'], None)")
                .await
                .unwrap()
                .unwrap_boolean()
        );
    }
}