omena-bridge 0.2.0

CME-coupled bridge crate for Omena semantic graph inputs
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

use std::path::{Path, PathBuf};

use oxc_ast::ast::{Argument, Expression};

use super::syntax::{expression_identifier_name, skip_parens_and_ts};

pub(super) fn static_replacement_path(
    config_path: &Path,
    expression: &Expression<'_>,
) -> Option<String> {
    if let Some(value) = static_string(expression) {
        let target_path = PathBuf::from(value);
        if target_path.is_absolute() {
            return Some(target_path.to_string_lossy().to_string());
        }
        return Some(
            normalize_path_lexical(
                config_path
                    .parent()
                    .unwrap_or_else(|| Path::new("."))
                    .join(target_path),
            )
            .to_string_lossy()
            .to_string(),
        );
    }
    static_path_call(config_path, expression)
}

fn static_path_call(config_path: &Path, expression: &Expression<'_>) -> Option<String> {
    let Expression::CallExpression(call) = skip_parens_and_ts(expression) else {
        return None;
    };
    let Expression::StaticMemberExpression(callee) = skip_parens_and_ts(&call.callee) else {
        return None;
    };
    if expression_identifier_name(&callee.object) != Some("path")
        || (callee.property.name.as_str() != "resolve" && callee.property.name.as_str() != "join")
    {
        return None;
    }
    let mut path = PathBuf::new();
    for argument in &call.arguments {
        let segment = static_path_segment(config_path, argument)?;
        path.push(segment);
    }
    Some(normalize_path_lexical(path).to_string_lossy().to_string())
}

fn static_path_segment(config_path: &Path, argument: &Argument<'_>) -> Option<PathBuf> {
    if let Argument::Identifier(identifier) = argument
        && identifier.name.as_str() == "__dirname"
    {
        return Some(
            config_path
                .parent()
                .unwrap_or_else(|| Path::new("."))
                .to_path_buf(),
        );
    }
    static_string_from_argument(argument).map(PathBuf::from)
}

fn static_string_from_argument(argument: &Argument<'_>) -> Option<String> {
    match argument {
        Argument::StringLiteral(literal) => Some(literal.value.as_str().to_string()),
        Argument::TemplateLiteral(literal)
            if literal.expressions.is_empty() && literal.quasis.len() == 1 =>
        {
            literal.quasis[0]
                .value
                .cooked
                .map(|value| value.as_str().to_string())
        }
        Argument::ParenthesizedExpression(expression) => static_string(&expression.expression),
        Argument::TSAsExpression(expression) => static_string(&expression.expression),
        Argument::TSSatisfiesExpression(expression) => static_string(&expression.expression),
        _ => None,
    }
}

pub(super) fn static_string(expression: &Expression<'_>) -> Option<String> {
    match skip_parens_and_ts(expression) {
        Expression::StringLiteral(literal) => Some(literal.value.as_str().to_string()),
        Expression::TemplateLiteral(literal)
            if literal.expressions.is_empty() && literal.quasis.len() == 1 =>
        {
            literal.quasis[0]
                .value
                .cooked
                .map(|value| value.as_str().to_string())
        }
        _ => None,
    }
}

fn normalize_path_lexical(path: PathBuf) -> PathBuf {
    let mut normalized = PathBuf::new();
    for component in path.components() {
        match component {
            std::path::Component::CurDir => {}
            std::path::Component::ParentDir => {
                normalized.pop();
            }
            std::path::Component::Normal(_)
            | std::path::Component::RootDir
            | std::path::Component::Prefix(_) => {
                normalized.push(component.as_os_str());
            }
        }
    }
    normalized
}