Bump java crate version.

Cargo.lock

@@ -144,7 +144,7 @@ checksum = "c3e64b0cc0439b12df2fa678eae89a1c56a529fd067a9115f7827f1fffd22b32"
 
 [[package]]
 name = "cli"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "clap",
 ]
@@ -166,7 +166,7 @@ dependencies = [
 
 [[package]]
 name = "core"
-version = "0.1.0"
+version = "0.1.1"
 dependencies = [
  "anyhow",
  "derive_more",
@@ -316,7 +316,7 @@ checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
 
 [[package]]
 name = "java"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
  "bytesize",
  "derive_more",

crates/cli/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "cli"
-version = "0.2.0"
+version = "0.2.1"
 edition.workspace = true
 license.workspace = true
 

crates/cli/src/lib.rs

@@ -6,8 +6,7 @@ use clap::{ArgAction, Args, Parser, Subcommand, ValueEnum};
 pub static CLI_ARGS: LazyLock<CliArgs> = LazyLock::new(|| CliArgs::parse());
 
 #[derive(Debug, Parser)]
-#[clap(author, version)]
-#[command(help_template = "{author-section}\n{usage-heading} {usage}\n\n{all-args}")]
+#[clap(name = "Raven", version = "0.2.0")]
 pub struct CliArgs {
     #[command(subcommand)]
     pub command: Command,

crates/core/Cargo.toml

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

crates/core/src/prey.rs

@@ -1,6 +1,6 @@
 use std::fs::{File, OpenOptions};
 use std::io::Read;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 
 use serde::{Deserialize, Serialize};
 
@@ -28,6 +28,11 @@ impl Prey {
         }
     }
 
+    pub fn with_entry_point<P: AsRef<Path>>(&mut self, entry_point: P) -> &mut Self {
+        self.package.entry_point = entry_point.as_ref().to_path_buf();
+        self
+    }
+
     pub fn entry_point(&self) -> PathBuf {
         self.package.entry_point.clone()
     }

crates/core/src/workspace.rs

@@ -67,32 +67,10 @@ impl WorkspaceHandler {
         Ok(())
     }
 
-    /*
-    /// Future `build` method.
-    pub fn compile(&self, target: Option<PathBuf>) -> crate::Result<()> {
-        let mut target = target.unwrap_or(self.nest.default_package());
-        if !target.is_file() {
-            // Use is_file to skip messing with pathing for src/
-            // If target is not a file (explicit entry point), check if it's a known package
-            // and use that's package's default entry point.
-            target = target.join(
-                self.packages
-                    .get(&target)
-                    .ok_or(Error::UnknownPackage)?
-                    .entry_point(),
-            );
-        }
-
-        //java::Compiler::new();
-
-        Ok(())
-    }
-    */
-
     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);
 
-        // ORDER MATTERS. THIS MUST COME FIRST.
         // Make config file.
         self.write_nest()?;
 
@@ -150,7 +128,7 @@ impl WorkspaceHandler {
         for target in targets.iter() {
             // Possibly come up with a source file handler for this?
             if let Ok(_) = compiler.clone().compile(target.path.as_path()) {
-                // No, this does not run O(1)
+                // TODO: Prevent unnecessary recompile
                 //target.update()?;
             }
         }
@@ -173,17 +151,13 @@ impl WorkspaceHandler {
             // Use is_file to skip messing with pathing for src/
             // If target is not a file (explicit entry point), check if it's a known package
             // and use that's package's default entry point.
-            entry_point = entry_point.join(
-                self.packages
-                    .get(&entry_point)
-                    .ok_or(Error::UnknownPackage)?
-                    .entry_point(),
-            );
+            entry_point = self
+                .packages
+                .get(&entry_point)
+                .ok_or(Error::UnknownPackage)?
+                .entry_point();
         }
 
-        // JRE pathing will be messed up without this.
-        std::env::set_current_dir(Self::DIR_TARGET)?;
-
         java::runtime::JVMBuilder::new(Self::DIR_TARGET)
             .assertions(assertions)
             .monitor(true)
@@ -305,7 +279,9 @@ impl WorkspaceHandler {
             .create_new(true)
             .open(main.join(F_PREY_TOML))
         {
-            f.write_all(toml::to_string_pretty(&Prey::new("main"))?.as_bytes())?;
+            f.write_all(
+                toml::to_string_pretty(&Prey::new("main").with_entry_point("Main"))?.as_bytes(),
+            )?;
         }
 
         // Make src/main/Main.java
@@ -323,7 +299,9 @@ impl WorkspaceHandler {
             .create_new(true)
             .open(test.join(F_PREY_TOML))
         {
-            f.write_all(toml::to_string_pretty(&Prey::new("test"))?.as_bytes())?;
+            f.write_all(
+                toml::to_string_pretty(&Prey::new("test").with_entry_point("MainTest"))?.as_bytes(),
+            )?;
         }
 
         // Make src/test/MainTest.java

crates/java/Cargo.toml

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

retired/nest_lib_rs_old/class.rs

@@ -1,114 +0,0 @@
-use std::hash::{self, Hash};
-use std::path::{Path, PathBuf};
-use std::sync::{Arc, Mutex};
-
-use crate::{Error, Result};
-
-use java::{JAVA_EXT_CLASS, JAVA_EXT_SOURCE};
-use path::PathHandler;
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct Class {
-    #[serde(skip_deserializing, skip_serializing)]
-    ph: Option<Arc<Mutex<PathHandler>>>,
-    path: PathBuf,
-    checksum: String,
-}
-
-impl Class {
-    pub fn new<P: AsRef<Path>>(ph: Arc<Mutex<PathHandler>>, path: P, checksum: String) -> Self {
-        Self {
-            ph: Some(ph),
-            path: path.as_ref().to_path_buf(),
-            checksum,
-        }
-    }
-
-    pub fn from_file<P: AsRef<Path>>(ph: Arc<Mutex<PathHandler>>, path: P) -> Result<Self> {
-        let mut path = path.as_ref().to_path_buf();
-        if path.is_relative() {
-            path = path.canonicalize()?;
-        }
-
-        let dir_src = ph.try_lock()?.dir_src();
-
-        Ok(Self {
-            ph: Some(ph),
-            path: PathBuf::from(
-                pathsub::sub_paths(path.as_path(), dir_src.as_path()).ok_or(Error::PathSub)?,
-            )
-            .with_extension(""),
-            checksum: sha256::try_digest(&path)?,
-        })
-    }
-
-    pub fn path(&self) -> PathBuf {
-        self.path.clone()
-    }
-
-    pub fn checksum(&self) -> String {
-        self.checksum.clone()
-    }
-
-    /// Returns the path such that src/ and target/ don't matter.
-    /// E.g., `main/Main.java` as_subpath is `Main.java`
-    /// allowing it to match with `target/main/Main.class`
-    /// because Java diregards the top level subdir in `src/`
-    fn subpath(&self) -> PathBuf {
-        let mut p = self.path.components();
-        p.next(); // Remove the top level dir.
-        p.as_path().to_path_buf()
-    }
-
-    /// Returns true if the class needs updating.
-    /// This may also cautionarily return true if it cannot digest the file.
-    pub fn is_updated(&mut self) -> Result<bool> {
-        // Still doesn't handle inter-dependency checks.
-        // Hopefully then I'll clean this horror up.
-        let mut ph = self
-            .ph
-            .as_ref()
-            .ok_or(Error::MissingPathHandler)?
-            .try_lock()?;
-
-        Ok(ph
-            .dir_target()
-            .join(self.subpath())
-            .with_extension(JAVA_EXT_CLASS)
-            .exists()
-            && sha256::try_digest(
-                ph.dir_src()
-                    .join(self.path())
-                    .with_extension(JAVA_EXT_SOURCE),
-            )
-            .is_ok_and(|hash| self.checksum == hash))
-    }
-
-    pub fn set_path_handler(&mut self, ph: Arc<Mutex<PathHandler>>) {
-        self.ph = Some(ph);
-    }
-
-    pub fn with_path_handler(&mut self, ph: Arc<Mutex<PathHandler>>) -> &mut Self {
-        self.ph = Some(ph);
-        self
-    }
-}
-
-impl Hash for Class {
-    fn hash<H: hash::Hasher>(&self, state: &mut H) {
-        self.path.hash(state);
-    }
-}
-
-impl PartialEq for Class {
-    fn eq(&self, other: &Self) -> bool {
-        self.path == other.path
-    }
-
-    fn ne(&self, other: &Self) -> bool {
-        self.path != other.path
-    }
-}
-
-impl Eq for Class {}

retired/nest_lib_rs_old/dependency.rs

@@ -1,7 +0,0 @@
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Hash, Default, Clone, Deserialize, Serialize, PartialEq, Eq)]
-pub struct Dependency {
-    name: String,
-    version: String,
-}

retired/nest_lib_rs_old/error.rs

@@ -1,35 +0,0 @@
-use std::sync::{MutexGuard, PoisonError, TryLockError};
-
-use derive_more::{Display, From};
-use path::PathHandler;
-
-pub type Result<T> = core::result::Result<T, Error>;
-
-#[derive(Debug, From, Display)]
-pub enum Error {
-    #[from]
-    Io(std::io::Error),
-
-    MutexLock(String),
-
-    MutexTryLock(String),
-
-    PathSub,
-
-    #[from]
-    Toml(toml::de::Error),
-
-    MissingPathHandler,
-}
-
-impl From<PoisonError<MutexGuard<'_, PathHandler>>> for Error {
-    fn from(value: PoisonError<MutexGuard<PathHandler>>) -> Self {
-        Self::MutexLock(value.to_string())
-    }
-}
-
-impl From<TryLockError<MutexGuard<'_, PathHandler>>> for Error {
-    fn from(value: TryLockError<MutexGuard<PathHandler>>) -> Self {
-        Self::MutexTryLock(value.to_string())
-    }
-}

