code_moniker_workspace/source/

catalog.rs

use std::path::{Path, PathBuf};

use crate::environment;
use crate::snapshot::{
	SourceCatalog, SourceUnit, WorkspaceCancellation, WorkspaceFailure, WorkspaceRequest,
	WorkspaceResource, WorkspaceResult,
};

use super::content::{LocalResourceCache, SourceCatalogMaterial};
use super::identity::LocalIdentityResolver;

pub trait SourceCatalogPort {
	fn load_catalog(&mut self, request: &WorkspaceRequest) -> WorkspaceResult<SourceCatalog>;
	fn load_catalog_cancellable(
		&mut self,
		request: &WorkspaceRequest,
		cancellation: &WorkspaceCancellation,
	) -> WorkspaceResult<SourceCatalog> {
		cancellation.check(WorkspaceResource::SourceCatalog)?;
		let catalog = self.load_catalog(request)?;
		cancellation.check(WorkspaceResource::SourceCatalog)?;
		Ok(catalog)
	}

	fn extend_catalog(
		&mut self,
		current: &SourceCatalog,
		paths: &[PathBuf],
	) -> WorkspaceResult<Option<SourceCatalog>>;
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub struct LocalSourceCatalogOptions {
	pub paths: Vec<PathBuf>,
	pub files: Option<Vec<PathBuf>>,
	pub project: Option<String>,
	pub identity: LocalIdentityResolver,
}

impl LocalSourceCatalogOptions {
	pub fn new(paths: Vec<PathBuf>, project: Option<String>) -> Self {
		Self {
			paths,
			files: None,
			project,
			identity: LocalIdentityResolver::default(),
		}
	}

	pub fn with_files(mut self, files: Vec<PathBuf>) -> Self {
		self.files = Some(files);
		self
	}

	pub fn with_identity(mut self, identity: LocalIdentityResolver) -> Self {
		self.identity = identity;
		self
	}
}

pub struct LocalSourceCatalog {
	options: LocalSourceCatalogOptions,
	cache: LocalResourceCache,
}

impl LocalSourceCatalog {
	pub fn new(options: LocalSourceCatalogOptions, cache: LocalResourceCache) -> Self {
		Self { options, cache }
	}
}

impl SourceCatalogPort for LocalSourceCatalog {
	fn load_catalog(&mut self, _request: &WorkspaceRequest) -> WorkspaceResult<SourceCatalog> {
		load_local_catalog(self, &WorkspaceCancellation::default())
	}

	fn load_catalog_cancellable(
		&mut self,
		_request: &WorkspaceRequest,
		cancellation: &WorkspaceCancellation,
	) -> WorkspaceResult<SourceCatalog> {
		load_local_catalog(self, cancellation)
	}

	fn extend_catalog(
		&mut self,
		current: &SourceCatalog,
		paths: &[PathBuf],
	) -> WorkspaceResult<Option<SourceCatalog>> {
		extend_local_catalog(&self.cache, current, paths)
	}
}

fn load_local_catalog(
	catalog: &mut LocalSourceCatalog,
	cancellation: &WorkspaceCancellation,
) -> WorkspaceResult<SourceCatalog> {
	let sources = if let Some(files) = &catalog.options.files {
		let [root] = catalog.options.paths.as_slice() else {
			return Err(WorkspaceFailure::new(
				WorkspaceResource::SourceCatalog,
				"explicit source files require exactly one source root",
			));
		};
		environment::discover_source_files(root, files, catalog.options.project.clone())
	} else {
		crate::sources::discover_cancellable(
			&catalog.options.paths,
			catalog.options.project.clone(),
			cancellation,
		)
	}
	.map_err(|err| WorkspaceFailure::new(WorkspaceResource::SourceCatalog, err.to_string()))?;
	cancellation.check(WorkspaceResource::SourceCatalog)?;
	let generation = catalog.cache.next_generation();
	let units = sources
		.files
		.iter()
		.enumerate()
		.map(|(file_idx, file)| {
			SourceUnit::with_language(
				catalog.options.identity.source_id(file_idx, &file.rel_path),
				file.rel_path.display().to_string(),
				file.lang.tag(),
			)
		})
		.collect::<Vec<_>>();
	catalog.cache.insert_sources(
		generation,
		SourceCatalogMaterial {
			sources,
			identity: catalog.options.identity.clone(),
		},
	);
	Ok(SourceCatalog::new(generation, units))
}

fn extend_local_catalog(
	cache: &LocalResourceCache,
	current: &SourceCatalog,
	paths: &[PathBuf],
) -> WorkspaceResult<Option<SourceCatalog>> {
	let Some(mut material) = cache.source_material(current.generation) else {
		return Ok(None);
	};
	let added = new_source_files(&material, paths);
	let flipped = flip_retired_slots(&mut material, paths);
	if added.is_empty() && !flipped {
		return Ok(None);
	}
	material.sources.files.extend(added);
	let generation = cache.next_generation();
	let units = catalog_units(&material);
	cache.insert_sources(generation, material);
	Ok(Some(SourceCatalog::new(generation, units)))
}

fn flip_retired_slots(material: &mut SourceCatalogMaterial, paths: &[PathBuf]) -> bool {
	let mut flipped = false;
	for path in paths {
		let file_idx = material
			.normalized_file_index(path)
			.or_else(|| material.normalized_file_index(&canonical_lookup_path(path)));
		let Some(file_idx) = file_idx else {
			continue;
		};
		let exists = material.sources.files[file_idx].path.is_file();
		let file = &mut material.sources.files[file_idx];
		if file.retired != exists {
			continue;
		}
		file.retired = !exists;
		flipped = true;
	}
	flipped
}

fn canonical_lookup_path(path: &Path) -> PathBuf {
	if let Ok(canonical) = path.canonicalize() {
		return canonical;
	}
	if let (Some(parent), Some(name)) = (path.parent(), path.file_name())
		&& let Ok(parent) = parent.canonicalize()
	{
		return parent.join(name);
	}
	path.to_path_buf()
}

fn new_source_files(
	material: &SourceCatalogMaterial,
	paths: &[PathBuf],
) -> Vec<crate::sources::SourceFile> {
	let mut added: Vec<crate::sources::SourceFile> = Vec::new();
	for path in paths {
		if !path.is_file() || material.normalized_file_index(path).is_some() {
			continue;
		}
		let Some(file) = crate::sources::source_file_for_new_path(&material.sources, path) else {
			continue;
		};
		let duplicate = material.normalized_file_index(&file.path).is_some()
			|| added.iter().any(|existing| existing.path == file.path);
		if !duplicate {
			added.push(file);
		}
	}
	added
}

fn catalog_units(material: &SourceCatalogMaterial) -> Vec<SourceUnit> {
	material
		.sources
		.files
		.iter()
		.enumerate()
		.filter(|(_, file)| !file.retired)
		.map(|(file_idx, file)| {
			SourceUnit::with_language(
				material.identity.source_id(file_idx, &file.rel_path),
				file.rel_path.display().to_string(),
				file.lang.tag(),
			)
		})
		.collect()
}