add check-manifest, check-crlf.

Author: Dirbaio

src/cmd/check_crlf.rs

@@ -0,0 +1,107 @@
+use crate::types::Context;
+use anyhow::{anyhow, Result};
+use std::fs;
+use std::path::Path;
+use walkdir::WalkDir;
+
+#[derive(Debug, clap::Args)]
+/// Check that all files in the repository have LF line endings (no CRLF)
+pub struct Args;
+
+pub fn run(ctx: &Context, _args: Args) -> Result<()> {
+    let mut files_with_crlf = Vec::new();
+    
+    // Walk through all files in the repository
+    for entry in WalkDir::new(&ctx.root)
+        .into_iter()
+        .filter_entry(|e| !is_ignored_path(e.path()))
+    {
+        let entry = entry?;
+        let path = entry.path();
+        
+        // Only check regular files
+        if !path.is_file() {
+            continue;
+        }
+        
+        // Skip binary files by checking if they're likely text files
+        if !is_likely_text_file(path) {
+            continue;
+        }
+        
+        // Read file as bytes to detect CRLF
+        match fs::read(path) {
+            Ok(contents) => {
+                if contains_crlf(&contents) {
+                    let relative_path = path.strip_prefix(&ctx.root)
+                        .unwrap_or(path)
+                        .display()
+                        .to_string();
+                    files_with_crlf.push(relative_path);
+                }
+            }
+            Err(e) => {
+                // Skip files we can't read (permissions, etc.)
+                eprintln!("Warning: Could not read {}: {}", path.display(), e);
+            }
+        }
+    }
+    
+    if files_with_crlf.is_empty() {
+        println!("✅ All text files have LF line endings!");
+        Ok(())
+    } else {
+        for file in &files_with_crlf {
+            eprintln!("❌ File has CRLF line endings: {}", file);
+        }
+        Err(anyhow!("Found {} files with CRLF line endings", files_with_crlf.len()))
+    }
+}
+
+fn is_ignored_path(path: &Path) -> bool {
+    let path_str = path.to_string_lossy();
+    
+    // Skip common directories and files that should be ignored
+    path_str.contains("/.git/") ||
+    path_str.contains("/target/") ||
+    path_str.contains("/node_modules/") ||
+    path_str.contains("/.cargo/") ||
+    path_str.ends_with("/.DS_Store") ||
+    path_str.ends_with("/Thumbs.db") ||
+    path_str.contains("/__pycache__/") ||
+    path_str.contains("/.pytest_cache/")
+}
+
+fn is_likely_text_file(path: &Path) -> bool {
+    if let Some(extension) = path.extension().and_then(|e| e.to_str()) {
+        // Common text file extensions
+        matches!(extension.to_lowercase().as_str(),
+            "rs" | "toml" | "md" | "txt" | "yml" | "yaml" | "json" | 
+            "js" | "ts" | "html" | "css" | "scss" | "xml" | "svg" |
+            "py" | "sh" | "bash" | "zsh" | "fish" | "ps1" | "bat" |
+            "c" | "cpp" | "cc" | "cxx" | "h" | "hpp" | "hxx" |
+            "java" | "kt" | "scala" | "go" | "rb" | "php" | "cs" |
+            "gitignore" | "gitattributes" | "dockerignore" | "dockerfile" |
+            "makefile" | "cmake" | "gradle" | "sbt" | "pom" |
+            "log" | "ini" | "cfg" | "conf" | "config"
+        )
+    } else {
+        // Files without extensions - check if they're known text files
+        if let Some(filename) = path.file_name().and_then(|f| f.to_str()) {
+            matches!(filename.to_lowercase().as_str(),
+                "readme" | "license" | "changelog" | "authors" | "contributors" |
+                "dockerfile" | "makefile" | "rakefile" | "gemfile" | "pipfile" |
+                "cargo.lock" | "package.json" | "package-lock.json" |
+                "yarn.lock" | "pnpm-lock.yaml" | ".gitignore" | ".gitattributes" |
+                ".dockerignore" | ".editorconfig" | ".rustfmt.toml"
+            )
+        } else {
+            false
+        }
+    }
+}
+
+fn contains_crlf(contents: &[u8]) -> bool {
+    // Look for CRLF sequences (\r\n)
+    contents.windows(2).any(|window| window == b"\r\n")
+}

src/cmd/check_manifest.rs

