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

mod error;
mod parse;
mod resolve;
mod surface;

use crate::model::PatchOp;
use draxl_ast::{File, LowerLanguage};

pub use error::PatchTextError;
pub use surface::{
    SurfaceDest, SurfaceFragment, SurfaceNodeRef, SurfacePatchOp, SurfacePath, SurfacePathSegment,
    SurfaceRankedDest, SurfaceSlotOwner, SurfaceSlotRef, SurfaceValue, SurfaceValueKind,
};

/// Parses canonical textual patch syntax into unresolved surface ops.
pub fn parse_patch_ops(source: &str) -> Result<Vec<SurfacePatchOp>, PatchTextError> {
    parse::parse_patch_ops(source)
}

/// Resolves textual patch ops against the current file into ordinary `PatchOp`s.
pub fn resolve_patch_ops(file: &File, source: &str) -> Result<Vec<PatchOp>, PatchTextError> {
    resolve_patch_ops_for_language(LowerLanguage::Rust, file, source)
}

/// Resolves textual patch ops against the current file into ordinary `PatchOp`s using the selected
/// lower language.
pub fn resolve_patch_ops_for_language(
    language: LowerLanguage,
    file: &File,
    source: &str,
) -> Result<Vec<PatchOp>, PatchTextError> {
    let surface_ops = parse_patch_ops(source)?;
    let resolved = resolve::resolve_patch_ops(language, file, source, &surface_ops)?;
    Ok(resolved.into_iter().map(|op| op.op).collect())
}

/// Parses, resolves, and applies textual patch ops in order.
pub fn apply_patch_text(file: &mut File, source: &str) -> Result<(), PatchTextError> {
    apply_patch_text_for_language(LowerLanguage::Rust, file, source)
}

/// Parses, resolves, and applies textual patch ops in order using the selected lower language.
pub fn apply_patch_text_for_language(
    language: LowerLanguage,
    file: &mut File,
    source: &str,
) -> Result<(), PatchTextError> {
    let surface_ops = parse_patch_ops(source)?;
    for surface_op in &surface_ops {
        let resolved = resolve::resolve_op(language, file, source, surface_op)?;
        crate::apply_op_for_language(language, file, resolved.op)
            .map_err(|error| error::patch_text_error(source, resolved.span, &error.message))?;
    }
    Ok(())
}