eure-cli 0.1.4

Command-line tool for Eure format conversion and validation
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
143

use catppuccin::{FlavorColors, PALETTE};
use eure::query::{
    GetSemanticTokens, SemanticToken, SemanticTokenModifier, SemanticTokenType, TextFile,
    TextFileContent, build_runtime,
};
use eure::query_flow::DurabilityLevel;
use maud::{Markup, html};

use crate::util::{display_path, handle_query_error, read_input};

#[derive(clap::Args)]
pub struct Args {
    /// Path to Eure file (use '-' or omit for stdin)
    pub file: Option<String>,

    /// Catppuccin theme variant
    #[arg(short, long, value_enum, default_value = "frappe")]
    pub theme: Theme,
}

#[derive(clap::ValueEnum, Clone, Copy, Debug)]
pub enum Theme {
    Mocha,
    Macchiato,
    Frappe,
    Latte,
}

pub fn run(args: Args) {
    // 1. Read input
    let contents = match read_input(args.file.as_deref()) {
        Ok(c) => c,
        Err(e) => {
            eprintln!("{e}");
            std::process::exit(1);
        }
    };

    // Create query runtime
    let runtime = build_runtime();

    let file = TextFile::from_path(display_path(args.file.as_deref()).into());
    runtime.resolve_asset(
        file.clone(),
        TextFileContent(contents.clone()),
        DurabilityLevel::Static,
    );

    // Get semantic tokens
    let tokens = match runtime.query(GetSemanticTokens::new(file)) {
        Ok(result) => result,
        Err(e) => handle_query_error(&runtime, e),
    };

    // 4. Get color palette
    let palette = match args.theme {
        Theme::Mocha => PALETTE.mocha.colors,
        Theme::Macchiato => PALETTE.macchiato.colors,
        Theme::Frappe => PALETTE.frappe.colors,
        Theme::Latte => PALETTE.latte.colors,
    };

    // 5. Generate HTML using Maud
    let markup = generate_html(&contents, &tokens, palette, args.theme);
    println!("{}", markup.into_string());
}

fn generate_html(
    contents: &str,
    tokens: &[SemanticToken],
    palette: FlavorColors,
    theme: Theme,
) -> Markup {
    let bg = palette.base.hex;
    let fg = palette.text.hex;
    let theme_name = match theme {
        Theme::Mocha => "Mocha",
        Theme::Macchiato => "Macchiato",
        Theme::Frappe => "Frappé",
        Theme::Latte => "Latte",
    };

    html! {
        (maud::PreEscaped(format!("<!-- Generated by eure CLI (https://eure.dev) with Catppuccin {} theme -->\n", theme_name)))
        pre style=(format!("background: {}; color: {}; padding: 1em; border-radius: 0.5em; overflow-x: auto;", bg, fg)) {
            code {
                @for (i, token) in tokens.iter().enumerate() {
                    // Print whitespace before token (ESCAPED to prevent XSS)
                    @if i == 0 && token.start > 0 {
                        (&contents[0..token.start as usize])
                    } @else if i > 0 {
                        @let prev_end = (tokens[i-1].start + tokens[i-1].length) as usize;
                        @let curr_start = token.start as usize;
                        @if prev_end < curr_start {
                            (&contents[prev_end..curr_start])
                        }
                    }

                    // Print colored token (ESCAPED to prevent XSS)
                    @let start = token.start as usize;
                    @let end = start + token.length as usize;
                    @let text = &contents[start..end];
                    @let color = token_type_to_color(token.token_type, palette);
                    span style=(token_style(token, color)) { (text) }
                }

                // Print remaining content after last token (ESCAPED to prevent XSS)
                @if let Some(last) = tokens.last() {
                    @let last_end = (last.start + last.length) as usize;
                    @if last_end < contents.len() {
                        (&contents[last_end..])
                    }
                }
            }
        }
    }
}

fn token_style(token: &SemanticToken, color: catppuccin::Hex) -> String {
    let is_section_header = token.modifiers & SemanticTokenModifier::SectionHeader.bitmask() != 0;
    if is_section_header {
        format!("color: {}; font-weight: bold", color)
    } else {
        format!("color: {}", color)
    }
}

fn token_type_to_color(token_type: SemanticTokenType, palette: FlavorColors) -> catppuccin::Hex {
    match token_type {
        SemanticTokenType::Keyword => palette.mauve.hex, // Purple for keywords
        SemanticTokenType::Number => palette.peach.hex,  // Peach for numbers
        SemanticTokenType::String => palette.green.hex,  // Green for strings
        SemanticTokenType::Comment => palette.overlay0.hex, // Muted for comments
        SemanticTokenType::Operator => palette.lavender.hex, // Subtle purple for operators
        SemanticTokenType::Property => palette.text.hex, // Base text color for properties
        SemanticTokenType::Punctuation => palette.overlay2.hex, // Light gray for punctuation
        SemanticTokenType::Macro => palette.teal.hex,    // Teal for code blocks
        SemanticTokenType::Decorator => palette.pink.hex, // Pink for decorators
        SemanticTokenType::SectionMarker => palette.red.hex, // Red for @
        SemanticTokenType::ExtensionMarker => palette.pink.hex, // Strong pink for $
        SemanticTokenType::ExtensionIdent => palette.rosewater.hex, // Light pink for extension ident
    }
}