retired/nest_lib_rs_old/lib.rs

@@ -1,45 +0,0 @@
-mod class;
-mod dependency;
-mod error;
-//mod lock;
-mod meta;
-mod nest;
-mod package;
-pub mod prelude;
-mod prey;
-mod workspace;
-
-pub use error::{Error, Result};
-
-use std::io;
-use std::path::PathBuf;
-
-pub const FN_NEST: &str = "Nest";
-pub const FN_PREY: &str = "Prey";
-
-pub const F_NEST_TOML: &str = const_format::concatcp!(FN_NEST, fs::EXT_TOML);
-pub const F_NEST_LOCK: &str = const_format::concatcp!(FN_NEST, fs::EXT_LOCK);
-pub const F_PREY_TOML: &str = const_format::concatcp!(FN_PREY, fs::EXT_TOML);
-pub const F_PREY_LOCK: &str = const_format::concatcp!(FN_PREY, fs::EXT_LOCK);
-
-/// Return the location of the parent `Nest.toml` as [`PathBuf`]
-///
-/// # Errors
-///
-/// Possible cases:
-///
-/// * `Nest.toml` cannot be located.
-/// * Current working directory does not exist.
-/// * There are insufficient permissions to access the current directory.
-pub fn locate_nest() -> io::Result<PathBuf> {
-    let cwd = std::env::current_dir()?;
-    let mut probe = cwd.clone();
-
-    while !probe.join(F_NEST_TOML).exists() {
-        if !probe.pop() {
-            return Err(io::ErrorKind::NotFound.into());
-        }
-    }
-
-    Ok(probe)
-}

