Use snforge_std or snforge_std_compatibility in snforge new

Closes #3461

commit-id:182fb50c

Author: cptartur

.github/workflows/ci.yml

@@ -135,6 +135,7 @@ jobs:
       - run: cargo test --package forge --features scarb_2_9_1 --test main e2e::requirements::test_warning_on_scarb_version_below_recommended
       - run: cargo test --package forge --features scarb_2_9_1 --lib compatibility_check::tests::warning_requirements
       - run: cargo test --package forge --features scarb_2_9_1 --test main e2e::running::sierra_gas_with_older_scarb
+      - run: cargo test --package forge --features scarb_2_9_1 --test main e2e::new::init_new_project_from_scarb_with_snforge_std_compatibility
 
   # TODO(#3212): Closures in Cairo are fully supported since version 2.11
   test-interact-with-state:

crates/forge/src/new.rs

@@ -48,11 +48,21 @@ struct TemplateManifestConfig {
 }
 
 impl TemplateManifestConfig {
-    fn add_dependencies(&self, scarb_manifest_path: &PathBuf) -> Result<()> {
+    fn add_dependencies(
+        &self,
+        scarb_version: &Version,
+        scarb_manifest_path: &PathBuf,
+    ) -> Result<()> {
         if env::var("DEV_DISABLE_SNFORGE_STD_DEPENDENCY").is_err() {
+            // TODO: Check Scarb `2.12`
+            let snforge_package = if scarb_version.build.is_empty() {
+                "snforge_std_compatibility"
+            } else {
+                "snforge_std"
+            };
             let snforge_version = env!("CARGO_PKG_VERSION");
             Dependency {
-                name: "snforge_std".to_string(),
+                name: snforge_package.to_string(),
                 version: snforge_version.to_string(),
                 dev: true,
             }
@@ -323,6 +333,7 @@ pub fn new(
         );
     }
     let name = infer_name(name, &path)?;
+    let scarb_version = ScarbCommand::version().run()?.scarb;
 
     fs::create_dir_all(&path)?;
     let project_path = path.canonicalize()?;
@@ -361,7 +372,7 @@ pub fn new(
     }
 
     let template_config = TemplateManifestConfig::try_from(&template)?;
-    template_config.add_dependencies(&scarb_manifest_path)?;
+    template_config.add_dependencies(&scarb_version, &scarb_manifest_path)?;
     template_config.update_config(&scarb_manifest_path)?;
 
     let template_dir = get_template_dir(&template)?;

crates/forge/tests/e2e/new.rs

@@ -9,6 +9,7 @@ use forge::Template;
 use forge::scarb::config::SCARB_MANIFEST_TEMPLATE_CONTENT;
 use indoc::{formatdoc, indoc};
 use regex::Regex;
+use scarb_api::ScarbCommand;
 use shared::consts::FREE_RPC_PROVIDER_URL;
 use shared::test_utils::output_assert::assert_stdout_contains;
 use snapbox::assert_matches;
@@ -43,7 +44,7 @@ fn init_new_project() {
         ),
     );
 
-    validate_init(&temp.join("test_name"), false, &Template::BalanceContract);
+    validate_init(&temp.join("test_name"), None, &Template::BalanceContract);
 }
 
 #[test_case(&Template::CairoProgram; "cairo-program")]
@@ -66,7 +67,7 @@ fn create_new_project_dir_not_exist(template: &Template) {
         .assert()
         .success();
 
-    validate_init(&project_path, false, template);
+    validate_init(&project_path, None, template);
 }
 
 #[test]
@@ -105,35 +106,73 @@ fn create_new_project_dir_exists_and_empty() {
         .assert()
         .success();
 
-    validate_init(&project_path, false, &Template::BalanceContract);
+    validate_init(&project_path, None, &Template::BalanceContract);
 }
 
 #[test]
 fn init_new_project_from_scarb() {
     let temp = tempdir_with_tool_versions().unwrap();
 
-    SnapboxCommand::new("scarb")
-        .current_dir(&temp)
-        .args(["new", "test_name"])
-        .env("SCARB_INIT_TEST_RUNNER", "starknet-foundry")
-        .env(
-            "PATH",
-            append_to_path_var(snforge_test_bin_path().parent().unwrap()),
-        )
-        .assert()
-        .success();
-
-    validate_init(&temp.join("test_name"), true, &Template::BalanceContract);
+    SnapboxCommand::from_std(
+        ScarbCommand::new()
+            .current_dir(temp.path())
+            .args(["new", "test_name"])
+            .env("SCARB_INIT_TEST_RUNNER", "starknet-foundry")
+            .env(
+                "PATH",
+                append_to_path_var(snforge_test_bin_path().parent().unwrap()),
+            )
+            .command(),
+    )
+    .assert()
+    .success();
+
+    validate_init(
+        &temp.join("test_name"),
+        Some(SnforgeStd::Normal),
+        &Template::BalanceContract,
+    );
 }
 
+#[test]
+#[cfg_attr(not(feature = "scarb_2_9_1"), ignore)]
+fn init_new_project_from_scarb_with_snforge_std_compatibility() {
+    let temp = tempdir_with_tool_versions().unwrap();
+    let tool_version_path = temp.join(".tool-versions");
+    fs::write(tool_version_path, "scarb 2.11.4").unwrap();
+
+    SnapboxCommand::from_std(
+        ScarbCommand::new()
+            .current_dir(temp.path())
+            .args(["new", "test_name"])
+            .env("SCARB_INIT_TEST_RUNNER", "starknet-foundry")
+            .env(
+                "PATH",
+                append_to_path_var(snforge_test_bin_path().parent().unwrap()),
+            )
+            .command(),
+    )
+    .assert()
+    .success();
+
+    validate_init(
+        &temp.join("test_name"),
+        Some(SnforgeStd::Compatibility),
+        &Template::BalanceContract,
+    );
+}
 pub fn append_to_path_var(path: &Path) -> OsString {
     let script_path = iter::once(path.to_path_buf());
     let os_path = env::var_os("PATH").unwrap();
     let other_paths = env::split_paths(&os_path);
     env::join_paths(script_path.chain(other_paths)).unwrap()
 }
 
-fn validate_init(project_path: &PathBuf, validate_snforge_std: bool, template: &Template) {
+fn validate_init(
+    project_path: &PathBuf,
+    validate_snforge_std: Option<SnforgeStd>,
+    template: &Template,
+) {
     let manifest_path = project_path.join("Scarb.toml");
     let scarb_toml = fs::read_to_string(manifest_path.clone()).unwrap();
 
@@ -160,7 +199,7 @@ fn validate_init(project_path: &PathBuf, validate_snforge_std: bool, template: &
     dependencies.remove("snforge_std");
     dependencies.insert("snforge_std", Item::Value(Value::InlineTable(snforge_std)));
 
-    std::fs::write(manifest_path, scarb_toml.to_string()).unwrap();
+    fs::write(manifest_path, scarb_toml.to_string()).unwrap();
 
     let output = test_runner(&TempDir::new().unwrap())
         .current_dir(project_path)
@@ -171,11 +210,21 @@ fn validate_init(project_path: &PathBuf, validate_snforge_std: bool, template: &
     assert_stdout_contains(output, expected);
 }
 
-fn get_expected_manifest_content(template: &Template, validate_snforge_std: bool) -> String {
-    let snforge_std_assert = if validate_snforge_std {
-        "\nsnforge_std = \"[..]\""
-    } else {
-        ""
+enum SnforgeStd {
+    Normal,
+    Compatibility,
+}
+
+fn get_expected_manifest_content(
+    template: &Template,
+    validate_snforge_std: Option<SnforgeStd>,
+) -> String {
+    let snforge_std_assert = match validate_snforge_std {
+        None => "",
+        Some(snforge_std) => match snforge_std {
+            SnforgeStd::Normal => "\nsnforge_std = \"[..]\"",
+            SnforgeStd::Compatibility => "\nsnforge_std_compatibility = \"[..]\"",
+        },
     };
 
     let target_contract_entry = "[[target.starknet-contract]]\nsierra = true";