Speed up brute force building with Prey.lock hashing and caching.

crates/core/src/workspace.rs

@@ -9,10 +9,10 @@ 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};
 
 #[derive(Debug)]
 pub struct WorkspaceHandler {
@@ -57,13 +57,15 @@ impl WorkspaceHandler {
         Ok(workspace_manager)
     }
 
-    pub fn write(&self) -> crate::Result<()> {
-        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(())
     }
 
@@ -114,25 +116,39 @@ impl WorkspaceHandler {
 
     // This is the naive build
     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() {
-            // Possibly come up with a source file handler for this?
-            if let Ok(_) = compiler.clone().compile(target.path.as_path()) {
-                // TODO: Prevent unnecessary recompile
-                //target.update()?;
+        // No unintentional deep copying anywhere, right?
+        // Probably not. We'll see.
+        for handler in self.packages.values_mut() {
+            let package_src_root = self
+                .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)
     }
 
@@ -172,12 +188,30 @@ impl WorkspaceHandler {
     }
 
     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)
     }
 
@@ -256,7 +290,7 @@ impl WorkspaceHandler {
             .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(())