use std::collections::BTreeMap;
use serde::{Deserialize, Serialize};
use super::SourceLocation;
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RMetadata {
pub name: String,
pub version: String,
pub title: String,
pub description: Option<String>,
pub license: Option<String>,
pub dependencies: BTreeMap<String, Vec<RDependency>>,
pub fields: BTreeMap<String, RMetadataField>,
pub source: SourceLocation,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RMetadataField {
pub value: String,
pub source: SourceLocation,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RDependency {
pub name: String,
pub constraints: Vec<RVersionConstraint>,
pub source: SourceLocation,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RVersionConstraint {
pub operator: String,
pub version: String,
pub source: SourceLocation,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(
tag = "language",
content = "data",
rename_all = "kebab-case",
deny_unknown_fields
)]
pub enum PackageMetadata {
Cpp(CppMetadata),
R(RPackageMetadata),
Python(PythonMetadata),
Julia(JuliaMetadata),
Rust(RustMetadata),
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct CppMetadata {
pub name: String,
pub version: Option<String>,
pub description: Option<String>,
pub source: SourceLocation,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RPackageMetadata {
pub description: RMetadata,
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
pub help_links: BTreeMap<String, Vec<RHelpTarget>>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub runtime: Option<RPackageRuntime>,
}
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RHelpTarget {
pub package: String,
pub topic: String,
pub repository: RdrrRepository,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum RdrrRepository {
R,
Cran,
Bioc,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RPackageRuntime {
pub authors: Vec<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub maintainers: Vec<String>,
pub citation: Option<RCitation>,
pub r_version: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RCitation {
pub text: String,
pub bibtex: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct PythonMetadata {
pub name: String,
pub version: String,
pub description: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub license: Option<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub authors: Vec<String>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub maintainers: Vec<String>,
#[serde(default, skip_serializing_if = "BTreeMap::is_empty")]
pub urls: BTreeMap<String, String>,
pub requires_python: Option<String>,
pub dependencies: Vec<String>,
pub optional_dependencies: BTreeMap<String, Vec<String>>,
pub dynamic: Vec<String>,
pub target_version: String,
pub source: SourceLocation,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct JuliaMetadata {
pub name: String,
pub uuid: String,
pub version: Option<String>,
pub authors: Vec<String>,
pub dependencies: BTreeMap<String, String>,
pub compatibility: BTreeMap<String, String>,
pub fields: BTreeMap<String, JuliaMetadataField>,
pub source: SourceLocation,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct JuliaMetadataField {
pub value: serde_json::Value,
pub source: SourceLocation,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RustMetadata {
pub name: String,
pub version: String,
pub description: Option<String>,
pub license: Option<String>,
pub authors: Vec<String>,
pub urls: BTreeMap<String, String>,
pub source: SourceLocation,
}
impl PackageMetadata {
pub fn name(&self) -> &str {
match self {
Self::Cpp(metadata) => &metadata.name,
Self::R(metadata) => &metadata.description.name,
Self::Python(metadata) => &metadata.name,
Self::Julia(metadata) => &metadata.name,
Self::Rust(metadata) => &metadata.name,
}
}
pub fn version(&self) -> Option<&str> {
match self {
Self::Cpp(metadata) => metadata.version.as_deref(),
Self::R(metadata) => Some(&metadata.description.version),
Self::Python(metadata) => Some(&metadata.version),
Self::Julia(metadata) => metadata.version.as_deref(),
Self::Rust(metadata) => Some(&metadata.version),
}
}
pub fn description(&self) -> Option<&str> {
match self {
Self::Cpp(metadata) => metadata.description.as_deref(),
Self::R(metadata) => metadata
.description
.description
.as_deref()
.or(Some(&metadata.description.title)),
Self::Python(metadata) => metadata.description.as_deref(),
Self::Julia(metadata) => metadata
.fields
.get("description")
.and_then(|field| field.value.as_str()),
Self::Rust(metadata) => metadata.description.as_deref(),
}
}
pub fn license(&self) -> Option<&str> {
match self {
Self::Cpp(_) => None,
Self::R(metadata) => metadata.description.license.as_deref(),
Self::Python(metadata) => metadata.license.as_deref(),
Self::Julia(metadata) => metadata
.fields
.get("license")
.and_then(|field| field.value.as_str()),
Self::Rust(metadata) => metadata.license.as_deref(),
}
}
pub fn source(&self) -> &SourceLocation {
match self {
Self::Cpp(metadata) => &metadata.source,
Self::R(metadata) => &metadata.description.source,
Self::Python(metadata) => &metadata.source,
Self::Julia(metadata) => &metadata.source,
Self::Rust(metadata) => &metadata.source,
}
}
}