texform-transform 0.1.0

Profile-based AST transform engine for TeXForm (internal; use the texform crate)
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

use crate::ast::{
    ArgumentKind, ArgumentSlot, ArgumentValue, ContentMode, Delimiter, GroupKind, Node, NodeId,
};
use crate::rewrite::RuleError;
use crate::rewrite::helpers::FenceToken;
use crate::rewrite::rule::RuleKey;
use crate::rewrite::rule_context::RuleContext;

pub(super) struct BinaryFencePair {
    pub(super) auto_left: Delimiter,
    pub(super) auto_right: Delimiter,
    pub(super) fixed_left: FenceToken,
    pub(super) fixed_right: FenceToken,
}

pub(super) fn required_braced_math_arg(
    rule: RuleKey,
    cx: &mut RuleContext<'_>,
    slot: &ArgumentSlot,
    subject: &str,
    label: &str,
) -> Result<NodeId, RuleError> {
    match slot {
        Some(arg) if arg.kind == ArgumentKind::Group => match arg.value {
            ArgumentValue::MathContent(node_id) => Ok(node_id),
            _ => Err(cx.for_rule(rule).invalid_shape(format!("{subject} {label} should be math content"))),
        },
        _ => Err(cx.for_rule(rule).invalid_shape(format!("{subject} {label} should be a required braced math group"))),
    }
}

pub(super) fn required_math_arg(
    rule: RuleKey,
    cx: &mut RuleContext<'_>,
    slot: &ArgumentSlot,
    subject: &str,
    label: &str,
) -> Result<NodeId, RuleError> {
    cx.for_rule(rule)
        .mandatory_or_group_math_content(slot, subject, label)
}

pub(super) fn replace_with_binary_bracket_fence(
    cx: &mut RuleContext<'_>,
    node_id: NodeId,
    starred: bool,
    left: NodeId,
    right: NodeId,
    fences: BinaryFencePair,
) {
    if starred {
        replace_with_fixed_fence(
            cx,
            node_id,
            left,
            right,
            fences.fixed_left,
            fences.fixed_right,
        );
    } else {
        replace_with_auto_fence(cx, node_id, left, right, fences.auto_left, fences.auto_right);
    }
}

fn replace_with_auto_fence(
    cx: &mut RuleContext<'_>,
    node_id: NodeId,
    left: NodeId,
    right: NodeId,
    open: Delimiter,
    close: Delimiter,
) {
    let mut children = Vec::new();
    append_binary_bracket_body(cx, &mut children, left, right);

    cx.ast.replace_node_drop_detached_children(node_id,
        Node::Group {
            children,
            kind: GroupKind::Delimited {
                left: open,
                right: close,
            },
            mode: ContentMode::Math,
        },
    );
}

fn replace_with_fixed_fence(
    cx: &mut RuleContext<'_>,
    node_id: NodeId,
    left: NodeId,
    right: NodeId,
    open: FenceToken,
    close: FenceToken,
) {
    let mut rest = Vec::new();
    append_binary_bracket_body(cx, &mut rest, left, right);
    rest.push(cx.ast.new_node(close.node()));

    let open = cx.ast.new_node(open.node());
    cx.ast
        .replace_with_math_sequence_preserving_scripts(node_id, Vec::new(), open, rest);
}

fn append_binary_bracket_body(
    cx: &mut RuleContext<'_>,
    out: &mut Vec<NodeId>,
    left: NodeId,
    right: NodeId,
) {
    cx.ast.append_cloned_math_content(out, left);
    out.push(cx.ast.new_node(Node::Char(',')));
    cx.ast.append_cloned_math_content(out, right);
}