Support apple's container for docker lang

Author: branchv

crates/prek/src/languages/docker.rs

@@ -111,6 +111,7 @@ fn container_id_from_cgroup_v2(mount_info: impl AsRef<Path>) -> Result<String> {
 #[derive(Debug, Copy, Clone, PartialEq, Eq)]
 enum RuntimeKind {
     Auto,
+    AppleContainer,
     Docker,
     Podman,
 }
@@ -120,6 +121,7 @@ impl FromStr for RuntimeKind {
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s.to_ascii_lowercase().as_str() {
+            "container" => Ok(RuntimeKind::AppleContainer),
             "docker" => Ok(RuntimeKind::Docker),
             "podman" => Ok(RuntimeKind::Podman),
             "auto" => Ok(RuntimeKind::Auto),
@@ -139,6 +141,7 @@ struct Mount {
 impl RuntimeKind {
     fn cmd(&self) -> &str {
         match self {
+            RuntimeKind::AppleContainer => "container",
             RuntimeKind::Docker => "docker",
             RuntimeKind::Podman => "podman",
             RuntimeKind::Auto => unreachable!("Auto should be resolved before use"),
@@ -148,6 +151,7 @@ impl RuntimeKind {
     /// Detect if the current runtime is rootless.
     fn detect_rootless(self) -> Result<bool> {
         match self {
+            RuntimeKind::AppleContainer => Ok(false),
             RuntimeKind::Docker => {
                 let output = Command::new(self.cmd())
                     .arg("info")
@@ -206,14 +210,16 @@ struct ContainerRuntimeInfo {
 impl ContainerRuntimeInfo {
     /// Detect container runtime provider, prioritise docker over podman if
     /// both are on the path, unless `PREK_CONTAINER_RUNTIME` is set to override detection.
-    fn resolve_runtime_kind<DF, PF>(
+    fn resolve_runtime_kind<DF, PF, CF>(
         env_override: Option<String>,
         docker_available: DF,
         podman_available: PF,
+        apple_container_available: CF,
     ) -> RuntimeKind
     where
         DF: Fn() -> bool,
         PF: Fn() -> bool,
+        CF: Fn() -> bool,
     {
         if let Some(val) = env_override {
             match RuntimeKind::from_str(&val) {
@@ -243,6 +249,9 @@ impl ContainerRuntimeInfo {
         if podman_available() {
             return RuntimeKind::Podman;
         }
+        if apple_container_available() {
+            return RuntimeKind::AppleContainer;
+        }
 
         debug!("No container runtime found on PATH, defaulting to docker");
         RuntimeKind::Docker
@@ -253,6 +262,7 @@ impl ContainerRuntimeInfo {
             EnvVars::var(EnvVars::PREK_CONTAINER_RUNTIME).ok(),
             || which::which("docker").is_ok(),
             || which::which("podman").is_ok(),
+            || which::which("container").is_ok(),
         );
         let rootless = runtime.detect_rootless().unwrap_or_else(|e| {
             warn!("Failed to detect if container runtime is rootless: {e}, defaulting to rootful");
@@ -283,6 +293,10 @@ impl ContainerRuntimeInfo {
         self.runtime == RuntimeKind::Podman
     }
 
+    fn is_apple_container(&self) -> bool {
+        self.runtime == RuntimeKind::AppleContainer
+    }
+
     /// Get the path of the current directory in the host.
     fn map_to_host_path<'a>(&self, path: &'a Path) -> Cow<'a, Path> {
         for mount in &self.mounts {
@@ -387,14 +401,21 @@ impl Docker {
         }
 
         let work_dir = CONTAINER_RUNTIME.map_to_host_path(work_dir);
+        let z = if CONTAINER_RUNTIME.is_apple_container() {
+            "" // Not currently supported
+        } else {
+            ",Z"
+        };
+        if !CONTAINER_RUNTIME.is_apple_container() {
+            // Run an init inside the container that forwards signals and reaps processes
+            command.arg("--init");
+        }
         command
-            // https://docs.docker.com/engine/reference/commandline/run/#mount-volumes-from-container-volumes-from
+            // https://docs.docker.com/reference/cli/docker/container/run/#volumes-from
             // The `Z` option tells Docker to label the content with a private
             // unshared label. Only the current container can use a private volume.
             .arg("--volume")
-            .arg(format!("{}:/src:rw,Z", work_dir.display()))
-            // Run an init inside the container that forwards signals and reaps processes
-            .arg("--init")
+            .arg(format!("{}:/src:rw{}", work_dir.display(), z))
             .arg("--workdir")
             .arg("/src");
 
@@ -673,52 +694,72 @@ mod tests {
             env_override: Option<&str>,
             docker_available: bool,
             podman_available: bool,
+            apple_container_available: bool,
         ) -> RuntimeKind {
             ContainerRuntimeInfo::resolve_runtime_kind(
                 env_override.map(ToString::to_string),
                 || docker_available,
                 || podman_available,
+                || apple_container_available,
             )
         }
 
-        assert_eq!(runtime_with(None, true, false), RuntimeKind::Docker);
-        assert_eq!(runtime_with(None, false, true), RuntimeKind::Podman);
-        assert_eq!(runtime_with(None, false, false), RuntimeKind::Docker);
+        assert_eq!(runtime_with(None, true, false, false), RuntimeKind::Docker);
+        assert_eq!(runtime_with(None, false, true, false), RuntimeKind::Podman);
+        assert_eq!(
+            runtime_with(None, false, false, true),
+            RuntimeKind::AppleContainer
+        );
+        assert_eq!(runtime_with(None, false, false, false), RuntimeKind::Docker);
 
-        assert_eq!(runtime_with(Some("auto"), true, false), RuntimeKind::Docker);
-        assert_eq!(runtime_with(Some("auto"), false, true), RuntimeKind::Podman);
         assert_eq!(
-            runtime_with(Some("auto"), false, false),
+            runtime_with(Some("auto"), true, false, false),
+            RuntimeKind::Docker
+        );
+        assert_eq!(
+            runtime_with(Some("auto"), false, true, false),
+            RuntimeKind::Podman
+        );
+        assert_eq!(
+            runtime_with(Some("auto"), false, false, true),
+            RuntimeKind::AppleContainer
+        );
+        assert_eq!(
+            runtime_with(Some("auto"), false, false, false),
             RuntimeKind::Docker
         );
 
         assert_eq!(
-            runtime_with(Some("docker"), true, false),
+            runtime_with(Some("docker"), true, false, false),
             RuntimeKind::Docker
         );
         assert_eq!(
-            runtime_with(Some("docker"), false, true),
+            runtime_with(Some("docker"), false, true, false),
             RuntimeKind::Docker
         );
         assert_eq!(
-            runtime_with(Some("DOCKER"), false, false),
+            runtime_with(Some("DOCKER"), false, false, false),
             RuntimeKind::Docker
         );
         assert_eq!(
-            runtime_with(Some("podman"), true, false),
+            runtime_with(Some("podman"), true, false, false),
             RuntimeKind::Podman
         );
         assert_eq!(
-            runtime_with(Some("podman"), false, true),
+            runtime_with(Some("podman"), false, true, false),
             RuntimeKind::Podman
         );
         assert_eq!(
-            runtime_with(Some("podman"), false, false),
+            runtime_with(Some("podman"), false, false, false),
             RuntimeKind::Podman
         );
+        assert_eq!(
+            runtime_with(Some("container"), true, true, false),
+            RuntimeKind::AppleContainer
+        );
 
         assert_eq!(
-            runtime_with(Some("invalid"), false, false),
+            runtime_with(Some("invalid"), false, false, false),
             RuntimeKind::Docker
         );
     }

docs/configuration.md

@@ -221,6 +221,7 @@ Prek supports the following environment variables:
     - `auto` (default, auto-detect available runtime)
     - `docker`
     - `podman`
+    - `container`
 
 Compatibility fallbacks:
 

docs/diff.md

@@ -78,7 +78,7 @@ Gems specified in hook gemspec files and `additional_dependencies` will be insta
 
 ### Docker & Docker Image
 
-`prek` auto-detects the available container runtime on the system (Docker or Podman) and uses it to run container-based hooks. You can also explicitly specify the container runtime using the `PREK_CONTAINER_RUNTIME` environment variable.
+`prek` auto-detects the available container runtime on the system (Docker, Podman, or Container) and uses it to run container-based hooks. You can also explicitly specify the container runtime using the `PREK_CONTAINER_RUNTIME` environment variable.
 
 ## Command line interface