use std::{
collections::BTreeMap,
path::{Path, PathBuf},
};
use serde::{Deserialize, Serialize};
use crate::domain::{ContextEntry, Metadata, MetadataContext};
#[derive(Debug)]
pub(crate) struct Domain;
#[derive(Debug, Deserialize)]
#[serde(deny_unknown_fields)]
pub(crate) struct Config {
manifests: crate::config::Patterns,
#[serde(default, rename = "source-documentation")]
source_documentation: bool,
}
#[derive(Debug, Serialize)]
struct TemplateContext {
version: Option<String>,
}
impl crate::domain::registry::Domain for Domain {
type Config = Config;
type State = ();
const NAME: &'static str = "php";
fn manifests(
config: &Self::Config,
_state: &Self::State,
root: &Path,
files: &crate::domain::IndexedFiles,
) -> Result<Vec<PathBuf>, crate::domain::Error> {
Ok(crate::config::matching_files(
root,
files,
&config.manifests,
))
}
fn metadata(
_config: &Self::Config,
_state: &Self::State,
context: &MetadataContext<'_>,
) -> Result<Option<Metadata>, crate::domain::Error> {
let manifest: Manifest =
serde_json::from_str(context.manifest_source).map_err(|error| {
crate::domain::Error::parse(context.manifest_path, "composer.json", error)
})?;
let mut metadata = Metadata {
name: manifest.name,
description: manifest.description,
version: manifest.version,
kind: "php",
..Metadata::default()
};
metadata.insert_data(
Self::NAME,
TemplateContext {
version: manifest.require.get("php").cloned(),
},
);
Ok(Some(metadata))
}
fn context(
_config: &Self::Config,
_state: &Self::State,
context: &crate::RenderCtx<'_>,
) -> Result<Vec<ContextEntry>, crate::domain::Error> {
let Some(value) = context.metadata.data::<TemplateContext>(Self::NAME) else {
return Ok(Vec::new());
};
Ok(vec![("php".into(), crate::domain::to_value(value))])
}
fn source_description(
config: &Self::Config,
_state: &Self::State,
path: &Path,
source: &str,
) -> Option<String> {
config.source_documentation.then_some(())?;
(path.extension()?.to_str()? == "php").then_some(())?;
source.lines().take(10).find_map(|line| {
let line = line.trim();
let body = line
.strip_prefix("/**")
.or_else(|| line.strip_prefix('*'))?
.trim();
let body = body.strip_suffix("*/").unwrap_or(body).trim();
(!body.is_empty()).then(|| body.to_string())
})
}
fn namespaces(_config: &Self::Config) -> Vec<Box<str>> {
vec![Self::NAME.into()]
}
}
#[derive(Deserialize)]
struct Manifest {
name: Option<String>,
description: Option<String>,
version: Option<String>,
#[serde(default)]
require: BTreeMap<String, String>,
}
crate::domain::registry::register_domain!(Domain);
#[cfg(test)]
mod tests {
use googletest::prelude::*;
use super::*;
use crate::{WorkspaceFile, WorkspaceIndex};
#[gtest]
fn parses_configured_composer_metadata() -> Result<()> {
let root = Path::new("/ws");
let workspace = WorkspaceIndex::new_domain(
root.to_path_buf(),
vec![WorkspaceFile {
path: root.join("composer.json"),
contents: Some(
r#"{"name":"example/api","description":"API","require":{"php":"^8.4"}}"#.into(),
),
}],
"php",
toml::Value::Table(toml::toml! { manifests = ["composer.json"] }),
);
let metadata = workspace.metadata(root).or_fail()?;
verify_eq!(metadata.kind, "php")?;
verify_eq!(metadata.name.as_deref(), Some("example/api"))
}
}