feat(apollo_infra_utils): add cairo-format to verified cairo0 scripts

Author: dorimedini-starkware

crates/apollo_infra_utils/src/cairo0_compiler.rs

@@ -13,6 +13,7 @@ pub mod test;
 
 pub const STARKNET_COMPILE_DEPRECATED: &str = "starknet-compile-deprecated";
 pub const CAIRO0_COMPILE: &str = "cairo-compile";
+pub const CAIRO0_FORMAT: &str = "cairo-format";
 pub const EXPECTED_CAIRO0_VERSION: &str = "0.14.0a1";
 
 /// The local python requirements used to determine the cairo0 compiler version.
@@ -21,20 +22,20 @@ pub(crate) static PIP_REQUIREMENTS_FILE: LazyLock<PathBuf> =
     LazyLock::new(|| resolve_project_relative_path("scripts/requirements.txt").unwrap());
 
 #[derive(thiserror::Error, Debug)]
-pub enum Cairo0CompilerVersionError {
-    #[error("{compiler} version is not correct: required {required}, got {existing}.")]
-    IncorrectVersion { compiler: String, existing: String, required: String },
+pub enum Cairo0ScriptVersionError {
+    #[error("{script} version is not correct: required {required}, got {existing}.")]
+    IncorrectVersion { script: String, existing: String, required: String },
     #[error("{0} not found.")]
     NotFound(String),
 }
 
-pub fn cairo0_compilers_correct_version() -> Result<(), Cairo0CompilerVersionError> {
-    for compiler in [CAIRO0_COMPILE, STARKNET_COMPILE_DEPRECATED] {
-        let version = match Command::new(compiler).arg("--version").output() {
+pub fn cairo0_scripts_correct_version() -> Result<(), Cairo0ScriptVersionError> {
+    for script in [CAIRO0_COMPILE, CAIRO0_FORMAT, STARKNET_COMPILE_DEPRECATED] {
+        let version = match Command::new(script).arg("--version").output() {
             Ok(output) => String::from_utf8_lossy(&output.stdout).to_string(),
             Err(error) => {
-                return Err(Cairo0CompilerVersionError::NotFound(format!(
-                    "Failed to get {compiler} version: {error}."
+                return Err(Cairo0ScriptVersionError::NotFound(format!(
+                    "Failed to get {script} version: {error}."
                 )));
             }
         };
@@ -43,11 +44,11 @@ pub fn cairo0_compilers_correct_version() -> Result<(), Cairo0CompilerVersionErr
             .replace("==", " ")
             .split(" ")
             .nth(1)
-            .ok_or(Cairo0CompilerVersionError::NotFound("No compiler version found.".to_string()))?
+            .ok_or(Cairo0ScriptVersionError::NotFound("No script version found.".to_string()))?
             != EXPECTED_CAIRO0_VERSION
         {
-            return Err(Cairo0CompilerVersionError::IncorrectVersion {
-                compiler: compiler.to_string(),
+            return Err(Cairo0ScriptVersionError::IncorrectVersion {
+                script: script.to_string(),
                 existing: version,
                 required: EXPECTED_CAIRO0_VERSION.to_string(),
             });
@@ -59,15 +60,15 @@ pub fn cairo0_compilers_correct_version() -> Result<(), Cairo0CompilerVersionErr
 
 /// Verifies that the required Cairo0 compiler is available; panics if unavailable.
 /// For use in tests only. If cairo0 compiler verification is required in business logic, use
-/// `crate::cairo0_compiler::cairo0_compilers_correct_version` instead.
+/// `crate::cairo0_compiler::cairo0_scripts_correct_version` instead.
 #[cfg(any(test, feature = "testing"))]
 pub fn verify_cairo0_compiler_deps() {
-    let specific_error = match cairo0_compilers_correct_version() {
+    let specific_error = match cairo0_scripts_correct_version() {
         Ok(_) => {
             return;
         }
-        Err(Cairo0CompilerVersionError::NotFound(_)) => "no installed cairo-lang found".to_string(),
-        Err(Cairo0CompilerVersionError::IncorrectVersion { existing, .. }) => {
+        Err(Cairo0ScriptVersionError::NotFound(_)) => "no installed cairo-lang found".to_string(),
+        Err(Cairo0ScriptVersionError::IncorrectVersion { existing, .. }) => {
             format!("installed version: {existing}")
         }
     };