retired/nest_lib_rs_old/lock.rs

@@ -1,99 +0,0 @@
-use std::collections::HashSet;
-use std::collections::hash_set::Iter;
-use std::fs::OpenOptions;
-use std::hash::Hash;
-use std::io::Read;
-use std::path::Path;
-use std::sync::{Arc, Mutex};
-
-use path::{PathHandled, PathHandler};
-use serde::{Deserialize, Serialize};
-
-use crate::Error;
-
-#[derive(Debug, Clone, Default, Deserialize, Serialize)]
-pub struct Lock<T> {
-    #[serde(skip_deserializing, skip_serializing)]
-    ph: Option<Arc<Mutex<PathHandler>>>,
-    inner: HashSet<T>,
-}
-
-impl<T> Lock<T>
-where
-    T: Lockable + Status + Deserialize<'de>,
-{
-    pub fn new(ph: Arc<Mutex<PathHandler>>, inner: HashSet<T>) -> Self {
-        Self {
-            ph: Some(ph),
-            inner,
-        }
-    }
-
-    pub fn load<P>(ph: Arc<Mutex<PathHandler>>, path: P) -> crate::Result<Self>
-    where
-        P: AsRef<Path>,
-    {
-        let mut path = path.as_ref().to_path_buf();
-        if path.is_relative() {
-            path = path.canonicalize()?;
-        }
-
-        let mut buf = Vec::new();
-        OpenOptions::new()
-            .read(true)
-            .open(path)?
-            .read_to_end(&mut buf)?;
-
-        let lock: Lock<T> = toml::from_slice(buf.as_slice())?;
-
-        Ok(lock)
-    }
-
-    pub fn update(&mut self) -> crate::Result<()> {
-        let ph = self.ph.as_ref().ok_or(Error::MissingPathHandler)?.clone();
-
-        self.inner = self
-            .inner
-            .clone()
-            .into_iter()
-            .filter_map(|mut item| {
-                let item = item.with_path_handler(Arc::clone(&ph));
-
-                // If the class is up-to-date and no errors occurred during the check
-                if item.is_updated().is_ok_and(|b| b == true) {
-                    Some(item.to_owned())
-                } else {
-                    None
-                }
-            })
-            .collect();
-
-        Ok(())
-    }
-
-    pub fn set_path_handler(&mut self, ph: Arc<Mutex<PathHandler>>) {
-        self.ph = Some(ph);
-    }
-
-    pub fn with_path_handler(&mut self, ph: Arc<Mutex<PathHandler>>) -> &mut Self {
-        self.ph = Some(ph);
-        self
-    }
-
-    /// Iterates over the entries in `NestLock`.
-    pub fn iter(&self) -> Iter<'_, T> {
-        self.inner.iter()
-    }
-
-    pub fn insert(&mut self, class: T) -> bool {
-        self.inner.insert(class)
-    }
-}
-
-pub trait Lockable: Hash + Eq + Clone + PathHandled {}
-
-trait Status {
-    type Error;
-
-    fn is_updated(&self) -> Result<bool, Self::Error>;
-}

