rust: Add glint (#2811)

Signed-off-by: Ryan Northey <[email protected]>

Author: phlax

.github/workflows/rust.yml

@@ -18,15 +18,33 @@ permissions:
   contents: read
 
 jobs:
-  test:
+  coverage:
     runs-on: ubuntu-24.04
     if: github.repository_owner == 'envoyproxy'
     steps:
     - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  # v4.2.2
     - uses: actions-rust-lang/setup-rust-toolchain@v1
       with:
         toolchain: nightly
-    - run: |
-        cargo install cargo-tarpaulin
-        cargo-tarpaulin
+    - name: Install cargo-tarpaulin
+      run: cargo install cargo-tarpaulin
+    - name: Run coverage
+      run: |
+        cargo tarpaulin --config tarpaulin.toml
+      working-directory: rust
+
+  integration:
+    runs-on: ubuntu-24.04
+    strategy:
+      matrix:
+        rust:
+        - stable
+    steps:
+    - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  # v4.2.2
+    - uses: actions-rust-lang/setup-rust-toolchain@v1
+      with:
+        toolchain: ${{ matrix.rust }}
+    - name: Run glint integration tests specifically
+      run: |
+        cargo test --package glint --test integration_test --verbose
       working-directory: rust

rust/Cargo.toml

@@ -2,6 +2,7 @@
 members = [
   "core",
   "echo",
+  "glint",
   "runner",
   "test",
 ]

rust/glint/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "glint"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+clap = { version = "4.5", features = ["derive"] }
+anyhow = "1.0"
+regex = "1.10"
+rayon = "1.10"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+
+[dev-dependencies]
+serde_json = "1.0"

rust/glint/src/args.rs

@@ -0,0 +1,10 @@
+use clap::Parser;
+use std::path::PathBuf;
+
+#[derive(Parser, Debug)]
+#[command(name = "glint")]
+#[command(about = "Lint files for whitespace issues", long_about = None)]
+pub struct Args {
+    #[arg(required = true)]
+    pub paths: Vec<PathBuf>,
+}

rust/glint/src/check.rs

@@ -0,0 +1,48 @@
+use anyhow::{Context, Result};
+use std::fs::File;
+use std::io::{BufRead, BufReader, Read, Seek, SeekFrom};
+use std::path::Path;
+
+pub fn final_newline(path: &Path) -> Result<bool> {
+    let mut file = File::open(path).context("Failed to open file")?;
+    let size = file.metadata()?.len();
+    if size == 0 {
+        return Ok(true); // Empty files are considered OK
+    }
+    file.seek(SeekFrom::End(-1))?;
+    let mut last_byte = [0u8; 1];
+    file.read_exact(&mut last_byte)?;
+    Ok(last_byte[0] != b'\n')
+}
+
+pub fn trailing_whitespace(path: &Path) -> Result<Vec<usize>> {
+    let file = File::open(path).context("Failed to open file")?;
+    let reader = BufReader::new(file);
+    let mut lines_with_trailing = Vec::new();
+    for (line_num, line) in reader.lines().enumerate() {
+        let line = line?;
+        if line.ends_with(' ') || line.ends_with('\t') {
+            lines_with_trailing.push(line_num + 1); // 1-based line numbers
+        }
+    }
+    Ok(lines_with_trailing)
+}
+
+pub fn mixed_indentation(path: &Path) -> Result<bool> {
+    let file = File::open(path).context("Failed to open file")?;
+    let reader = BufReader::new(file);
+    let mut has_tab_indent = false;
+    let mut has_space_indent = false;
+    for line in reader.lines() {
+        let line = line?;
+        if line.starts_with('\t') {
+            has_tab_indent = true;
+        } else if line.starts_with(' ') {
+            has_space_indent = true;
+        }
+        if has_tab_indent && has_space_indent {
+            return Ok(true);
+        }
+    }
+    Ok(false)
+}

rust/glint/src/files.rs

@@ -0,0 +1,117 @@
+use crate::check;
+#[allow(unused_imports)]
+use anyhow::{Context, Result};
+use regex::Regex;
+use serde::{Deserialize, Serialize};
+use std::path::{Path, PathBuf};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FileIssues {
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub trailing_whitespace: Vec<usize>,
+    #[serde(skip_serializing_if = "std::ops::Not::not")]
+    pub mixed_indentation: bool,
+    #[serde(skip_serializing_if = "std::ops::Not::not")]
+    pub no_final_newline: bool,
+}
+
+impl FileIssues {
+    pub fn new() -> Self {
+        FileIssues {
+            trailing_whitespace: Vec::new(),
+            mixed_indentation: false,
+            no_final_newline: false,
+        }
+    }
+
+    pub fn has_issues(&self) -> bool {
+        !self.trailing_whitespace.is_empty() || self.mixed_indentation || self.no_final_newline
+    }
+
+    pub fn total_issues(&self) -> usize {
+        self.trailing_whitespace.len()
+            + if self.mixed_indentation { 1 } else { 0 }
+            + if self.no_final_newline { 1 } else { 0 }
+    }
+}
+
+pub fn should_exclude(path: &Path) -> bool {
+    let path_str = path.to_string_lossy();
+    let exclude_patterns = [
+        r"[\w\W/-]*\.go$",
+        r"[\w\W/-]*\.patch$",
+        r"^test/[\w/]*_corpus/[\w/]*",
+        r"^tools/[\w/]*_corpus/[\w/]*",
+        r"[\w/]*password_protected_password.txt$",
+    ];
+    for pattern in &exclude_patterns {
+        if let Ok(re) = Regex::new(pattern) {
+            if re.is_match(&path_str) {
+                return true;
+            }
+        }
+    }
+    false
+}
+
+pub fn process_file(path: &Path) -> Result<Option<(String, FileIssues)>> {
+    if should_exclude(path) {
+        return Ok(None);
+    }
+    let mut issues = FileIssues::new();
+
+    match check::trailing_whitespace(path) {
+        Ok(lines) => issues.trailing_whitespace = lines,
+        Err(e) => {
+            return Err(e.context(format!(
+                "Failed to check trailing whitespace for {}",
+                path.display()
+            )));
+        }
+    }
+
+    match check::mixed_indentation(path) {
+        Ok(mixed) => issues.mixed_indentation = mixed,
+        Err(e) => {
+            return Err(e.context(format!(
+                "Failed to check mixed indentation for {}",
+                path.display()
+            )));
+        }
+    }
+
+    match check::final_newline(path) {
+        Ok(missing) => issues.no_final_newline = missing,
+        Err(e) => {
+            return Err(e.context(format!(
+                "Failed to check final newline for {}",
+                path.display()
+            )));
+        }
+    }
+
+    if issues.has_issues() {
+        Ok(Some((path.display().to_string(), issues)))
+    } else {
+        Ok(None)
+    }
+}
+
+/// Recursively find all files in a directory
+pub fn find_files(path: &Path) -> Result<Vec<PathBuf>> {
+    let mut files = Vec::new();
+    if path.is_file() {
+        files.push(path.to_path_buf());
+    } else if path.is_dir() {
+        for entry in std::fs::read_dir(path)? {
+            let entry = entry?;
+            let path = entry.path();
+            if path.is_file() {
+                files.push(path);
+            } else if path.is_dir() {
+                files.extend(find_files(&path)?);
+            }
+        }
+    }
+    Ok(files)
+}

rust/glint/src/main.rs

@@ -0,0 +1,88 @@
+mod args;
+mod check;
+mod files;
+
+use anyhow::Result;
+use clap::Parser;
+use rayon::prelude::*;
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use std::sync::{
+    Mutex,
+    atomic::{AtomicBool, Ordering},
+};
+
+use crate::args::Args;
+use crate::files::{FileIssues, find_files, process_file};
+
+#[derive(Debug, Serialize, Deserialize)]
+struct LintResult {
+    files: HashMap<String, FileIssues>,
+    summary: Summary,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct Summary {
+    total_files: usize,
+    files_with_issues: usize,
+    total_issues: usize,
+}
+
+fn main() -> Result<()> {
+    let args = Args::parse();
+    let mut all_files = Vec::new();
+    for path in &args.paths {
+        if !path.exists() {
+            eprintln!("Warning: Path does not exist: {}", path.display());
+            continue;
+        }
+        all_files.extend(find_files(path)?);
+    }
+
+    if all_files.is_empty() {
+        eprintln!("No files to process");
+        return Ok(());
+    }
+
+    let file_issues = Mutex::new(HashMap::new());
+    let had_error = AtomicBool::new(false);
+    all_files
+        .par_iter()
+        .for_each(|file| match process_file(file) {
+            Ok(Some((path, issues))) => {
+                let mut map = file_issues.lock().unwrap();
+                map.insert(path, issues);
+            }
+            Ok(None) => {}
+            Err(e) => {
+                eprintln!("Error processing {}: {}", file.display(), e);
+                had_error.store(true, Ordering::Relaxed);
+            }
+        });
+
+    let files = file_issues.into_inner().unwrap();
+
+    // Calculate summary
+    let total_files = all_files.len();
+    let files_with_issues = files.len();
+    let total_issues: usize = files.values().map(|f| f.total_issues()).sum();
+
+    let result = LintResult {
+        files,
+        summary: Summary {
+            total_files,
+            files_with_issues,
+            total_issues,
+        },
+    };
+
+    // Output JSON
+    println!("{}", serde_json::to_string_pretty(&result)?);
+
+    // Exit with non-zero status if there were issues
+    if files_with_issues > 0 || had_error.load(Ordering::Relaxed) {
+        std::process::exit(1);
+    }
+
+    Ok(())
+}

rust/glint/tests/fixtures/README.md

@@ -0,0 +1,19 @@
+# Test Fixtures for glint
+
+This directory contains test files and their expected outputs.
+
+## Test Files:
+- `bad.txt` - 50 lines with all types of issues (trailing whitespace, mixed indentation, no final newline)
+- `bad2.txt` - 7 lines with all types of issues  
+- `bad3.txt` - 7 lines with only trailing whitespace issues
+- `good.txt` - Clean file with no issues
+
+## Expected Files:
+Each test file has a corresponding `.expected.json` file containing the exact JSON output that glint should produce.
+
+To generate/update an expected file:
+```bash
+cargo run -- tests/fixtures/FILENAME.txt > tests/fixtures/FILENAME.txt.expected.json
+```
+
+Then manually edit to ensure paths are relative (e.g., `tests/fixtures/bad.txt` not the full path).