Most of the refactor. Need to switch machines.
This commit is contained in:
Olivia Brooks
272
crates/core/src/workspace.rs
Normal file
272
crates/core/src/workspace.rs
Normal file
@@ -0,0 +1,272 @@
|
||||
use std::collections::HashMap;
|
||||
use std::fs::{OpenOptions, read_dir};
|
||||
use std::io::{Read, Write};
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use fs::{self, expand_files};
|
||||
use io::run_process;
|
||||
use java::{self, JAVA_EXT_CLASS, JAVA_EXT_SOURCE};
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::Error;
|
||||
use crate::dependency::Dependency;
|
||||
use crate::nest::{F_NEST_LOCK, F_NEST_TOML, Nest, NestLock};
|
||||
use crate::package::PackageHandler;
|
||||
use crate::prey::F_PREY_TOML;
|
||||
|
||||
pub struct WorkspaceHandler {
|
||||
nest: Nest,
|
||||
nest_lock: Option<NestLock>,
|
||||
project_root: PathBuf,
|
||||
packages: HashMap<PathBuf, PackageHandler>,
|
||||
}
|
||||
|
||||
impl WorkspaceHandler {
|
||||
const DIR_SRC: &str = "src/";
|
||||
const DIR_TARGET: &str = "target/";
|
||||
|
||||
pub fn new<P: AsRef<Path>>(project_root: P) -> crate::Result<Self> {
|
||||
let project_root = project_root.as_ref().canonicalize()?;
|
||||
|
||||
Ok(Self {
|
||||
nest: Nest::new(
|
||||
project_root
|
||||
.file_name()
|
||||
.ok_or(Error::MissingFileName)?
|
||||
.display(),
|
||||
),
|
||||
nest_lock: None,
|
||||
packages: HashMap::new(),
|
||||
project_root,
|
||||
})
|
||||
}
|
||||
|
||||
pub fn load<P: AsRef<Path>>(project_root: P) -> crate::Result<Self> {
|
||||
let project_root = project_root.as_ref().canonicalize()?;
|
||||
|
||||
let mut workspace_manager = Self {
|
||||
nest: Nest::try_from(project_root.join(F_NEST_TOML))?,
|
||||
nest_lock: NestLock::try_from(project_root.join(F_NEST_LOCK)).ok(),
|
||||
packages: HashMap::new(),
|
||||
project_root,
|
||||
};
|
||||
|
||||
workspace_manager.discover_packages()?;
|
||||
|
||||
Ok(workspace_manager)
|
||||
}
|
||||
|
||||
pub fn write(&self) -> crate::Result<()> {
|
||||
self.nest.write(self.project_root.join(F_NEST_TOML))?;
|
||||
|
||||
if let Option::Some(lock) = self.nest_lock.clone() {
|
||||
lock.write(self.project_root.join(F_NEST_LOCK))?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
//pub fn refresh_packages(&mut self) -> crate::Result<()> {}
|
||||
|
||||
/*
|
||||
/// 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(())
|
||||
}
|
||||
|
||||
fn make_compiler_job<P: AsRef<Path>>(target: P) {
|
||||
// Generate dependency tree.
|
||||
}
|
||||
*/
|
||||
|
||||
pub fn init(&mut self) -> crate::Result<()> {
|
||||
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()?;
|
||||
|
||||
// Make .java-version
|
||||
self.write_java_version()?;
|
||||
|
||||
// Make src/, target/, test/
|
||||
self.write_dir_tree()?;
|
||||
|
||||
if !is_empty {
|
||||
self.write_example_project()?;
|
||||
self.discover_packages()?;
|
||||
|
||||
run_process(&["git", "init", "."])?;
|
||||
}
|
||||
|
||||
// Append to .gitignore
|
||||
if let Result::Ok(mut f) = OpenOptions::new()
|
||||
.append(true)
|
||||
.create(true)
|
||||
.read(true)
|
||||
.open(".gitignore")
|
||||
{
|
||||
let mut buf = String::new();
|
||||
f.read_to_string(&mut buf)?;
|
||||
|
||||
for ignored in [
|
||||
"# Automatically added by Raven".to_string(),
|
||||
Self::DIR_TARGET.to_string(),
|
||||
format!("*.{}", JAVA_EXT_CLASS),
|
||||
] {
|
||||
if !buf.contains(&ignored) {
|
||||
f.write(format!("{}\n", ignored).as_bytes())?;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
// This is the naive build
|
||||
pub fn build(&mut self) -> crate::Result<()> {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Add any newly created packages.
|
||||
fn discover_packages(&mut self) -> crate::Result<()> {
|
||||
// Scan the src/ directory for entries,
|
||||
// filter out the files,
|
||||
// then construct PackageManagers for each package
|
||||
|
||||
// Promote *not* using reverse domain name tree structures
|
||||
// by improving the speed of package discovery by using read_dir
|
||||
// and checking for an immediate Prey.toml before expanding the
|
||||
// whole subtree.
|
||||
//
|
||||
// Yes, I know this looks like shit.
|
||||
// That's because it is.
|
||||
|
||||
for file in read_dir(Self::DIR_SRC)?
|
||||
// Get directories
|
||||
.filter_map(|entry| {
|
||||
if entry.as_ref().is_ok_and(|entry| entry.path().is_dir()) {
|
||||
Some(entry.unwrap().path())
|
||||
} else {
|
||||
None
|
||||
}
|
||||
})
|
||||
// Get Prey.toml files
|
||||
.filter_map(|dir| {
|
||||
Some(if dir.join(F_PREY_TOML).exists() {
|
||||
vec![dir.join(F_PREY_TOML)]
|
||||
} else {
|
||||
expand_files(dir)
|
||||
.ok()?
|
||||
.iter()
|
||||
.filter_map(|file| {
|
||||
if file.ends_with(PathBuf::from(F_PREY_TOML)) {
|
||||
Some(file.to_owned())
|
||||
} else {
|
||||
None
|
||||
}
|
||||
})
|
||||
.collect()
|
||||
})
|
||||
})
|
||||
.flatten()
|
||||
{
|
||||
let package_root =
|
||||
pathsub::sub_paths(file.as_path(), PathBuf::from(Self::DIR_SRC).as_path()).unwrap();
|
||||
|
||||
self.packages.insert(
|
||||
package_root.to_path_buf(),
|
||||
PackageHandler::new(package_root, PathBuf::from(Self::DIR_TARGET))?,
|
||||
);
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn write_nest(&self) -> crate::Result<()> {
|
||||
if let Result::Ok(mut f) = OpenOptions::new()
|
||||
.write(true)
|
||||
.create_new(true)
|
||||
.open(F_NEST_TOML)
|
||||
{
|
||||
f.write_all(toml::to_string_pretty(&self.nest)?.as_bytes())?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
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())?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn write_dir_tree(&self) -> std::io::Result<()> {
|
||||
for dir in [
|
||||
format!("{}main/java", Self::DIR_SRC),
|
||||
format!("{}test/java", Self::DIR_SRC),
|
||||
Self::DIR_TARGET.to_string(),
|
||||
] {
|
||||
std::fs::create_dir_all(std::env::current_dir()?.join(dir))?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn write_example_project(&self) -> std::io::Result<()> {
|
||||
// Make src/main/Main.java
|
||||
if let Result::Ok(mut f) = OpenOptions::new().write(true).create_new(true).open(
|
||||
PathBuf::from(Self::DIR_SRC)
|
||||
.join("main/java/Main")
|
||||
.with_extension(JAVA_EXT_SOURCE),
|
||||
) {
|
||||
f.write_all(include_bytes!("../assets/Main.java"))?;
|
||||
}
|
||||
|
||||
// Make src/test/MainTest.java
|
||||
if let Result::Ok(mut f) = OpenOptions::new().write(true).create_new(true).open(
|
||||
PathBuf::from(Self::DIR_SRC)
|
||||
.join("test/java/MainTest")
|
||||
.with_extension(JAVA_EXT_SOURCE),
|
||||
) {
|
||||
f.write_all(include_bytes!("../assets/MainTest.java"))?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
/// Data struct
|
||||
#[derive(Debug, Clone, Deserialize, Serialize, Hash, PartialEq, Eq, PartialOrd, Ord)]
|
||||
pub struct Workspace {
|
||||
pub default_package: PathBuf,
|
||||
}
|
||||
|
||||
impl Default for Workspace {
|
||||
fn default() -> Self {
|
||||
Workspace {
|
||||
default_package: PathBuf::from("main"),
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user