Update deno and rust.

crates/core/dep-graph/src/dep_builder.rs

@@ -89,8 +89,8 @@ impl<'ws> DepGraphBuilder<'ws> {
             return pair.clone();
         }
 
-        let mut project_runtime = Runtime::System;
-        let mut workspace_runtime = Runtime::System;
+        let mut project_runtime = Runtime::system();
+        let mut workspace_runtime = Runtime::system();
 
         if let Some(platform) = PlatformManager::read().find(|p| match task {
             Some(task) => p.matches(&task.platform, None),

crates/core/emitter/Cargo.toml

@@ -14,7 +14,7 @@ harness = false
 [dependencies]
 moon_action = { path = "../action" }
 moon_action_context = { path = "../action-context" }
-moon_platform_runtime = { path = "../platform-runtime" }
+moon_platform_runtime2 = { path = "../../../nextgen/platform-runtime" }
 moon_project = { path = "../../../nextgen/project" }
 moon_target = { path = "../../../nextgen/target" }
 moon_task = { path = "../../../nextgen/task" }

crates/core/emitter/src/event.rs

@@ -1,6 +1,6 @@
 use moon_action::{Action, ActionNode};
 use moon_action_context::ActionContext;
-use moon_platform_runtime::Runtime;
+use moon_platform_runtime2::Runtime;
 use moon_project::Project;
 use moon_target::Target;
 use moon_task::Task;

crates/core/runner/Cargo.toml

@@ -14,7 +14,7 @@ moon_emitter = { path = "../emitter" }
 moon_hash = { path = "../../../nextgen/hash" }
 moon_logger = { path = "../logger" }
 moon_platform = { path = "../platform" }
-moon_platform_runtime = { path = "../platform-runtime" }
+moon_platform_runtime2 = { path = "../../../nextgen/platform-runtime" }
 moon_process = { path = "../../../nextgen/process" }
 moon_project = { path = "../../../nextgen/project" }
 moon_target = { path = "../../../nextgen/target" }

crates/core/runner/src/runner.rs

@@ -11,7 +11,7 @@ use moon_emitter::{Emitter, Event, EventFlow};
 use moon_hash::ContentHasher;
 use moon_logger::{debug, warn};
 use moon_platform::PlatformManager;
-use moon_platform_runtime::Runtime;
+use moon_platform_runtime2::Runtime;
 use moon_process::{args, output_to_error, output_to_string, Command, Output};
 use moon_project::Project;
 use moon_target::{TargetError, TargetScope};

crates/deno/platform/src/platform.rs

@@ -11,7 +11,7 @@ use moon_deno_lang::{load_lockfile_dependencies, DenoJson, DENO_DEPS};
 use moon_deno_tool::DenoTool;
 use moon_hash::ContentHasher;
 use moon_logger::{debug, map_list};
-use moon_platform::{Platform, Runtime, Version};
+use moon_platform::{Platform, Runtime, RuntimeReq};
 use moon_process::Command;
 use moon_project::Project;
 use moon_task::Task;
@@ -51,7 +51,7 @@ impl DenoPlatform {
         DenoPlatform {
             config: config.to_owned(),
             proto_env,
-            toolchain: ToolManager::new(Runtime::Deno(Version::new_global())),
+            toolchain: ToolManager::new(Runtime::new(PlatformType::Deno, RuntimeReq::Global)),
             typescript_config: typescript_config.to_owned(),
             workspace_root: workspace_root.to_path_buf(),
         }
@@ -65,7 +65,7 @@ impl Platform for DenoPlatform {
     }
 
     fn get_runtime_from_config(&self, _project_config: Option<&ProjectConfig>) -> Runtime {
-        Runtime::Deno(Version::new_global())
+        Runtime::new(PlatformType::Deno, RuntimeReq::Global)
     }
 
     fn matches(&self, platform: &PlatformType, runtime: Option<&Runtime>) -> bool {
@@ -74,7 +74,7 @@ impl Platform for DenoPlatform {
         }
 
         if let Some(runtime) = &runtime {
-            return matches!(runtime, Runtime::Deno(_));
+            return matches!(runtime.platform, PlatformType::Deno);
         }
 
         false
@@ -104,8 +104,8 @@ impl Platform for DenoPlatform {
         Ok(Box::new(tool))
     }
 
-    fn get_tool_for_version(&self, version: Version) -> miette::Result<Box<&dyn Tool>> {
-        let tool = self.toolchain.get_for_version(&version)?;
+    fn get_tool_for_version(&self, req: RuntimeReq) -> miette::Result<Box<&dyn Tool>> {
+        let tool = self.toolchain.get_for_version(&req)?;
 
         Ok(Box::new(tool))
     }
@@ -123,17 +123,15 @@ impl Platform for DenoPlatform {
         //     None => Version::new_global(),
         // };
 
-        let version = Version::new_global();
+        let req = RuntimeReq::Global;
         let mut last_versions = FxHashMap::default();
 
-        if !self.toolchain.has(&version) {
-            self.toolchain.register(
-                &version,
-                DenoTool::new(&self.proto_env, &self.config, &version)?,
-            );
+        if !self.toolchain.has(&req) {
+            self.toolchain
+                .register(&req, DenoTool::new(&self.proto_env, &self.config, &req)?);
         }
 
-        self.toolchain.setup(&version, &mut last_versions).await?;
+        self.toolchain.setup(&req, &mut last_versions).await?;
 
         Ok(())
     }
@@ -152,16 +150,14 @@ impl Platform for DenoPlatform {
         runtime: &Runtime,
         last_versions: &mut FxHashMap<String, SemVersion>,
     ) -> miette::Result<u8> {
-        let version = runtime.version();
+        let req = &runtime.requirement;
 
-        if !self.toolchain.has(&version) {
-            self.toolchain.register(
-                &version,
-                DenoTool::new(&self.proto_env, &self.config, &version)?,
-            );
+        if !self.toolchain.has(req) {
+            self.toolchain
+                .register(req, DenoTool::new(&self.proto_env, &self.config, req)?);
         }
 
-        Ok(self.toolchain.setup(&version, last_versions).await?)
+        Ok(self.toolchain.setup(req, last_versions).await?)
     }
 
     async fn install_deps(
@@ -174,7 +170,7 @@ impl Platform for DenoPlatform {
             return Ok(());
         }
 
-        let tool = self.toolchain.get_for_version(runtime.version())?;
+        let tool = self.toolchain.get_for_version(&runtime.requirement)?;
 
         debug!(target: LOG_TARGET, "Installing dependencies");
 

crates/deno/tool/Cargo.toml

@@ -6,7 +6,7 @@ publish = false
 
 [dependencies]
 moon_config = { path = "../../../nextgen/config" }
-moon_platform_runtime = { path = "../../core/platform-runtime" }
+moon_platform_runtime2 = { path = "../../../nextgen/platform-runtime" }
 moon_tool = { path = "../../core/tool" }
 miette = { workspace = true }
 proto_core = { workspace = true }

crates/deno/tool/src/deno_tool.rs

@@ -1,5 +1,5 @@
 use moon_config::DenoConfig;
-use moon_platform_runtime::Version;
+use moon_platform_runtime2::RuntimeReq;
 use moon_tool::{async_trait, Tool};
 use proto_core::ProtoEnvironment;
 use std::path::PathBuf;
@@ -15,14 +15,14 @@ impl DenoTool {
     pub fn new(
         _proto: &ProtoEnvironment,
         config: &DenoConfig,
-        version: &Version,
+        req: &RuntimeReq,
     ) -> miette::Result<DenoTool> {
         let mut deno = DenoTool {
             config: config.to_owned(),
             global: true,
         };
 
-        if version.is_global() {
+        if req.is_global() {
             deno.global = true;
             // node.config.version = None;
         } else {

crates/rust/platform/src/rust_platform.rs

@@ -5,11 +5,11 @@ use moon_action_context::ActionContext;
 use moon_common::{is_ci, Id};
 use moon_config::{
     BinEntry, HasherConfig, PlatformType, ProjectConfig, ProjectsAliasesMap, ProjectsSourcesMap,
-    RustConfig,
+    RustConfig, VersionSpec,
 };
 use moon_hash::ContentHasher;
 use moon_logger::{debug, map_list};
-use moon_platform::{Platform, Runtime, Version};
+use moon_platform::{Platform, Runtime, RuntimeReq};
 use moon_process::Command;
 use moon_project::Project;
 use moon_rust_lang::{
@@ -55,7 +55,7 @@ impl RustPlatform {
         RustPlatform {
             config: config.to_owned(),
             proto_env,
-            toolchain: ToolManager::new(Runtime::Rust(Version::new_global())),
+            toolchain: ToolManager::new(Runtime::new(PlatformType::Rust, RuntimeReq::Global)),
             workspace_root: workspace_root.to_path_buf(),
         }
     }
@@ -71,16 +71,22 @@ impl Platform for RustPlatform {
         if let Some(config) = &project_config {
             if let Some(rust_config) = &config.toolchain.rust {
                 if let Some(version) = &rust_config.version {
-                    return Runtime::Rust(Version::new_override(version.to_string()));
+                    return Runtime::new(
+                        PlatformType::Rust,
+                        RuntimeReq::ToolchainOverride(VersionSpec::Version(version.to_owned())),
+                    );
                 }
             }
         }
 
         if let Some(version) = &self.config.version {
-            return Runtime::Rust(Version::new(version.to_string()));
+            return Runtime::new(
+                PlatformType::Rust,
+                RuntimeReq::Toolchain(VersionSpec::Version(version.to_owned())),
+            );
         }
 
-        Runtime::Rust(Version::new_global())
+        Runtime::new(PlatformType::Rust, RuntimeReq::Global)
     }
 
     fn matches(&self, platform: &PlatformType, runtime: Option<&Runtime>) -> bool {
@@ -89,7 +95,7 @@ impl Platform for RustPlatform {
         }
 
         if let Some(runtime) = &runtime {
-            return matches!(runtime, Runtime::Rust(_));
+            return matches!(runtime.platform, PlatformType::Rust);
         }
 
         false
@@ -155,8 +161,8 @@ impl Platform for RustPlatform {
         Ok(Box::new(tool))
     }
 
-    fn get_tool_for_version(&self, version: Version) -> miette::Result<Box<&dyn Tool>> {
-        let tool = self.toolchain.get_for_version(&version)?;
+    fn get_tool_for_version(&self, req: RuntimeReq) -> miette::Result<Box<&dyn Tool>> {
+        let tool = self.toolchain.get_for_version(&req)?;
 
         Ok(Box::new(tool))
     }
@@ -167,8 +173,8 @@ impl Platform for RustPlatform {
 
     async fn setup_toolchain(&mut self) -> miette::Result<()> {
         let version = match &self.config.version {
-            Some(v) => Version::new(v.to_string()),
-            None => Version::new_global(),
+            Some(v) => RuntimeReq::Toolchain(VersionSpec::Version(v.to_owned())),
+            None => RuntimeReq::Global,
         };
 
         let mut last_versions = FxHashMap::default();
@@ -199,16 +205,16 @@ impl Platform for RustPlatform {
         runtime: &Runtime,
         last_versions: &mut FxHashMap<String, SemVersion>,
     ) -> miette::Result<u8> {
-        let version = runtime.version();
+        let req = &runtime.requirement;
 
-        if !self.toolchain.has(&version) {
+        if !self.toolchain.has(req) {
             self.toolchain.register(
-                &version,
-                RustTool::new(&self.proto_env, &self.config, &version).await?,
+                req,
+                RustTool::new(&self.proto_env, &self.config, req).await?,
             );
         }
 
-        Ok(self.toolchain.setup(&version, last_versions).await?)
+        Ok(self.toolchain.setup(req, last_versions).await?)
     }
 
     async fn install_deps(
@@ -217,7 +223,7 @@ impl Platform for RustPlatform {
         runtime: &Runtime,
         working_dir: &Path,
     ) -> miette::Result<()> {
-        let tool = self.toolchain.get_for_version(runtime.version())?;
+        let tool = self.toolchain.get_for_version(&runtime.requirement)?;
 
         if find_cargo_lock(working_dir).is_none() {
             print_checkpoint("cargo generate-lockfile", Checkpoint::Setup);
@@ -466,10 +472,8 @@ impl Platform for RustPlatform {
             | "rustdoc" | "rustfmt" | "rustup" => {}
             // Handle toolchains for cargo commands
             "cargo" => {
-                let version = runtime.version();
-
-                if version.is_override() {
-                    args.push(format!("+{}", version.number));
+                if runtime.requirement.is_override() {
+                    args.push(format!("+{}", runtime.requirement));
                 }
             }
             // Binary may be installed to ~/.cargo/bin

crates/rust/tool/Cargo.toml

@@ -7,7 +7,7 @@ publish = false
 [dependencies]
 moon_config = { path = "../../../nextgen/config" }
 moon_logger = { path = "../../core/logger" }
-moon_platform_runtime = { path = "../../core/platform-runtime" }
+moon_platform_runtime2 = { path = "../../../nextgen/platform-runtime" }
 moon_process = { path = "../../../nextgen/process" }
 moon_terminal = { path = "../../core/terminal" }
 moon_tool = { path = "../../core/tool" }

crates/rust/tool/src/rust_tool.rs

@@ -1,6 +1,6 @@
 use moon_config::RustConfig;
 use moon_logger::debug;
-use moon_platform_runtime::Version;
+use moon_platform_runtime2::RuntimeReq;
 use moon_process::Command;
 use moon_terminal::{print_checkpoint, Checkpoint};
 use moon_tool::{async_trait, load_tool_plugin, Tool};
@@ -25,7 +25,7 @@ impl RustTool {
     pub async fn new(
         proto: &ProtoEnvironment,
         config: &RustConfig,
-        version: &Version,
+        req: &RuntimeReq,
     ) -> miette::Result<RustTool> {
         let mut rust = RustTool {
             config: config.to_owned(),
@@ -34,11 +34,11 @@ impl RustTool {
                 .await?,
         };
 
-        if version.is_global() {
+        if req.is_global() {
             rust.global = true;
             rust.config.version = None;
         } else {
-            rust.config.version = SemVersion::parse(&version.number).ok();
+            rust.config.version = req.to_version();
         };
 
         Ok(rust)