feat: add build args

Author: 0xgregthedev

bin/pcl/src/main.rs

@@ -14,7 +14,7 @@ use pcl_core::{
         ConfigArgs,
     },
 };
-use pcl_phoundry::test::PhorgeTest;
+use pcl_phoundry::phorge_test::PhorgeTest;
 use serde_json::json;
 
 const VERSION_MESSAGE: &str = concat!(

crates/core/tests/common/da_store_harness.rs

@@ -10,7 +10,7 @@ use pcl_core::{
     assertion_da::DaStoreArgs,
     error::DaSubmitError,
 };
-use pcl_phoundry::phorge::BuildAndFlattenArgs;
+use pcl_phoundry::build_and_flatten::BuildAndFlattenArgs;
 use std::{
     collections::HashMap,
     path::PathBuf,

crates/phoundry/src/build.rs

@@ -0,0 +1,249 @@
+use clap::{
+    Parser,
+    ValueHint,
+};
+use foundry_cli::opts::{
+    BuildOpts,
+    ProjectPathOpts,
+};
+
+use std::path::PathBuf;
+
+use crate::compile::compile;
+use crate::error::PhoundryError;
+
+/// Command-line arguments for building assertion contracts and tests.
+#[derive(Debug, Default, Parser)]
+#[clap(about = "Build contracts using Phorge")]
+pub struct BuildArgs {
+    /// Root directory of the project
+    #[clap(
+        short = 'r',
+        long,
+        value_hint = ValueHint::DirPath,
+        help = "Root directory of the project"
+    )]
+    pub root: Option<PathBuf>,
+}
+
+impl BuildArgs {
+    /// Builds the assertion contract and tests
+    ///
+    /// # Returns
+    ///
+    /// - `Ok(())`
+    /// - `Err(PhoundryError)` if any step in the process fails
+    pub fn run(&self) -> Result<(), Box<PhoundryError>> {
+        let build_cmd = BuildOpts {
+            project_paths: ProjectPathOpts {
+                root: self.root.clone(),
+                // FIXME(Odysseas): this essentially hard-codes the location of the assertions to live in
+                // assertions/src
+                contracts: Some(PathBuf::from("assertions/src")),
+                ..Default::default()
+            },
+            ..Default::default()
+        };
+
+        foundry_cli::utils::load_dotenv();
+
+        compile(build_cmd)?;
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+    use tempfile::TempDir;
+
+    // Helper function to create a temporary Solidity project with valid contracts
+    fn setup_valid_test_project() -> (TempDir, PathBuf) {
+        let temp_dir = TempDir::new().unwrap();
+        let project_root = temp_dir.path().join("test_project");
+        fs::create_dir_all(&project_root).unwrap();
+
+        // Create assertions/src directory structure
+        let contract_dir = project_root.join("assertions").join("src");
+        fs::create_dir_all(&contract_dir).unwrap();
+
+        // Create a valid test contract
+        let contract_path = contract_dir.join("ValidContract.sol");
+        fs::write(
+            &contract_path,
+            r#"// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract ValidContract {
+    function test() public pure returns (bool) {
+        return true;
+    }
+}"#,
+        )
+        .unwrap();
+
+        (temp_dir, project_root)
+    }
+
+    // Helper function to create a temporary Solidity project with compilation errors
+    fn setup_invalid_test_project() -> (TempDir, PathBuf) {
+        let temp_dir = TempDir::new().unwrap();
+        let project_root = temp_dir.path().join("test_project");
+        fs::create_dir_all(&project_root).unwrap();
+
+        // Create assertions/src directory structure
+        let contract_dir = project_root.join("assertions").join("src");
+        fs::create_dir_all(&contract_dir).unwrap();
+
+        // Create a contract with compilation errors
+        let contract_path = contract_dir.join("InvalidContract.sol");
+        fs::write(
+            &contract_path,
+            r#"// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+contract InvalidContract {
+    // Missing semicolon - syntax error
+    uint256 public value = 42
+    
+    // Invalid function syntax - missing parentheses
+    function test public pure returns (bool) {
+        // Type mismatch error
+        return "not a boolean";
+    }
+    
+    // Undefined variable error
+    function anotherTest() public pure returns (uint256) {
+        return undefinedVariable;
+    }
+    
+    // Missing closing brace
+}"#,
+        )
+        .unwrap();
+
+        (temp_dir, project_root)
+    }
+
+    // Helper function to create an empty project (no source files)
+    fn setup_empty_test_project() -> (TempDir, PathBuf) {
+        let temp_dir = TempDir::new().unwrap();
+        let project_root = temp_dir.path().join("test_project");
+        fs::create_dir_all(&project_root).unwrap();
+
+        // Create assertions/src directory but leave it empty
+        let contract_dir = project_root.join("assertions").join("src");
+        fs::create_dir_all(&contract_dir).unwrap();
+
+        (temp_dir, project_root)
+    }
+
+    #[test]
+    fn test_build_args_new() {
+        let args = BuildArgs { root: None };
+
+        assert!(args.root.is_none());
+    }
+
+    #[test]
+    fn test_build_args_with_root() {
+        let root_path = PathBuf::from("/test/path");
+        let args = BuildArgs {
+            root: Some(root_path.clone()),
+        };
+
+        assert_eq!(args.root, Some(root_path));
+    }
+
+    #[test]
+    fn test_compilation_with_invalid_contract() {
+        let (_temp_dir, project_root) = setup_invalid_test_project();
+
+        let args = BuildArgs {
+            root: Some(project_root),
+        };
+
+        let result = args.run();
+
+        // Compilation should fail due to syntax errors
+        assert!(
+            result.is_err(),
+            "Expected compilation to fail with invalid contract"
+        );
+
+        // Verify it's a compilation error
+        if let Err(error) = result {
+            // The error should be a compilation error or related error type
+            // We can't check the exact error type without knowing the PhoundryError variants,
+            // but the compilation should definitely fail
+            println!("Compilation failed as expected with error: {:?}", error);
+        }
+    }
+
+    #[test]
+    fn test_compilation_with_empty_directory() {
+        let (_temp_dir, project_root) = setup_empty_test_project();
+
+        let args = BuildArgs {
+            root: Some(project_root),
+        };
+
+        let result = args.run();
+
+        // Compilation should fail due to no source files
+        assert!(
+            result.is_err(),
+            "Expected compilation to fail with empty directory"
+        );
+
+        if let Err(error) = result {
+            println!("Compilation failed as expected with error: {:?}", error);
+        }
+    }
+
+    #[test]
+    fn test_compilation_with_nonexistent_directory() {
+        let temp_dir = TempDir::new().unwrap();
+        let nonexistent_path = temp_dir.path().join("nonexistent_project");
+
+        let args = BuildArgs {
+            root: Some(nonexistent_path),
+        };
+
+        let result = args.run();
+
+        // Compilation should fail due to nonexistent directory
+        assert!(
+            result.is_err(),
+            "Expected compilation to fail with nonexistent directory"
+        );
+
+        if let Err(error) = result {
+            println!("Compilation failed as expected with error: {:?}", error);
+        }
+    }
+
+    #[tokio::test(flavor = "multi_thread")]
+    async fn test_build_integration_with_valid_contract() {
+        let (_temp_dir, project_root) = setup_valid_test_project();
+
+        let args = BuildArgs {
+            root: Some(project_root),
+        };
+
+        let result = args.run();
+
+        // This test might succeed or fail depending on the environment and dependencies
+        // In a real test environment with proper setup, it should succeed with valid contracts
+        match result {
+            Ok(_) => println!("Compilation succeeded as expected"),
+            Err(error) => {
+                println!(
+                    "Compilation failed (might be expected in test environment): {:?}",
+                    error
+                )
+            }
+        }
+    }
+}