retired/nest_lib_rs_old/meta.rs

@@ -1,62 +0,0 @@
-use std::fmt::Display;
-use std::path::PathBuf;
-
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct Meta {
-    name: String,
-    version: semver::Version,
-    #[serde(skip_serializing_if = "<Option<_>>::is_none")]
-    authors: Option<Vec<String>>,
-    #[serde(skip_serializing_if = "<Option<_>>::is_none")]
-    repository: Option<String>,
-    #[serde(skip_serializing_if = "<Option<_>>::is_none")]
-    license: Option<License>,
-    #[serde(skip_serializing_if = "<Option<_>>::is_none")]
-    license_file: Option<PathBuf>,
-}
-
-impl Meta {
-    pub fn new<S: ToString>(name: S) -> Self {
-        let mut meta = Self::default();
-        meta.name = name.to_string();
-        meta
-    }
-
-    pub fn name(&self) -> String {
-        self.name.clone()
-    }
-}
-
-impl Default for Meta {
-    fn default() -> Self {
-        Self {
-            name: Default::default(),
-            version: semver::Version::new(0, 1, 0),
-            authors: None,
-            repository: None,
-            license: None,
-            license_file: None,
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, Deserialize, Serialize)]
-pub enum License {
-    Mit,
-    Apache,
-}
-
-impl Display for License {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(
-            f,
-            "{}",
-            match self {
-                License::Mit => "MIT",
-                License::Apache => "Apache",
-            }
-        )
-    }
-}