@@ -0,0 +1,162 @@
+use crate::types::Context;
+use anyhow::{anyhow, Result};
+use std::collections::HashSet;
+use toml_edit::{DocumentMut, Item};
+
+#[derive(Debug, clap::Args)]
+/// Check that all Cargo.toml files have correct metadata and feature configuration
+pub struct Args;
+
+pub fn run(ctx: &Context, _args: Args) -> Result<()> {
+    let mut errors = Vec::new();
+    
+    for (crate_name, krate) in &ctx.crates {
+        let cargo_toml_path = krate.path.join("Cargo.toml");
+        let content = std::fs::read_to_string(&cargo_toml_path)
+            .map_err(|e| anyhow!("Failed to read {}: {}", cargo_toml_path.display(), e))?;
+        
+        let doc: DocumentMut = content.parse()
+            .map_err(|e| anyhow!("Failed to parse {}: {}", cargo_toml_path.display(), e))?;
+        
+        // Check package metadata
+        if let Err(e) = check_package_metadata(&doc, crate_name, krate.publish) {
+            errors.push(format!("{}: {}", crate_name, e));
+        }
+        
+        // Check features - only for publishable crates
+        if krate.publish {
+            if let Err(e) = check_features(&doc) {
+                errors.push(format!("{}: {}", crate_name, e));
+            }
+        }
+    }
+    
+    if errors.is_empty() {
+        println!("✅ All manifests are correct!");
+        Ok(())
+    } else {
+        for error in &errors {
+            eprintln!("❌ {}", error);
+        }
+        Err(anyhow!("Found {} manifest errors", errors.len()))
+    }
+}
+
+fn check_package_metadata(doc: &DocumentMut, crate_name: &str, is_publishable: bool) -> Result<()> {
+    let package = doc.get("package")
+        .ok_or_else(|| anyhow!("missing [package] section"))?
+        .as_table()
+        .ok_or_else(|| anyhow!("[package] is not a table"))?;
+    
+    // Check license
+    let license = package.get("license")
+        .ok_or_else(|| anyhow!("missing license field"))?
+        .as_str()
+        .ok_or_else(|| anyhow!("license field is not a string"))?;
+    
+    if license != "MIT OR Apache-2.0" {
+        return Err(anyhow!("license should be 'MIT OR Apache-2.0', found '{}'", license));
+    }
+    
+    // Only check repository and documentation for publishable crates
+    if is_publishable {
+        // Check repository
+        let repository = package.get("repository")
+            .ok_or_else(|| anyhow!("missing repository field"))?
+            .as_str()
+            .ok_or_else(|| anyhow!("repository field is not a string"))?;
+        
+        if repository != "https://github.com/embassy-rs/embassy" {
+            return Err(anyhow!("repository should be 'https://github.com/embassy-rs/embassy', found '{}'", repository));
+        }
+        
+        // Check documentation
+        let documentation = package.get("documentation")
+            .ok_or_else(|| anyhow!("missing documentation field"))?
+            .as_str()
+            .ok_or_else(|| anyhow!("documentation field is not a string"))?;
+        
+        let expected_documentation = format!("https://docs.embassy.dev/{}", crate_name);
+        if documentation != expected_documentation {
+            return Err(anyhow!("documentation should be '{}', found '{}'", expected_documentation, documentation));
+        }
+    }
+    
+    Ok(())
+}
+
+fn check_features(doc: &DocumentMut) -> Result<()> {
+    // Get all optional dependencies
+    let mut optional_deps: HashSet<String> = HashSet::new();
+    
+    // Check dependencies
+    if let Some(deps) = doc.get("dependencies").and_then(|d| d.as_table()) {
+        for (name, value) in deps.iter() {
+            if is_optional_dependency(value) {
+                optional_deps.insert(name.to_string());
+            }
+        }
+    }
+    
+    // Check dev-dependencies
+    if let Some(deps) = doc.get("dev-dependencies").and_then(|d| d.as_table()) {
+        for (name, value) in deps.iter() {
+            if is_optional_dependency(value) {
+                optional_deps.insert(name.to_string());
+            }
+        }
+    }
+    
+    // Check build-dependencies
+    if let Some(deps) = doc.get("build-dependencies").and_then(|d| d.as_table()) {
+        for (name, value) in deps.iter() {
+            if is_optional_dependency(value) {
+                optional_deps.insert(name.to_string());
+            }
+        }
+    }
+    
+    if optional_deps.is_empty() {
+        return Ok(()); // No optional dependencies to check
+    }
+    
+    // Get all features that reference dependencies
+    let mut referenced_deps: HashSet<String> = HashSet::new();
+    
+    if let Some(features) = doc.get("features").and_then(|f| f.as_table()) {
+        for (_feature_name, feature_value) in features.iter() {
+            if let Some(feature_list) = feature_value.as_array() {
+                for item in feature_list.iter() {
+                    if let Some(item_str) = item.as_str() {
+                        if let Some(dep_name) = item_str.strip_prefix("dep:") {
+                            referenced_deps.insert(dep_name.to_string());
+                        }
+                    }
+                }
+            }
+        }
+    }
+    
+    // Find unreferenced optional dependencies
+    let unreferenced: Vec<String> = optional_deps.difference(&referenced_deps).cloned().collect();
+    
+    if !unreferenced.is_empty() {
+        return Err(anyhow!(
+            "optional dependencies not referenced by any feature with 'dep:': {}",
+            unreferenced.join(", ")
+        ));
+    }
+    
+    Ok(())
+}
+
+fn is_optional_dependency(value: &Item) -> bool {
+    match value {
+        Item::Value(toml_edit::Value::InlineTable(table)) => {
+            table.get("optional")
+                .and_then(|v| v.as_bool())
+                .unwrap_or(false)
+        }
+        _ => false
+    }
+}

src/cmd/mod.rs

@@ -1,5 +1,7 @@
 pub mod build;
 pub mod bump;
+pub mod check_crlf;
+pub mod check_manifest;
 pub mod dependencies;
 pub mod dependents;
 pub mod list;

src/main.rs

@@ -30,6 +30,8 @@ enum Command {
     Build(cmd::build::Args),
     SemverCheck(cmd::semver_check::Args),
     PrepareRelease(cmd::prepare_release::Args),
+    CheckManifest(cmd::check_manifest::Args),
+    CheckCrlf(cmd::check_crlf::Args),
 }
 
 fn list_crates(root: &PathBuf) -> Result<BTreeMap<CrateId, Crate>> {
@@ -186,6 +188,12 @@ fn main() -> Result<()> {
         Command::PrepareRelease(args) => {
             cmd::prepare_release::run(&mut ctx, args)?;
         }
+        Command::CheckManifest(args) => {
+            cmd::check_manifest::run(&ctx, args)?;
+        }
+        Command::CheckCrlf(args) => {
+            cmd::check_crlf::run(&ctx, args)?;
+        }
     }
     Ok(())
 }