Move to multi crates project

Starting impl devcontainer spec

crates/devcontainer-rs/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "devcontainer-rs"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+tokio = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+anyhow = { workspace = true }
+thiserror = { workspace = true }
+
+[dev-dependencies]
+tempfile = "3"

crates/devcontainer-rs/src/lib.rs

@@ -0,0 +1,175 @@
+use std::{
+    collections::HashMap,
+    path::{Path, PathBuf},
+};
+
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize)]
+pub struct DevContainerBuildSchema {
+    #[serde(default)]
+    pub dockerfile: Option<String>,
+    #[serde(default)]
+    pub args: HashMap<String, String>,
+}
+
+#[derive(Debug, Deserialize)]
+pub struct DevContainerSchema {
+    #[serde(default)]
+    pub name: Option<String>,
+    pub build: DevContainerBuildSchema,
+
+    #[serde(rename = "workspaceFolder", default)]
+    pub workspace_folder: Option<String>,
+
+    #[serde(rename = "containerEnv", default)]
+    pub container_env: HashMap<String, String>,
+
+    #[serde(rename = "postCreateCommand", default)]
+    pub post_create_command: Option<String>,
+
+    #[serde(rename = "postStartCommand", default)]
+    pub post_start_command: Option<String>,
+}
+
+#[derive(Debug)]
+pub struct DevContainer {
+    /// Absolute or relative path to the Dockerfile/Containerfile to build.
+    pub container_file_path: PathBuf,
+    pub name: Option<String>,
+    pub build_args: HashMap<String, String>,
+    pub container_env: HashMap<String, String>,
+    pub workspace_folder: Option<String>,
+    pub post_create_command: Option<String>,
+    pub post_start_command: Option<String>,
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum ParseError {
+    #[error("failed to read devcontainer file `{path}`: {source}")]
+    Read {
+        path: PathBuf,
+        source: std::io::Error,
+    },
+
+    #[error("invalid devcontainer JSON in `{path}`: {source}")]
+    Json {
+        path: PathBuf,
+        source: serde_json::Error,
+    },
+
+    #[error("container file `{0}` does not exist or is not a regular file")]
+    ContainerFileNotFound(PathBuf),
+
+    #[error("the devcontainer file path has no parent directory: `{0}`")]
+    InvalidDevContainerPath(PathBuf),
+}
+
+impl TryFrom<(DevContainerSchema, PathBuf)> for DevContainer {
+    type Error = ParseError;
+
+    fn try_from((schema, devcontainer_path): (DevContainerSchema, PathBuf)) -> Result<Self, Self::Error> {
+        let base_dir = devcontainer_path
+            .parent()
+            .ok_or_else(|| ParseError::InvalidDevContainerPath(devcontainer_path.clone()))?;
+
+        let container_file_path = match schema.build.dockerfile.as_deref() {
+            Some(file) => base_dir.join(file),
+            None => first_existing_container_file(base_dir),
+        };
+
+        if !container_file_path.is_file() {
+            return Err(ParseError::ContainerFileNotFound(container_file_path));
+        }
+
+        Ok(Self {
+            container_file_path,
+            name: schema.name,
+            build_args: schema.build.args,
+            container_env: schema.container_env,
+            workspace_folder: schema.workspace_folder,
+            post_create_command: schema.post_create_command,
+            post_start_command: schema.post_start_command,
+        })
+    }
+}
+
+fn first_existing_container_file(base_dir: &Path) -> PathBuf {
+    ["Dockerfile", "Containerfile"]
+        .iter()
+        .map(|filename| base_dir.join(filename))
+        .find(|path| path.is_file())
+        .unwrap_or_else(|| base_dir.join("Dockerfile"))
+}
+
+pub async fn parse(path: impl AsRef<Path>) -> Result<DevContainer, ParseError> {
+    let path = path.as_ref().to_path_buf();
+    let contents = tokio::fs::read_to_string(&path)
+        .await
+        .map_err(|source| ParseError::Read {
+            path: path.clone(),
+            source,
+        })?;
+
+    let schema = serde_json::from_str::<DevContainerSchema>(&contents).map_err(|source| {
+        ParseError::Json {
+            path: path.clone(),
+            source,
+        }
+    })?;
+
+    DevContainer::try_from((schema, path))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+
+    #[test]
+    fn resolves_configured_containerfile_relative_to_devcontainer_file() {
+        let dir = tempfile::tempdir().unwrap();
+        let devcontainer_path = dir.path().join("devcontainer.json");
+        let containerfile_path = dir.path().join("Containerfile");
+        fs::write(&containerfile_path, "FROM alpine\n").unwrap();
+
+        let schema = DevContainerSchema {
+            name: Some("test".into()),
+            build: DevContainerBuildSchema {
+                dockerfile: Some("Containerfile".into()),
+                args: HashMap::new(),
+            },
+            workspace_folder: None,
+            container_env: HashMap::new(),
+            post_create_command: None,
+            post_start_command: None,
+        };
+
+        let config = DevContainer::try_from((schema, devcontainer_path)).unwrap();
+        assert_eq!(config.container_file_path, containerfile_path);
+    }
+
+    #[test]
+    fn falls_back_to_dockerfile_before_containerfile() {
+        let dir = tempfile::tempdir().unwrap();
+        let devcontainer_path = dir.path().join("devcontainer.json");
+        let dockerfile_path = dir.path().join("Dockerfile");
+        fs::write(&dockerfile_path, "FROM alpine\n").unwrap();
+        fs::write(dir.path().join("Containerfile"), "FROM busybox\n").unwrap();
+
+        let schema = DevContainerSchema {
+            name: None,
+            build: DevContainerBuildSchema {
+                dockerfile: None,
+                args: HashMap::new(),
+            },
+            workspace_folder: None,
+            container_env: HashMap::new(),
+            post_create_command: None,
+            post_start_command: None,
+        };
+
+        let config = DevContainer::try_from((schema, devcontainer_path)).unwrap();
+        assert_eq!(config.container_file_path, dockerfile_path);
+    }
+}