restart

Author: anthonyshew

crates/turborepo-lib/src/turbo_json/mod.rs

@@ -11,14 +11,14 @@ use clap::ValueEnum;
 use miette::{NamedSource, SourceSpan};
 use serde::{Deserialize, Serialize};
 use struct_iterable::Iterable;
-use turbopath::AbsoluteSystemPath;
+use turbopath::{AbsoluteSystemPath, AnchoredSystemPath, AnchoredSystemPathBuf};
 use turborepo_errors::Spanned;
 use turborepo_repository::package_graph::ROOT_PKG_NAME;
 use turborepo_unescape::UnescapedString;
 
 use crate::{
     cli::{EnvMode, OutputLogsMode},
-    config::{ConfigurationOptions, Error, InvalidEnvPrefixError},
+    config::{ConfigurationOptions, Error, InvalidEnvPrefixError, RootSyntaxInGlobalDepsError},
     run::{
         task_access::TaskAccessTraceFile,
         task_id::{TaskId, TaskName},
@@ -33,6 +33,8 @@ pub use loader::TurboJsonLoader;
 
 use crate::{boundaries::BoundariesConfig, config::UnnecessaryPackageTaskSyntaxError};
 
+const TURBO_ROOT: &str = "$TURBO_ROOT$";
+
 #[derive(Serialize, Deserialize, Debug, Default, PartialEq, Clone, Deserializable)]
 #[serde(rename_all = "camelCase")]
 pub struct SpacesJson {
@@ -537,10 +539,11 @@ impl RawTurboJson {
     }
 }
 
-impl TryFrom<RawTurboJson> for TurboJson {
-    type Error = Error;
-
-    fn try_from(raw_turbo: RawTurboJson) -> Result<Self, Error> {
+impl TurboJson {
+    fn from_raw(
+        raw_turbo: RawTurboJson,
+        path_to_repo_root: &AnchoredSystemPath,
+    ) -> Result<Self, Error> {
         if let Some(pipeline) = raw_turbo.pipeline {
             let (span, text) = pipeline.span_and_text("turbo.json");
             return Err(Error::PipelineField { span, text });
@@ -608,6 +611,8 @@ impl TryFrom<RawTurboJson> for TurboJson {
             // Remote Cache config is handled through layered config
         })
     }
+
+    // fn task
 }
 
 impl TurboJson {
@@ -629,7 +634,12 @@ impl TurboJson {
         path: &AbsoluteSystemPath,
     ) -> Result<TurboJson, Error> {
         let raw_turbo_json = RawTurboJson::read(repo_root, path)?;
-        raw_turbo_json.try_into()
+        // pass in repo_root
+        // This needs the relative path to root
+        let pkg_path = path.parent().expect("turbo.json is not root");
+        // relative pkg_path -> repo_root
+        let path_to_root = AnchoredSystemPathBuf::relative_path_between(pkg_path, repo_root);
+        TurboJson::from_raw(raw_turbo_json, &path_to_root)
     }
 
     pub fn task(&self, task_id: &TaskId, task_name: &TaskName) -> Option<RawTaskDefinition> {
@@ -739,6 +749,30 @@ pub fn validate_extends(turbo_json: &TurboJson) -> Vec<Error> {
     }
 }
 
+pub fn validate_no_root_syntax_in_global_deps(turbo_json: &TurboJson) -> Vec<Error> {
+    let mut errors = Vec::new();
+
+    for dep in &turbo_json.global_deps {
+        if dep.starts_with("$TURBO_ROOT$") {
+            errors.push(Error::RootSyntaxInGlobalDeps(Box::new(
+                RootSyntaxInGlobalDepsError {
+                    span: turbo_json.text.as_ref().map(|text| {
+                        // Find the position of the $TURBO_ROOT$ in the text
+                        let pos = text.find("$TURBO_ROOT$").unwrap_or(0);
+                        (pos, pos + 12).into() // 12 is length of "$TURBO_ROOT$"
+                    }),
+                    text: NamedSource::new(
+                        turbo_json.path.as_deref().unwrap_or("turbo.json"),
+                        turbo_json.text.as_deref().unwrap_or("").to_string(),
+                    ),
+                },
+            )));
+        }
+    }
+
+    errors
+}
+
 fn gather_env_vars(
     vars: Vec<Spanned<impl Into<String>>>,
     key: &str,
@@ -765,6 +799,21 @@ fn gather_env_vars(
     Ok(())
 }
 
+// $TURBO_ROOT$/something
+fn replace_turbo_root_token(
+    task_definition: &mut TaskDefinition,
+    path_to_repo_root: &AnchoredSystemPath,
+) {
+    for input in task_definition.inputs.iter_mut() {
+        let swapped = input.replacen(TURBO_ROOT, path_to_repo_root.as_str(), 1);
+    }
+    /* need to go through incl & exclu individually
+       for output in task_definition.outputs.iter_mut() {
+           let swapped = output.replacen(TURBO_ROOT, path_to_repo_root.as_str(), 1);
+       }
+    */
+}
+
 #[cfg(test)]
 mod tests {
     use anyhow::Result;
@@ -775,13 +824,15 @@ mod tests {
     use test_case::test_case;
     use turborepo_unescape::UnescapedString;
 
-    use super::{RawTurboJson, SpacesJson, Spanned, TurboJson, UIMode};
+    use super::{
+        validate_no_root_syntax_in_global_deps, RawTaskDefinition, RawTurboJson, SpacesJson,
+        Spanned, TaskName, TurboJson, UIMode,
+    };
     use crate::{
         boundaries::BoundariesConfig,
         cli::OutputLogsMode,
-        run::task_id::TaskName,
+        config::Error,
         task_graph::{TaskDefinition, TaskOutputs},
-        turbo_json::RawTaskDefinition,
     };
 
     #[test_case("{}", "empty boundaries")]
@@ -1191,4 +1242,32 @@ mod tests {
             &[Spanned::new(UnescapedString::from("api#server"))]
         );
     }
+
+    #[test]
+    fn test_validate_no_root_syntax_in_global_deps() {
+        let json_with_root = r#"{
+            "globalDependencies": ["$TURBO_ROOT$/some/path"]
+        }"#;
+
+        let json_without_root = r#"{
+            "globalDependencies": ["some/path"]
+        }"#;
+
+        let turbo_json_with_root = RawTurboJson::parse(json_with_root, "turbo.json").unwrap();
+        let turbo_json = TurboJson::try_from(turbo_json_with_root).unwrap();
+        let errors = validate_no_root_syntax_in_global_deps(&turbo_json);
+        assert_eq!(errors.len(), 1);
+        match &errors[0] {
+            Error::RootSyntaxInGlobalDeps(error) => {
+                assert!(error.span.is_some());
+                assert_eq!(error.text.name(), "turbo.json");
+            }
+            _ => panic!("Expected RootSyntaxInGlobalDeps error"),
+        }
+
+        let turbo_json_without_root = RawTurboJson::parse(json_without_root, "turbo.json").unwrap();
+        let turbo_json = TurboJson::try_from(turbo_json_without_root).unwrap();
+        let errors = validate_no_root_syntax_in_global_deps(&turbo_json);
+        assert!(errors.is_empty());
+    }
 }