globetrotter 0.0.15

Polyglot, type-safe internationalization
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

//! Angular pipe inputs are classified before their constituent literals are visited.

use super::{Dialect, DynamicReference, References, constructs_string, literal_prefix, text};
use std::io;
use tree_sitter::Node;

pub(super) fn classify_pipes(
    node: Node<'_>,
    source: &str,
    functions: &[String],
    references: &mut References,
) -> io::Result<()> {
    let Some(expression) = pipe_expression(node) else {
        return Ok(());
    };
    if node
        .parent()
        .is_some_and(|parent| is_calculation(parent) && parent.end_byte() == node.end_byte())
    {
        return Ok(());
    }
    let Some(sequence) = expression.child_by_field_name("pipes") else {
        return Ok(());
    };
    let mut cursor = sequence.walk();
    for (index, pipe) in sequence
        .named_children(&mut cursor)
        .filter(|child| child.kind() == "pipe_call")
        .enumerate()
    {
        let Some(name) = pipe.child_by_field_name("name") else {
            continue;
        };
        if !functions
            .iter()
            .any(|function| text(name, source).is_ok_and(|name| name == function))
        {
            continue;
        }
        let input = if node == expression {
            expression.named_child(0).unwrap_or(node)
        } else {
            node
        };
        if index != 0 || !constructs_string(input, source, Dialect::AngularExpression)? {
            continue;
        }

        // The grammar attaches a pipe to the right operand of a calculation.
        // Angular applies it to the complete calculation.
        // Results of earlier pipes are opaque, just like function results.
        let prefix = literal_prefix(input, source, Dialect::AngularExpression)?
            .filter(|prefix| prefix.contains('.') && prefix.chars().all(super::super::is_key_char));
        let end = pipe
            .prev_named_sibling()
            .map_or(sequence.start_byte(), |operator| operator.start_byte());
        let raw = source
            .get(node.start_byte()..end)
            .ok_or_else(|| io::Error::other("invalid Angular pipe input span"))?;
        let span = node.start_byte()..node.start_byte() + raw.trim_end().len();
        references.dynamic.push(DynamicReference { prefix, span });
    }
    Ok(())
}

fn is_calculation(node: Node<'_>) -> bool {
    matches!(
        node.kind(),
        "concatenation_expression" | "binary_expression"
    )
}

fn pipe_expression(node: Node<'_>) -> Option<Node<'_>> {
    if node.kind() == "expression" && node.child_by_field_name("pipes").is_some() {
        return Some(node);
    }
    if is_calculation(node) {
        let mut cursor = node.walk();
        return node
            .named_children(&mut cursor)
            .last()
            .and_then(pipe_expression);
    }
    None
}