retired/nest_lib_rs_old/nest.rs

@@ -1,130 +0,0 @@
-use std::collections::HashSet;
-use std::fs::{File, OpenOptions};
-use std::io::Read;
-use std::path::PathBuf;
-use std::sync::{Arc, Mutex};
-
-use crate::Error;
-use crate::dependency::Dependency;
-use crate::meta::Meta;
-use crate::package::Package;
-use crate::workspace::Workspace;
-
-use path::{PathHandled, PathHandler};
-use pom::Pom;
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Default, Deserialize, Serialize)]
-pub struct Nest {
-    pub workspace: Workspace,
-    pub meta: Meta,
-    #[serde(default, skip_serializing_if = "HashSet::is_empty")]
-    pub dependencies: HashSet<Dependency>,
-    #[serde(default, skip_serializing_if = "Pom::is_empty")]
-    pub pom: Pom,
-}
-
-impl Nest {
-    pub fn new<S: ToString>(name: S) -> Self {
-        Nest {
-            meta: Meta::new(name),
-            ..Default::default()
-        }
-    }
-}
-
-impl TryFrom<File> for Nest {
-    type Error = Error;
-
-    fn try_from(value: File) -> Result<Self, Self::Error> {
-        let mut value = value;
-        let mut buf = String::new();
-        value.read_to_string(&mut buf)?;
-
-        Ok(toml::from_str(buf.as_str())?)
-    }
-}
-
-impl TryFrom<PathBuf> for Nest {
-    type Error = Error;
-
-    fn try_from(value: PathBuf) -> Result<Self, Self::Error> {
-        Nest::try_from(OpenOptions::new().read(true).open(value)?)
-    }
-}
-
-// TODO: See if NestLock and PreyLock can be combined into one parent struct,
-// but with different generics, and merely call upon a is_updated method set
-// by the generics implementing a common IsUpdated trait.
-//
-// Not happening any time soon. An enum could get around the issue of being unable to
-// implement Deserialize on a generic.
-
-#[derive(Debug, Default, Deserialize, Serialize)]
-pub struct NestLock {
-    #[serde(skip_serializing, skip_deserializing)]
-    ph: Option<Arc<Mutex<PathHandler>>>,
-    pub packages: HashSet<Package>,
-}
-
-impl NestLock {
-    /// Update, retaining all packages that still exist.
-    ///
-    /// Presently only supports packages under src/
-    pub fn update(&mut self) -> crate::Result<()> {
-        let dir_src = self
-            .ph
-            .as_ref()
-            .ok_or(Error::MissingPathHandler)?
-            .try_lock()?
-            .dir_src();
-
-        self.packages = self
-            .packages
-            .clone()
-            .into_iter()
-            .filter_map(|package| {
-                let path = dir_src.join(package.name());
-
-                if path.exists() && path.is_dir() {
-                    return Some(package);
-                }
-
-                None
-            })
-            .collect();
-
-        Ok(())
-    }
-}
-
-impl TryFrom<File> for NestLock {
-    type Error = Error;
-
-    fn try_from(value: File) -> Result<Self, Self::Error> {
-        let mut value = value;
-        let mut buf = String::new();
-
-        value.read_to_string(&mut buf)?;
-        Ok(toml::from_str(buf.as_str())?)
-    }
-}
-
-impl TryFrom<PathBuf> for NestLock {
-    type Error = Error;
-
-    fn try_from(value: PathBuf) -> Result<Self, Self::Error> {
-        NestLock::try_from(OpenOptions::new().read(true).open(&value)?)
-    }
-}
-
-impl PathHandled for NestLock {
-    fn set_path_handler(&mut self, ph: Arc<Mutex<PathHandler>>) {
-        self.ph = Some(ph);
-    }
-
-    fn with_path_handler(&mut self, ph: Arc<Mutex<PathHandler>>) -> &mut Self {
-        self.ph = Some(ph);
-        self
-    }
-}

