draxl-patch 0.1.1

Structured semantic patch operations over the Draxl model
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use draxl_ast::{NodeId, Span};

/// Unresolved textual patch op parsed from the canonical patch surface.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum SurfacePatchOp {
    Insert {
        dest: SurfaceRankedDest,
        fragment: SurfaceFragment,
        span: Span,
    },
    Put {
        slot: SurfaceSlotRef,
        fragment: SurfaceFragment,
        span: Span,
    },
    Replace {
        target: SurfaceNodeRef,
        fragment: SurfaceFragment,
        span: Span,
    },
    Delete {
        target: SurfaceNodeRef,
        span: Span,
    },
    Move {
        target: SurfaceNodeRef,
        dest: SurfaceDest,
        span: Span,
    },
    Set {
        path: SurfacePath,
        value: SurfaceValue,
        span: Span,
    },
    Clear {
        path: SurfacePath,
        span: Span,
    },
    Attach {
        node: SurfaceNodeRef,
        target: SurfaceNodeRef,
        span: Span,
    },
    Detach {
        node: SurfaceNodeRef,
        span: Span,
    },
}

impl SurfacePatchOp {
    /// Returns the source span for the full patch op entry.
    pub fn span(&self) -> Span {
        match self {
            Self::Insert { span, .. }
            | Self::Put { span, .. }
            | Self::Replace { span, .. }
            | Self::Delete { span, .. }
            | Self::Move { span, .. }
            | Self::Set { span, .. }
            | Self::Clear { span, .. }
            | Self::Attach { span, .. }
            | Self::Detach { span, .. } => *span,
        }
    }
}

/// Parsed `@id` node reference.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SurfaceNodeRef {
    pub id: NodeId,
    pub span: Span,
}

/// Parsed owner for a slot ref.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum SurfaceSlotOwner {
    File { span: Span },
    Node(SurfaceNodeRef),
}

/// Parsed slot reference before schema resolution.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SurfaceSlotRef {
    pub owner: SurfaceSlotOwner,
    pub slot: String,
    pub slot_span: Span,
    pub span: Span,
}

/// Parsed ranked destination before schema resolution.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SurfaceRankedDest {
    pub slot: SurfaceSlotRef,
    pub rank: String,
    pub rank_span: Span,
    pub span: Span,
}

/// Parsed move destination before schema resolution.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum SurfaceDest {
    Ranked(SurfaceRankedDest),
    Slot(SurfaceSlotRef),
}

/// Parsed scalar path before schema resolution.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SurfacePath {
    pub node: SurfaceNodeRef,
    pub segments: Vec<SurfacePathSegment>,
    pub span: Span,
}

/// Parsed scalar path segment.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SurfacePathSegment {
    pub name: String,
    pub span: Span,
}

/// Parsed scalar value before type resolution.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SurfaceValue {
    pub kind: SurfaceValueKind,
    pub span: Span,
}

/// Surface scalar value variants.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum SurfaceValueKind {
    Ident(String),
    Str(String),
    Int(i64),
    Bool(bool),
}

/// Fragment source carried verbatim until schema resolution picks a parser.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SurfaceFragment {
    pub source: String,
    pub span: Span,
}