Add documentation.

Cargo.lock

@@ -166,7 +166,7 @@ dependencies = [
 
 [[package]]
 name = "core"
-version = "0.1.3"
+version = "0.1.4"
 dependencies = [
  "anyhow",
  "derive_more",
@@ -316,7 +316,7 @@ checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
 
 [[package]]
 name = "java"
-version = "0.2.1"
+version = "0.2.2"
 dependencies = [
  "bytesize",
  "derive_more",

crates/core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "core"
-version = "0.1.3"
+version = "0.1.4"
 edition.workspace = true
 license.workspace = true
 

crates/core/src/class.rs

@@ -1,35 +1,74 @@
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
+use java::{JAVA_EXT_CLASS, JAVA_EXT_SOURCE};
 use serde::{Deserialize, Serialize};
 
-/// Data struct
+use crate::{Error, Result};
+
+/// [`Class`] represents a source file. It is a handler.
 #[derive(Debug, Clone, Deserialize, Serialize, Hash, PartialEq, Eq, PartialOrd, Ord)]
 pub struct Class {
+    /// Path relative to PACKAGE/java, without file extension.
     pub path: PathBuf,
     pub checksum: String,
 }
 
 impl Class {
-    pub fn is_updated(&self) -> crate::Result<bool> {
+    /// Creates a new [`Class`].
-        // If the path is local and that file has not been updated.
+    ///
-        Ok(self.checksum == sha256::try_digest(self.path.clone())?)
+    /// # Error
+    ///
+    /// * [`Error::MismatchedPackage`] if the provided `file_path` is absolute, and cannot be
+    /// subtracted to just its relative path within its parent package.
+    /// * [`Error::Io`] if the source file cannot be loaded and digested.
+    pub fn new<P: AsRef<Path>>(package_src_root: P, file_path: P) -> Result<Self> {
+        let mut file_path = file_path.as_ref().to_path_buf();
+        if file_path.is_absolute() {
+            file_path = pathsub::sub_paths(file_path.as_path(), package_src_root.as_ref())
+                .ok_or(Error::MismatchedPackage)?;
         }
 
-    pub fn update(&mut self) -> crate::Result<()> {
+        Ok(Self {
-        self.checksum = sha256::try_digest(self.path.clone())?;
+            path: dbg!(file_path.with_extension("")),
+            checksum: sha256::try_digest(package_src_root.as_ref().join(file_path))?,
+        })
+    }
+
+    /// Returns a boolean representing if the class is up to date.
+    ///
+    /// # Criteria
+    ///
+    /// * The class path is local.
+    /// * The class has been compiled to `target/`
+    /// * The class' source file has not been updated.
+    ///
+    /// # Errors
+    ///
+    /// * [`Error::Io`]
+    pub fn is_updated<P: AsRef<Path>>(&self, class_path: P) -> Result<bool> {
+        // If the path is local and that file has not been updated.
+        Ok(class_path
+            .as_ref()
+            .join(self.path.as_path())
+            .with_extension(JAVA_EXT_CLASS)
+            .exists()
+            && self.checksum == sha256::try_digest(self.path.clone())?)
+    }
+
+    /// Updates the class' checksum.
+    ///
+    /// Only call this if you know that the class has been compiled successfully.
+    ///
+    /// # Errors
+    ///
+    /// * [`Error::Io`] if the source file cannot be loaded and digested.
+    pub fn update<P: AsRef<Path>>(&mut self, package_src_root: P) -> Result<()> {
+        self.checksum = sha256::try_digest(dbg!(
+            package_src_root
+                .as_ref()
+                .join(self.path.as_path())
+                .with_extension(JAVA_EXT_SOURCE),
+        ))?;
         Ok(())
     }
 }
-
-// TODO: Make it clearer that this is for general files,
-// not nests.
-impl TryFrom<PathBuf> for Class {
-    type Error = crate::Error;
-
-    fn try_from(value: PathBuf) -> Result<Self, Self::Error> {
-        Ok(Self {
-            path: value.clone(),
-            checksum: sha256::try_digest(value)?,
-        })
-    }
-}

crates/core/src/dependency.rs

@@ -1,6 +1,7 @@
 use semver::Version;
 use serde::{Deserialize, Serialize};
 
+use crate::Result;
 use crate::package::PackageHandler;
 
 /// Data struct
@@ -26,7 +27,7 @@ impl Dependency {
         return self.name.clone();
     }
 
-    pub fn is_updated(&self) -> crate::Result<bool> {
+    pub fn is_updated(&self) -> Result<bool> {
         // If the path is local and that file has not been updated.
         Ok(self.source.as_ref().is_some_and(|path| is_url(path))
             && self.checksum == sha256::try_digest(self.source.as_ref().unwrap())?)

crates/core/src/error.rs

@@ -4,6 +4,10 @@ pub type Result<T> = std::result::Result<T, Error>;
 
 #[derive(Debug, From, Display)]
 pub enum Error {
+    /// Attempted to replace a value in a hash collection,
+    /// but there was no prime present when one was expected.
+    AbsentPrimeHashingError,
+
     #[from]
     Io(std::io::Error),
 
@@ -12,6 +16,8 @@ pub enum Error {
 
     MissingFileName,
 
+    MismatchedPackage,
+
     #[from]
     TomlDeserialize(toml::de::Error),
 

crates/core/src/nest.rs

@@ -29,16 +29,16 @@ impl Nest {
         }
     }
 
-    pub fn write<P: AsRef<Path>>(&self, path: P) -> crate::Result<()> {
+    pub fn write<P: AsRef<Path>>(&self, project_root: P) -> crate::Result<()> {
-        let mut path = path.as_ref().to_path_buf();
+        let mut project_root = project_root.as_ref().to_path_buf();
-        if path.is_dir() {
+        if project_root.is_dir() {
-            path = path.join(F_NEST_TOML);
+            project_root = project_root.join(F_NEST_TOML);
         }
 
         Ok(OpenOptions::new()
             .write(true)
             .create(true)
-            .open(path)?
+            .open(project_root)?
             .write_all(toml::to_string_pretty(&self)?.as_bytes())?)
     }
 

crates/core/src/package.rs

@@ -1,30 +1,35 @@
 use std::hash::Hash;
 use std::path::{Path, PathBuf};
 
-use fs::expand_files;
 use serde::{Deserialize, Serialize};
 
 use crate::class::Class;
 use crate::prey::{F_PREY_LOCK, F_PREY_TOML, Prey, PreyLock};
 
+pub const DIR_JAVA: &str = "java/";
+
 /// Hashing is only based off the Prey.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct PackageHandler {
     prey: Prey,
-    prey_lock: Option<PreyLock>,
+    prey_lock: PreyLock,
+    /// Path relative to WORKSPACE/src
     package_root: PathBuf,
     target_dir: PathBuf,
 }
 
 impl PackageHandler {
-    const DIR_JAVA: &str = "java/";
-
     pub fn new<P: AsRef<Path>>(src_dir: P, package_root: P, target_dir: P) -> crate::Result<Self> {
         let package_root = src_dir.as_ref().join(package_root.as_ref());
+        let prey_lock = if let Ok(prey_lock) = PreyLock::try_from(package_root.join(F_PREY_LOCK)) {
+            prey_lock
+        } else {
+            PreyLock::new(package_root.clone(), package_root.join(DIR_JAVA))?
+        };
 
         Ok(Self {
             prey: Prey::try_from(package_root.join(F_PREY_TOML))?,
-            prey_lock: PreyLock::try_from(package_root.join(F_PREY_LOCK)).ok(),
+            prey_lock,
             package_root,
             target_dir: target_dir.as_ref().to_path_buf(),
         })
@@ -42,32 +47,26 @@ impl PackageHandler {
         self.prey.version()
     }
 
-    pub fn get_update_targets(&mut self) -> crate::Result<Vec<&Class>> {
+    pub fn prey_lock(&mut self) -> &mut PreyLock {
-        if self.prey_lock.is_none() {
+        &mut self.prey_lock
-            // Try to pass a reference to the class so that there's mutability of the object
-            // available at the workspace level instead of parsing all the way down the
-            // tree. How I do this, idk. My brain is friend from a few days of JS.
-
-            self.prey_lock = Some(PreyLock::from(expand_files(
-                self.package_root.join(Self::DIR_JAVA),
-            )?));
-            return Ok(self.prey_lock.as_ref().unwrap().classes.iter().collect());
     }
 
-        Ok(self
+    pub fn get_outdated<P: AsRef<Path>>(&self, class_path: P) -> Vec<Class> {
-            .prey_lock
+        self.prey_lock
-            .as_ref()
+            .clone()
-            .unwrap()
+            .classes()
-            .classes
             .iter()
-            .filter_map(|tracked| {
+            .filter(|class| {
-                if tracked.is_updated().is_ok_and(|v| v == true) {
+                class
-                    Some(tracked)
+                    .is_updated(class_path.as_ref())
-                } else {
+                    .is_ok_and(|b| b == false)
-                    None
-                }
             })
-            .collect())
+            .cloned()
+            .collect()
+    }
+
+    pub fn write_lock(&self) -> crate::Result<()> {
+        self.prey_lock.write(self.package_root.as_path())
     }
 }
 

crates/core/src/prey.rs

@@ -1,7 +1,9 @@
+use std::collections::HashSet;
 use std::fs::{File, OpenOptions};
-use std::io::Read;
+use std::io::{Read, Write};
 use std::path::{Path, PathBuf};
 
+use fs::expand_files;
 use serde::{Deserialize, Serialize};
 
 use crate::class::Class;
@@ -68,14 +70,54 @@ impl TryFrom<File> for Prey {
 /// Data struct
 #[derive(Debug, Clone, Default, Deserialize, Serialize, PartialEq, Eq)]
 pub struct PreyLock {
-    pub classes: Vec<Class>,
+    classes: HashSet<Class>,
 }
 
 impl PreyLock {
+    pub fn new<P: AsRef<Path>>(package_root: P, package_src_root: P) -> crate::Result<Self> {
+        Ok(Self::from_paths(
+            expand_files(package_root)?,
+            package_src_root,
+        ))
+    }
+
+    pub fn from_paths<P: AsRef<Path>>(paths: Vec<PathBuf>, package_src_root: P) -> Self {
+        let mut lock = Self::default();
+        lock.classes = paths
+            .iter()
+            .filter_map(|f| {
+                let dep = Class::new(package_src_root.as_ref().to_path_buf(), f.to_owned());
+                if dep.is_ok() {
+                    Some(dep.unwrap())
+                } else {
+                    None
+                }
+            })
+            .collect();
+        lock
+    }
+
+    pub fn write<P: AsRef<Path>>(&self, package_root: P) -> crate::Result<()> {
+        let mut package_root = package_root.as_ref().to_path_buf();
+        if package_root.is_dir() {
+            package_root = package_root.join(F_PREY_LOCK);
+        }
+
+        Ok(OpenOptions::new()
+            .write(true)
+            .create(true)
+            .open(package_root)?
+            .write_all(toml::to_string_pretty(&self)?.as_bytes())?)
+    }
+
     pub fn with_class(&mut self, class: Class) -> &mut Self {
-        self.classes.push(class);
+        self.classes.insert(class);
         self
     }
+
+    pub fn classes(&mut self) -> &mut HashSet<Class> {
+        &mut self.classes
+    }
 }
 
 /// Load the PreyLock from Prey.lock file.
@@ -97,21 +139,3 @@ impl TryFrom<File> for PreyLock {
         Ok(toml::from_str(buf.as_str())?)
     }
 }
-
-impl From<Vec<PathBuf>> for PreyLock {
-    fn from(value: Vec<PathBuf>) -> Self {
-        let mut lock = Self::default();
-        lock.classes = value
-            .iter()
-            .filter_map(|f| {
-                let dep = Class::try_from(f.to_owned());
-                if dep.is_ok() {
-                    Some(dep.unwrap())
-                } else {
-                    None
-                }
-            })
-            .collect();
-        lock
-    }
-}

crates/core/src/workspace.rs

@@ -9,11 +9,15 @@ use java::{JAVA_EXT_CLASS, JAVA_EXT_SOURCE};
 use serde::{Deserialize, Serialize};
 use subprocess::Exec;
 
-use crate::Error;
 use crate::nest::{F_NEST_LOCK, F_NEST_TOML, Nest, NestLock};
 use crate::package::PackageHandler;
-use crate::prey::{F_PREY_TOML, Prey};
+use crate::prey::{F_PREY_LOCK, F_PREY_TOML, Prey};
+use crate::{Error, package};
 
+/// Represents a raven workspace.
+///
+/// [`WorkspaceHandler`] manages project compilation, cache writing,
+/// and tracking of all packages that make up the workspace.
 #[derive(Debug)]
 pub struct WorkspaceHandler {
     nest: Nest,
@@ -26,6 +30,13 @@ impl WorkspaceHandler {
     const DIR_SRC: &str = "src/";
     const DIR_TARGET: &str = "target/";
 
+    /// Creates a new [`WorkspaceHandler`] instance at the provided path.
+    ///
+    /// # Errors
+    ///
+    /// * [`Error::Io`] if the `project_root` cannot be canonicalized.
+    /// * [`Error::MissingFileName`] if a name for the workspace cannot be derived
+    /// from the `project_root`
     pub fn new<P: AsRef<Path>>(project_root: P) -> crate::Result<Self> {
         let project_root = project_root.as_ref().canonicalize()?;
 
@@ -42,6 +53,14 @@ impl WorkspaceHandler {
         })
     }
 
+    /// Loads an existing workspace from the provided path.
+    ///
+    /// # Errors
+    ///
+    /// * [`Error::Io`] for any number of IO-related errors.
+    /// Unwrap the [`std::io::Error`] for further information.
+    /// * [`Error::MissingFileName`] if a name for the workspace cannot be derived
+    /// from the `project_root`
     pub fn load<P: AsRef<Path>>(project_root: P) -> crate::Result<Self> {
         let project_root = project_root.as_ref().canonicalize()?;
 
@@ -57,16 +76,39 @@ impl WorkspaceHandler {
         Ok(workspace_manager)
     }
 
-    pub fn write(&self) -> crate::Result<()> {
+    /// Writes all lock files (Nest.toml, src/**/Prey.toml) to the disk.
-        self.write_nest()?;
+    pub fn write_locks(&self) -> crate::Result<()> {
-
         if let Option::Some(lock) = self.nest_lock.clone() {
             lock.write(self.project_root.join(F_NEST_LOCK))?;
         }
 
+        for handler in self.packages.values() {
+            handler.write_lock()?;
+        }
+
         Ok(())
     }
 
+    /// Initializes a new workspace.
+    ///
+    /// # Behaviour
+    ///
+    /// Init will avoid overwriting or adding an example project if raven is being integrated into
+    /// an existing workspace codebase.
+    ///
+    /// Init will always write:
+    ///
+    /// * Nest.toml
+    /// * .java-version
+    /// * Attempt to append to .gitignore
+    ///
+    /// If this is an empty workspace, init will include:
+    ///
+    /// * Calling `git init`
+    /// * Writing an example project.
+    /// * Automatic package discovery.
+    ///
+    /// # Errors
     pub fn init(&mut self) -> crate::Result<&mut Self> {
         // ORDER MATTERS.
         let is_empty = read_dir(self.project_root.as_path()).is_ok_and(|tree| tree.count() == 0);
@@ -112,30 +154,69 @@ impl WorkspaceHandler {
         Ok(self)
     }
 
-    // This is the naive build
+    /// This is a naive build; it attempts to build every source file individually.
+    ///
+    /// It calls [`PackageHandler::get_outdated()`] on all known packages to determine
+    /// compile targets.
+    ///
+    /// It will then attempt to write all locks to update the caches and avoid attempting to
+    /// needlessly recompile targets.
+    ///
+    /// # Errors
+    ///
+    /// * [`Error::AbsentPrimeError`]
+    /// * [`Error::Io`]
     pub fn build(&mut self) -> crate::Result<&mut Self> {
-        let mut targets = vec![];
-
-        for handler in self.packages.values_mut() {
-            targets.append(&mut handler.get_update_targets()?);
-        }
-
         let compiler = java::compiler::CompilerBuilder::new()
             .class_path(Self::DIR_TARGET)
             .destination(Self::DIR_TARGET)
             .build();
 
-        for target in targets.iter() {
+        // No unintentional deep copying anywhere, right?
-            // Possibly come up with a source file handler for this?
+        // Probably not. We'll see.
-            if let Ok(_) = compiler.clone().compile(target.path.as_path()) {
+        for handler in self.packages.values_mut() {
-                // TODO: Prevent unnecessary recompile
+            let package_src_root = self
-                //target.update()?;
+                .project_root
+                .join(Self::DIR_SRC)
+                .join(handler.name())
+                .join(package::DIR_JAVA);
+            let targets = handler.get_outdated(self.project_root.join(Self::DIR_TARGET));
+
+            for mut target in targets {
+                dbg!(&target);
+                if let Ok(true) = compiler
+                    .clone()
+                    .compile(package_src_root.join(target.path.as_path()))
+                {
+                    target.update(package_src_root.as_path())?;
+                    handler
+                        .prey_lock()
+                        .classes()
+                        .replace(target)
+                        .ok_or(Error::AbsentPrimeHashingError)?;
                 }
             }
+        }
+
+        self.write_locks()?;
 
         Ok(self)
     }
 
+    /// Attempts to call the JVM to run, in order of precedence:
+    ///
+    /// 1. Provided entry point which includes a specific source file.
+    /// 2. Provided entry point to a package, using that package's default entry point
+    /// defined in it's `Prey.toml`
+    /// 3. The workspace's default package defined in `Nest.toml`, and that package's default
+    /// entry point as defined in it's `Prey.toml`.
+    ///
+    /// # Errors
+    ///
+    /// * [`Error::UnknownPackage`] if the package cannot be found.
+    /// * [`Error::UndefinedEntryPoint`] if no fallback entry point can be found.
+    /// * [`Error::Io`]
+    /// * [`Error::Java`]
     pub fn run<P: AsRef<Path>>(
         &mut self,
         entry_point: Option<P>,
@@ -171,17 +252,47 @@ impl WorkspaceHandler {
         Ok(self)
     }
 
+    /// Cleans the workspace of it's caches:
+    ///
+    /// * `target/`
+    /// * Nest.lock
+    /// * Prey.lock
     pub fn clean(&mut self) -> crate::Result<&mut Self> {
+        // Clear Nest.lock
         if let Err(err) = std::fs::remove_file(self.project_root.join(F_NEST_LOCK)) {
             if err.kind() != std::io::ErrorKind::NotFound {
                 return Err(Error::from(err));
             }
         }
+
+        // Clear src/**/Prey.lock
+        for handler in self.packages.values() {
+            if let Err(err) = std::fs::remove_file(
+                self.project_root
+                    .join(Self::DIR_SRC)
+                    .join(handler.name())
+                    .join(F_PREY_LOCK),
+            ) {
+                if err.kind() != std::io::ErrorKind::NotFound {
+                    return Err(Error::from(err));
+                }
+            }
+        }
+
+        // Clear target/
         let _ = std::fs::remove_dir_all(Self::DIR_TARGET);
+
         Ok(self)
     }
 
-    /// Add any newly created packages.
+    /// Scan for newly created packages, wrapping them in [`PackageHandler`]s
+    /// and adding them to the [`WorkspaceHandler`]'s package map.
+    ///
+    /// Packages are identified by their `Prey.toml` manifests.
+    ///
+    /// # Errors
+    ///
+    /// * [`Error::Io`]
     fn discover_packages(&mut self) -> crate::Result<()> {
         // Scan the src/ directory for entries,
         // filter out the files,
@@ -246,22 +357,31 @@ impl WorkspaceHandler {
         Ok(())
     }
 
+    /// Writes the [`WorkspaceHandler`]'s `Nest.toml` to disk.
     fn write_nest(&self) -> crate::Result<()> {
         Ok(self.nest.write(self.project_root.clone())?)
     }
 
+    /// Writes a `.java-version` file for `jenv` to the disk with an automatically parsed
+    /// java version from [`java::get_javac_version()`].
+    ///
+    /// # Errors
+    ///
+    /// * [`Error::Io`]
+    /// * [`Error::Java`]
     fn write_java_version(&self) -> crate::Result<()> {
         if let Result::Ok(mut f) = OpenOptions::new()
             .write(true)
             .create_new(true)
             .open(java::F_JAVA_VERSION)
         {
-            f.write_all(format!("{}\n", java::get_javac_ver()?.major.to_string()).as_bytes())?;
+            f.write_all(format!("{}\n", java::get_javac_version()?.major.to_string()).as_bytes())?;
         }
 
         Ok(())
     }
 
+    /// Writes an example project tree to disk.
     fn write_dir_tree(&self) -> std::io::Result<()> {
         for dir in [
             format!("{}main/java", Self::DIR_SRC),
@@ -274,6 +394,7 @@ impl WorkspaceHandler {
         Ok(())
     }
 
+    /// Writes an example project to disk.
     fn write_example_project(&self) -> crate::Result<()> {
         let main: PathBuf = PathBuf::from(Self::DIR_SRC).join("main/");
         let test: PathBuf = PathBuf::from(Self::DIR_SRC).join("test/");

crates/java/Cargo.toml

@@ -3,7 +3,7 @@
 
 [package]
 name = "java"
-version = "0.2.1"
+version = "0.2.2"
 edition.workspace = true
 license.workspace = true
 

crates/java/src/compiler.rs

@@ -1,9 +1,11 @@
+use std::fmt::Display;
 use std::path::{Path, PathBuf};
 
 use subprocess::Exec;
 use subprocess::Redirection;
 
 use crate::JAVA_BIN_COMPILER;
+use crate::JAVA_EXT_SOURCE;
 use crate::Result;
 
 #[derive(Debug, Default, Clone)]
@@ -48,26 +50,6 @@ pub struct Compiler {
 }
 
 impl Compiler {
-    /*
-    pub fn compile<P: AsRef<Path>>(self, path: P) -> Result<(Option<String>, Option<String>)> {
-        let mut cmd: Vec<String> = vec![JAVA_BIN_COMPILER.to_string()];
-
-        cmd.extend(
-            self.flags
-                .clone()
-                .into_iter()
-                .flat_map(|f| Into::<Vec<String>>::into(f)),
-        );
-        cmd.extend(
-            fs::expand_files(path)?
-                .into_iter()
-                .filter_map(|f| Some(f.to_str()?.to_string())),
-        );
-
-        Ok(io::run_process(cmd.as_slice())?)
-    }
-    */
-
     pub fn compile<P: AsRef<Path>>(self, path: P) -> Result<bool> {
         Ok(Exec::cmd(JAVA_BIN_COMPILER)
             .args(
@@ -76,7 +58,7 @@ impl Compiler {
                     .into_iter()
                     .flat_map(|f| Into::<Vec<String>>::into(f)),
             )
-            .arg(path.as_ref())
+            .arg(path.as_ref().with_extension(JAVA_EXT_SOURCE))
             .stdout(Redirection::Pipe)
             .detached()
             .start()?
@@ -89,6 +71,7 @@ impl Compiler {
 pub enum CompilerFlag {
     Classpath { path: PathBuf },
     Destination { path: PathBuf },
+    Version,
 }
 
 impl Into<Vec<String>> for CompilerFlag {
@@ -96,6 +79,18 @@ impl Into<Vec<String>> for CompilerFlag {
         match self {
             Self::Classpath { path } => vec!["-classpath".to_string(), path.display().to_string()],
             Self::Destination { path } => vec!["-d".to_string(), path.display().to_string()],
+            Self::Version => vec!["--version".to_string()],
+        }
+    }
+}
+
+// TODO: Clean this up a bit?
+impl Display for CompilerFlag {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Classpath { path } => write!(f, "-classpath {}", path.display()),
+            Self::Destination { path } => write!(f, "-d {}", path.display()),
+            Self::Version => write!(f, "--version"),
         }
     }
 }

crates/java/src/lib.rs

@@ -8,6 +8,8 @@ pub use error::{Error, Result};
 use runtime::VMFlag;
 use subprocess::Exec;
 
+use crate::compiler::CompilerFlag;
+
 pub const JAVA_BIN_VM: &str = "java";
 pub const JAVA_BIN_COMPILER: &str = "javac";
 
@@ -16,24 +18,22 @@ pub const JAVA_EXT_CLASS: &str = "class";
 
 pub const F_JAVA_VERSION: &str = ".java-version";
 
-/// Uses the java binary to parse its stdout for version information.
+/// Uses the javac binary to get information about the install compiler.
-///
+pub fn get_javac_version() -> Result<semver::Version> {
-/// This is non-caching.
+    // Try to pull from javac first.
-pub fn get_javac_ver() -> Result<semver::Version> {
+    if let Ok(version) = semver::Version::from_str(
-    // TODO: Consider making this pull the version info from javac instead?
+        Exec::cmd(JAVA_BIN_COMPILER)
-
+            .arg(CompilerFlag::Version.to_string())
-    /*
+            .capture()?
-     * $ java --version
+            .stdout_str()
-     *      openjdk 21.0.9 2025-10-21
+            .replace("javac", "")
-     *      OpenJDK Runtime Environment (build 21.0.9+10)
+            .trim(),
-     *      OpenJDK 64-Bit Server VM (build 21.0.9+10, mixed mode, sharing)
+    ) {
-     */
+        return Ok(version);
+    }
 
     Ok(semver::Version::from_str(
         get_java_version_info()?
-            .lines()
-            .nth(0)
-            .ok_or(Error::EmptyStdout)?
             .split_ascii_whitespace()
             .nth(1)
             .ok_or(Error::NthOutOfBounds)?,
@@ -42,8 +42,14 @@ pub fn get_javac_ver() -> Result<semver::Version> {
 
 /// Calls the java binary, returning the complete stdout version information.
 fn get_java_version_info() -> Result<String> {
+    /*
+     * $ java --version
+     *      openjdk 21.0.9 2025-10-21
+     *      OpenJDK Runtime Environment (build 21.0.9+10)
+     *      OpenJDK 64-Bit Server VM (build 21.0.9+10, mixed mode, sharing)
+     */
     Ok(Exec::cmd(JAVA_BIN_VM)
-        .arg(VMFlag::Version.to_string().as_str())
+        .arg(VMFlag::Version.to_string())
         .capture()?
         .stdout_str())
 }

crates/raven/src/main.rs

@@ -5,6 +5,11 @@ use cli::{CLI_ARGS, Command};
 
 fn main() -> anyhow::Result<()> {
     // type_ is yet unused.
+
+    // `raven new` requires special behaviour.
+    // This will call the "new" part of the command,
+    // changing the cwd, before calling WorkspaceHandler.init()
+    // on the actual workspace directory.
     if let Command::New { project_name, .. } = &CLI_ARGS.command {
         new(project_name.to_owned())?;
     }
@@ -35,7 +40,10 @@ fn main() -> anyhow::Result<()> {
     Ok(())
 }
 
+/// Creates a new project directory and enters it.
 fn new(project_name: String) -> anyhow::Result<()> {
+    // Because this messes around with the CWD, this should live external to any
+    // instance of a `WorkspaceHandler`.
     let cwd = std::env::current_dir()?.join(project_name);
 
     std::fs::create_dir(&cwd)?;