retired/nest_lib_rs_old/package.rs

@@ -1,38 +0,0 @@
-use std::{collections::HashSet, hash::Hash};
-
-use serde::{Deserialize, Serialize};
-
-use crate::dependency::Dependency;
-
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
-pub struct Package {
-    name: String,
-    version: semver::Version,
-    source: String,
-    checksum: String,
-    dependencies: HashSet<Dependency>,
-}
-
-impl Package {
-    pub fn name(&self) -> String {
-        self.name.clone()
-    }
-}
-
-impl Default for Package {
-    fn default() -> Self {
-        Self {
-            name: Default::default(),
-            version: semver::Version::new(0, 1, 0),
-            source: Default::default(),
-            checksum: Default::default(),
-            dependencies: Default::default(),
-        }
-    }
-}
-
-impl Hash for Package {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.name.hash(state);
-    }
-}

retired/nest_lib_rs_old/prelude.rs

@@ -1,10 +0,0 @@
-#![allow(unused_imports)]
-
-pub use crate::class::Class;
-pub use crate::dependency::Dependency;
-pub use crate::meta::Meta;
-pub use crate::nest::{Nest, NestLock};
-pub use crate::package::Package;
-pub use crate::prey::{Prey, PreyLock};
-pub use crate::workspace::Workspace;
-pub use crate::{F_NEST_LOCK, F_NEST_TOML, F_PREY_LOCK, F_PREY_TOML, FN_NEST, FN_PREY};

retired/nest_lib_rs_old/prey.rs

@@ -1,127 +0,0 @@
-use std::collections::HashSet;
-use std::collections::hash_set::Iter;
-use std::fs::{File, OpenOptions};
-use std::io::Read;
-use std::path::PathBuf;
-use std::sync::{Arc, Mutex};
-
-use path::{PathHandled, PathHandler};
-use serde::{Deserialize, Serialize};
-
-use crate::Error;
-use crate::class::Class;
-use crate::meta::Meta;
-use crate::package::Package;
-
-#[derive(Debug, Clone, Default, Deserialize, Serialize)]
-pub struct Prey {
-    package: Package,
-    meta: Meta,
-}
-
-impl Prey {
-    pub fn new<S: ToString>(name: S) -> Self {
-        Prey {
-            package: (),
-            meta: (),
-        }
-    }
-}
-
-impl TryFrom<File> for Prey {
-    type Error = Error;
-
-    fn try_from(value: File) -> Result<Self, Self::Error> {
-        let mut value = value;
-        let mut buf = String::new();
-        value.read_to_string(&mut buf)?;
-
-        Ok(toml::from_str(buf.as_str())?)
-    }
-}
-
-impl TryFrom<PathBuf> for Prey {
-    type Error = Error;
-
-    fn try_from(value: PathBuf) -> Result<Self, Self::Error> {
-        Prey::try_from(OpenOptions::new().read(true).open(value)?)
-    }
-}
-
-#[derive(Debug, Clone, Default, Deserialize, Serialize)]
-pub struct PreyLock {
-    #[serde(skip_deserializing, skip_serializing)]
-    ph: Option<Arc<Mutex<PathHandler>>>,
-    classes: HashSet<Class>,
-}
-
-impl PreyLock {
-    pub fn new(ph: Arc<Mutex<PathHandler>>, classes: HashSet<Class>) -> Self {
-        Self {
-            ph: Some(ph),
-            classes,
-        }
-    }
-
-    pub fn update(&mut self) -> crate::Result<()> {
-        let ph = self.ph.as_ref().ok_or(Error::MissingPathHandler)?.clone();
-
-        self.classes = self
-            .classes
-            .clone()
-            .into_iter()
-            .filter_map(|mut class| {
-                let class = class.with_path_handler(Arc::clone(&ph));
-
-                // If the class is up-to-date and no errors occurred during the check
-                if class.is_updated().is_ok_and(|b| b == true) {
-                    Some(class.to_owned())
-                } else {
-                    None
-                }
-            })
-            .collect();
-
-        Ok(())
-    }
-
-    /// Iterates over the entries in `PreyLock`.
-    pub fn iter(&self) -> Iter<'_, Class> {
-        self.classes.iter()
-    }
-
-    pub fn insert(&mut self, class: Class) -> bool {
-        self.classes.insert(class)
-    }
-}
-
-impl TryFrom<File> for PreyLock {
-    type Error = Error;
-
-    fn try_from(value: File) -> Result<Self, Self::Error> {
-        let mut value = value;
-        let mut buf = String::new();
-        value.read_to_string(&mut buf)?;
-
-        Ok(toml::from_str(buf.as_str())?)
-    }
-}
-
-impl TryFrom<PathBuf> for PreyLock {
-    type Error = Error;
-
-    fn try_from(value: PathBuf) -> Result<Self, Self::Error> {
-        PreyLock::try_from(OpenOptions::new().read(true).open(value)?)
-    }
-}
-
-impl PathHandled for PreyLock {
-    fn set_path_handler(&mut self, ph: Arc<Mutex<PathHandler>>) {
-        self.ph = Some(ph);
-    }
-
-    fn with_path_handler(&mut self, ph: Arc<Mutex<PathHandler>>) -> &mut Self {
-        self.ph = Some(ph);
-        self
-    }
-}

