ToolBeta

Plugin-Entwicklung

Erstelle eigene Velisch-Plugins mit der Compiler-API für Code-Analyse, Metriken und mehr.

Beispiel-Plugin: Code-Metriken

Das Example Plugin zeigt, wie man ein Plugin für Code-Metriken erstellt:

cd tools/example-plugin
cargo build --release

Verwendung

Code-Metriken analysieren

velin-example-plugin metrics -i examples/

JSON-Output

velin-example-plugin metrics -i examples/ --format json

Verbose Output

velin-example-plugin metrics -i examples/ --verbose

Features

Funktionen

Anzahl der Funktionen im Projekt

Structs

Anzahl der Structs

Enums

Anzahl der Enums

Durchschnittliche Länge

Durchschnittliche Zeilen pro Funktion

Gesamt-Zeilen

Gesamte Anzahl Code-Zeilen

Beispiel-Output

📊 Code-Metriken für examples/:
  Funktionen: 45
  Structs: 12
  Enums: 3
  Durchschnittliche Funktion-Länge: 15 Zeilen
  Gesamt-Zeilen: 1200

JSON-Format

{
  "functions": 45,
  "structs": 12,
  "enums": 3,
  "average_function_length": 15,
  "total_lines": 1200,
  "files_analyzed": 23
}

Eigene Plugins erstellen

1. Projekt-Struktur

cargo new --bin my-velin-plugin
cd my-velin-plugin

2. Dependencies

Cargo.tomltoml

[package]
name = "velin-my-plugin"
version = "0.1.0"
edition = "2021"

[dependencies]
velin-compiler = { path = "../../compiler" }
clap = { version = "4.0", features = ["derive"] }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

3. Plugin-Logik

src/main.rsrust

use velin_compiler::parser::Parser;
use velin_compiler::parser::ast::*;

fn main() {
    let code = std::fs::read_to_string("example.velin").unwrap();
    let parser = Parser::new();
    let program = parser.parse(&code).unwrap();
    
    let mut function_count = 0;
    for item in &program.items {
        if let Item::Function(_) = item {
            function_count += 1;
        }
    }
    
    println!("Funktionen gefunden: {}", function_count);
}

Plugin-API

Parser verwenden

use velin_compiler::parser::Parser;

let parser = Parser::new();
let program = parser.parse(&code)?;

AST durchlaufen

for item in &program.items {
    match item {
        Item::Function(func) => {
            println!("Function: {}", func.name);
        }
        Item::Struct(s) => {
            println!("Struct: {}", s.name);
        }
        Item::Enum(e) => {
            println!("Enum: {}", e.name);
        }
        _ => {}
    }
}

Type-Checker verwenden

use velin_compiler::type_checker::TypeChecker;

let mut type_checker = TypeChecker::new();
type_checker.check(&program)?;

Best Practices

Klarer Zweck

Jedes Plugin sollte einen klaren Zweck haben

Gute Dokumentation

Dokumentiere alle Features und Optionen

Error Handling

Behandle Fehler ordentlich

Testing

Schreibe Tests für Plugin-Funktionalität

Performance

Optimiere für große Codebases

CLI-Design

Verwende clap für konsistente CLI

CI/CD Integration

.github/workflows/metrics.ymlyaml

- name: Code Metrics
  run: |
    cd tools/example-plugin
    cargo build --release
    ./target/release/velin-example-plugin metrics -i src/ --format json > metrics.json

Package Manager Tutorials