crates/phoundry/src/build_and_flatten.rs

@@ -2,25 +2,13 @@ use clap::{
     Parser,
     ValueHint,
 };
-use color_eyre::Report;
-use forge::{
-    cmd::{
-        build::BuildArgs,
-        test::TestArgs,
-    },
-    opts::{
-        Forge,
-        ForgeSubcommand,
-    },
-};
 use foundry_cli::{
     opts::{
         BuildOpts,
         ProjectPathOpts,
     },
     utils::LoadConfig,
 };
-use foundry_common::compile::ProjectCompiler;
 use foundry_compilers::{
     flatten::{
         Flattener,
@@ -33,12 +21,8 @@ use foundry_compilers::{
 
 use alloy_json_abi::JsonAbi;
 
-use foundry_config::{
-    error::ExtractConfigError,
-    find_project_root,
-};
+use foundry_config::find_project_root;
 use std::path::PathBuf;
-use tokio::task::spawn_blocking;
 
 use crate::error::PhoundryError;
 
@@ -151,8 +135,8 @@ impl BuildAndFlattenArgs {
 
     /// Builds the project and returns the compilation output.
     fn build(&self) -> Result<ProjectCompileOutput, Box<PhoundryError>> {
-        let build_cmd = BuildArgs {
-            build: BuildOpts {
+        let build_opts = 
+            BuildOpts {
                 project_paths: ProjectPathOpts {
                     root: self.root.clone(),
                     // FIXME(Odysseas): this essentially hard-codes the location of the assertions to live in
@@ -161,41 +145,9 @@ impl BuildAndFlattenArgs {
                     ..Default::default()
                 },
                 ..Default::default()
-            },
-            ..Default::default()
-        };
+            };
 
-        let config = build_cmd.load_config()?;
-
-        let project = config.project().map_err(PhoundryError::SolcError)?;
-        let contracts = project.sources_path();
-
-        match std::fs::read_dir(contracts) {
-            Ok(mut files) => {
-                // Check if the directory is empty
-                if files.next().is_none() {
-                    return Err(Box::new(PhoundryError::NoSourceFilesFound));
-                }
-            }
-            Err(_) => {
-                return Err(Box::new(PhoundryError::DirectoryNotFound(
-                    contracts.to_path_buf(),
-                )));
-            }
-        }
-
-        let compiler = ProjectCompiler::new()
-            .dynamic_test_linking(config.dynamic_test_linking)
-            .print_names(build_cmd.names)
-            .print_sizes(build_cmd.sizes)
-            .ignore_eip_3860(build_cmd.ignore_eip_3860)
-            .bail(true)
-            .quiet(true);
-
-        let res = compiler
-            .compile(&project)
-            .map_err(PhoundryError::CompilationError)?;
-        Ok(res)
+        crate::compile::compile(build_opts)
     }
 
     /// Flattens the contract source code.
@@ -234,7 +186,6 @@ impl BuildAndFlattenArgs {
     }
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;