use sephera_compression::SupportedLanguage;
use sephera_core::plugins::ImportPlugin;
use sephera_graph_cpp::CCppPlugin;
use sephera_graph_go::GoPlugin;
use sephera_graph_java::JavaPlugin;
use sephera_graph_javascript::JavaScriptPlugin;
use sephera_graph_python::PythonPlugin;
use sephera_graph_rust::RustPlugin;
pub use sephera_core::plugins::{
KnownFiles, ResolveContext, ResolverPlugin, ends_with_segments,
test_context,
};
pub use sephera_core::path_utils as paths;
#[must_use]
pub fn builtin_languages() -> Vec<SupportedLanguage> {
BUNDLED.iter().map(|entry| entry.language).collect()
}
struct Bundled {
language: SupportedLanguage,
import: &'static dyn ImportPlugin,
resolver: &'static (dyn ResolverPlugin + Sync),
}
macro_rules! bundled {
($language:expr, $plugin:expr $(,)?) => {
Bundled {
language: $language,
import: &$plugin,
resolver: &$plugin,
}
};
}
static BUNDLED: &[Bundled] = &[
bundled!(SupportedLanguage::Rust, RustPlugin),
bundled!(SupportedLanguage::Python, PythonPlugin),
bundled!(
SupportedLanguage::TypeScript,
JavaScriptPlugin {
language: SupportedLanguage::TypeScript
}
),
bundled!(
SupportedLanguage::JavaScript,
JavaScriptPlugin {
language: SupportedLanguage::JavaScript
}
),
bundled!(SupportedLanguage::Go, GoPlugin),
bundled!(SupportedLanguage::Java, JavaPlugin),
bundled!(
SupportedLanguage::C,
CCppPlugin {
language: SupportedLanguage::C
}
),
bundled!(
SupportedLanguage::Cpp,
CCppPlugin {
language: SupportedLanguage::Cpp
}
),
];
fn bundled_for(language: SupportedLanguage) -> Option<&'static Bundled> {
BUNDLED.iter().find(|entry| entry.language == language)
}
#[must_use]
pub fn builtin_import_plugin(
language: SupportedLanguage,
) -> Option<&'static dyn ImportPlugin> {
bundled_for(language).map(|entry| entry.import)
}
#[must_use]
pub fn builtin_resolver_plugin(
language: SupportedLanguage,
) -> Option<&'static dyn ResolverPlugin> {
bundled_for(language).map(|entry| entry.resolver as &dyn ResolverPlugin)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn every_variant_has_both_plugins() {
for language in SupportedLanguage::all() {
assert!(
builtin_import_plugin(*language).is_some(),
"{language:?} is missing an import plugin"
);
assert!(
builtin_resolver_plugin(*language).is_some(),
"{language:?} is missing a resolver plugin"
);
}
}
#[test]
fn the_registry_pairs_each_language_with_its_own_plugin() {
assert_eq!(BUNDLED.len(), SupportedLanguage::all().len());
}
#[test]
fn two_languages_sharing_a_struct_get_distinct_entries() {
let typescript = builtin_resolver_plugin(SupportedLanguage::TypeScript)
.expect("TypeScript has a resolver");
let javascript = builtin_resolver_plugin(SupportedLanguage::JavaScript)
.expect("JavaScript has a resolver");
assert!(
!std::ptr::eq(typescript, javascript),
"the two share a struct, so the registry must hold one value per language"
);
}
#[test]
fn resolver_for_unknown_language_is_absent() {
assert!(builtin_resolver_plugin(SupportedLanguage::Rust).is_some());
}
}