retired/nest_lib_rs_old/workspace.rs

@@ -1,8 +0,0 @@
-use std::path::PathBuf;
-
-use serde::{Deserialize, Serialize};
-
-#[derive(Debug, Clone, Default, Deserialize, Serialize)]
-pub struct Workspace {
-    pub default_package: PathBuf,
-}

retired/old_nest.rs

@@ -1,196 +0,0 @@
-#![allow(dead_code)]
-
-use std::collections::HashSet;
-use std::fs::{File, OpenOptions};
-use std::hash::{self, Hash};
-use std::io::Read;
-use std::path::{Path, PathBuf};
-use std::sync::LazyLock;
-
-use crate::java::{JAVA_EXT_CLASS, JAVA_EXT_SOURCE};
-use crate::{DIR_SRC, DIR_TARGET, F_NEST_LOCK, F_NEST_TOML, PROJECT_ROOT};
-
-use anyhow::Context;
-use semver::Version;
-use serde::{Deserialize, Serialize};
-
-pub static NEST: LazyLock<anyhow::Result<Nest>> =
-    LazyLock::new(|| Nest::try_from(PROJECT_ROOT.join(F_NEST_TOML.as_path())));
-
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct Nest {
-    pub package: Package,
-}
-
-impl TryFrom<File> for Nest {
-    type Error = anyhow::Error;
-
-    fn try_from(value: File) -> Result<Self, Self::Error> {
-        let mut value = value;
-        let mut buf = String::new();
-        value
-            .read_to_string(&mut buf)
-            .context("Failed to read Nest")?;
-
-        toml::from_str(buf.as_str()).context("Failed to deserialize Nest")
-    }
-}
-
-impl TryFrom<PathBuf> for Nest {
-    type Error = anyhow::Error;
-
-    fn try_from(value: PathBuf) -> Result<Self, Self::Error> {
-        Nest::try_from(
-            OpenOptions::new()
-                .read(true)
-                .open(value)
-                .expect("Failed to load Nest.toml"),
-        )
-    }
-}
-
-// Rename to Prey
-// Mark as deprecated soon.
-#[derive(Debug, Clone, Deserialize, Serialize)]
-pub struct Package {
-    pub name: String,
-    pub version: semver::Version,
-}
-
-impl Default for Package {
-    fn default() -> Self {
-        Self {
-            name: String::from("MyPackage"),
-            version: Version::new(0, 1, 0),
-        }
-    }
-}
-
-#[derive(Debug, Default, Deserialize, Serialize)]
-pub struct NestLock {
-    pub classes: HashSet<Class>,
-}
-
-impl NestLock {
-    pub fn load() -> anyhow::Result<NestLock> {
-        NestLock::try_from(PROJECT_ROOT.join(F_NEST_LOCK.as_path()))
-    }
-
-    /// Update, retaining all classes that still exist and whose paths are still files, rather than
-    /// being shifted into a package.
-    pub fn update(&mut self) {
-        self.classes = self
-            .classes
-            .clone()
-            .into_iter()
-            .filter_map(|class| {
-                // Paths are almost correct, except that the target classes are expecting to path
-                // through:
-                // target/main/Main.class, not target/Main.class
-                // target/test/MainTest.class, not target/MainTest.class
-
-                if DIR_SRC
-                    .join(&class.path)
-                    .with_extension(JAVA_EXT_SOURCE)
-                    .exists()
-                    && DIR_TARGET
-                        .join(&class.subpath())
-                        .with_extension(JAVA_EXT_CLASS)
-                        .is_file()
-                {
-                    return Some(class);
-                }
-
-                None
-            })
-            .collect();
-    }
-}
-
-impl TryFrom<File> for NestLock {
-    type Error = anyhow::Error;
-
-    fn try_from(value: File) -> Result<Self, Self::Error> {
-        let mut value = value;
-        let mut buf = String::new();
-
-        value.read_to_string(&mut buf)?;
-        toml::from_str(buf.as_str()).context("Failed to deserialize NestLock")
-    }
-}
-
-impl TryFrom<PathBuf> for NestLock {
-    type Error = anyhow::Error;
-
-    fn try_from(value: PathBuf) -> Result<Self, Self::Error> {
-        NestLock::try_from(
-            OpenOptions::new()
-                .read(true)
-                .open(&value)
-                .with_context(|| format!("Failed to open {}", value.display()))?,
-        )
-        .context("")
-    }
-}
-
-#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Eq)]
-pub struct Class {
-    path: PathBuf,
-    checksum: String,
-}
-
-impl Class {
-    /// Returns true if the class needs updating.
-    /// This may also cautionarily return true if it cannot digest the file.
-    pub fn is_updated(&self) -> bool {
-        // Still doesn't handle inter-dependency checks.
-
-        DIR_TARGET
-            .join(self.subpath())
-            .with_extension(JAVA_EXT_CLASS)
-            .exists()
-            && sha256::try_digest(DIR_SRC.join(self.path()).with_extension(JAVA_EXT_SOURCE))
-                .is_ok_and(|hash| self.checksum == hash)
-    }
-
-    /// Returns the path such that src/ and target/ don't matter.
-    /// E.g., `main/Main.java` as_subpath is `Main.java`
-    /// allowing it to match with `target/main/Main.class`
-    /// because Java diregards the top level subdir in `src/`
-    fn subpath(&self) -> PathBuf {
-        let mut p = self.path.components();
-        p.next(); // Remove the top level dir.
-        p.as_path().to_path_buf()
-    }
-
-    pub fn path(&self) -> &Path {
-        self.path.as_path()
-    }
-}
-
-impl Hash for Class {
-    fn hash<H: hash::Hasher>(&self, state: &mut H) {
-        self.path.hash(state);
-    }
-}
-
-impl TryFrom<PathBuf> for Class {
-    type Error = anyhow::Error;
-
-    fn try_from(mut value: PathBuf) -> Result<Self, Self::Error> {
-        if value.is_relative() {
-            value = value
-                .canonicalize()
-                .context("Failed to canonicalize path")?;
-        }
-
-        Ok(Self {
-            path: PathBuf::from(
-                pathsub::sub_paths(value.as_path(), DIR_SRC.as_path())
-                    .context("Failed to subtract paths to get class path")?,
-            )
-            .with_extension(""),
-            checksum: sha256::try_digest(&value)?,
-        })
-    }
-}