use std::collections::{BTreeMap, BTreeSet};
use serde::{Deserialize, Deserializer, Serialize, Serializer};
pub use crate::configuration::{
ConceptKind, ContentNavigation, ExecutionEngine, ExecutionMode, PackageKind, PackageVisibility,
RelationshipKind,
};
use crate::diagnostics::{Diagnostic, DiagnosticPath};
use crate::documents::AuthoredFormat;
use super::{
Document, Fingerprint, ItemAlias, ItemLanguageData, JuliaCallableRole, JuliaDeclaration,
JuliaVisibility, PackageMetadata, Provenance, SourceSpan, SourcedSignature,
};
pub const WORKSPACE_SCHEMA_VERSION: u32 = 16;
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct SchemaVersion;
impl Serialize for SchemaVersion {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_u32(WORKSPACE_SCHEMA_VERSION)
}
}
impl<'de> Deserialize<'de> for SchemaVersion {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let version = u32::deserialize(deserializer)?;
if version != WORKSPACE_SCHEMA_VERSION {
return Err(serde::de::Error::custom(format!(
"unsupported workspace IR schema version {version}; expected {WORKSPACE_SCHEMA_VERSION}"
)));
}
Ok(Self)
}
}
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Workspace {
pub schema_version: SchemaVersion,
pub name: String,
pub repositories: BTreeMap<String, Repository>,
pub packages: BTreeMap<String, Package>,
pub content_collections: BTreeMap<String, ContentCollection>,
pub pages: BTreeMap<String, Page>,
pub concepts: BTreeMap<String, Concept>,
pub relationships: Vec<PackageRelationship>,
pub diagnostics: BTreeSet<Diagnostic>,
pub provenance: Vec<Provenance>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Repository {
pub canonical_url: Option<String>,
pub source_link_template: Option<String>,
pub revision: Option<String>,
pub dirty: Option<bool>,
pub declared_input_fingerprint: Option<Fingerprint>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Package {
pub slug: String,
pub name: String,
pub ecosystem: String,
pub version: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub metadata: Option<PackageMetadata>,
pub repository: String,
pub path: Option<DiagnosticPath>,
pub metadata_path: DiagnosticPath,
pub kind: PackageKind,
pub visibility: PackageVisibility,
pub extraction_targets: BTreeMap<String, ExtractionTarget>,
pub items: BTreeMap<String, Item>,
}
impl Package {
pub fn discoverable_items(&self) -> BTreeSet<&str> {
let mut discoverable: BTreeSet<_> = self
.items
.iter()
.filter(|(_, item)| match &item.language_data {
Some(ItemLanguageData::Julia(data)) => match &data.declaration {
JuliaDeclaration::Module { .. } if data.defining_module.is_empty() => true,
JuliaDeclaration::Callable {
role: JuliaCallableRole::Method { .. },
..
} => false,
_ => item.discoverable(),
},
_ => item.discoverable(),
})
.map(|(id, _)| id.as_str())
.collect();
for (id, item) in &self.items {
if let Some(ItemLanguageData::Julia(data)) = &item.language_data
&& let JuliaDeclaration::Callable {
role: JuliaCallableRole::Method { family, .. },
..
} = &data.declaration
&& discoverable.contains(family.item.as_str())
{
discoverable.insert(id.as_str());
}
}
let modules: BTreeMap<_, _> = self
.items
.iter()
.filter(|(_, item)| {
matches!(&item.language_data, Some(ItemLanguageData::Julia(data))
if matches!(data.declaration, JuliaDeclaration::Module { .. }))
})
.map(|(id, item)| (item.qualified_name.as_str(), id.as_str()))
.collect();
let mut pending: Vec<_> = discoverable.iter().copied().collect();
while let Some(id) = pending.pop() {
if let Some(ItemLanguageData::Julia(data)) = &self.items[id].language_data
&& let Some(&module) = modules.get(data.defining_module.as_str())
&& discoverable.insert(module)
{
pending.push(module);
}
}
discoverable
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ExtractionTarget {
pub extractor: String,
pub path: Option<DiagnosticPath>,
pub role: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ContentCollection {
pub owner: ContentOwner,
pub repository: String,
pub path: Option<DiagnosticPath>,
pub mount: String,
pub format: AuthoredFormat,
#[serde(default, skip_serializing_if = "ContentNavigation::is_default")]
pub navigation: ContentNavigation,
pub execution: ExecutionConfiguration,
}
#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ExecutionConfiguration {
pub mode: ExecutionMode,
pub engine: Option<ExecutionEngine>,
pub kernel: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub julia_project: Option<DiagnosticPath>,
pub declared_environment_inputs: BTreeSet<DiagnosticPath>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "kebab-case", deny_unknown_fields)]
pub enum ContentOwner {
Project,
Package {
package: String,
},
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Page {
pub owner: ContentOwner,
pub kind: PageKind,
pub title: String,
pub document: SourcedDocument,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "kebab-case", deny_unknown_fields)]
pub enum PageKind {
Authored {
collection: String,
},
Api {
item: ItemReference,
},
Concept {
concept: String,
},
PackageDocumentation {
role: PackagePageRole,
},
Overview,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum PackagePageRole {
Overview,
News,
Authors,
License,
Community,
}
impl PackagePageRole {
pub fn filename(self) -> &'static str {
match self {
Self::Overview => "index.html",
Self::News => "news.html",
Self::Authors => "authors.html",
Self::License => "license.html",
Self::Community => "community.html",
}
}
pub fn title(self) -> &'static str {
match self {
Self::Overview => "Overview",
Self::News => "News",
Self::Authors => "Authors and citation",
Self::License => "License",
Self::Community => "Community",
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SourcedDocument {
pub document: Document,
pub source_format: DocumentFormat,
pub source_location: Option<SourceLocation>,
pub raw_source: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub generated_source: Option<String>,
pub provenance: Vec<Provenance>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "kebab-case", deny_unknown_fields)]
pub enum DocumentFormat {
Authored {
format: AuthoredFormat,
},
Extracted {
name: String,
},
Generated,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Item {
pub kind: ItemKind,
pub name: String,
pub qualified_name: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub language_data: Option<ItemLanguageData>,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pub aliases: Vec<ItemAlias>,
pub signatures: Vec<SourcedSignature>,
pub documentation: Option<SourcedDocument>,
pub source_location: Option<SourceLocation>,
pub children: Vec<String>,
pub provenance: Vec<Provenance>,
}
impl Item {
pub fn discoverable(&self) -> bool {
match &self.language_data {
Some(ItemLanguageData::Cpp(data)) => data.family.is_none(),
Some(ItemLanguageData::R(data)) => !data.internal,
Some(ItemLanguageData::Python(data)) => {
data.visibility != super::PythonVisibility::Private
&& !matches!(
&data.declaration,
super::PythonDeclaration::Callable {
role: super::PythonCallableRole::Overload { .. },
..
}
)
}
Some(ItemLanguageData::Julia(data)) => {
data.visibility != JuliaVisibility::Private
&& !matches!(data.declaration, JuliaDeclaration::Field { .. })
}
_ => true,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "kebab-case")]
pub enum ItemKind {
Module,
Function,
Method,
Type,
Class,
Constant,
Field,
Namespace,
}
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ItemReference {
pub package: String,
pub item: String,
}
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct TargetReference {
pub package: String,
pub target: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SourceLocation {
pub repository: String,
pub path: DiagnosticPath,
pub span: Option<SourceSpan>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct IncludeSourceRange {
pub expanded: SourceSpan,
pub original: SourceLocation,
pub line: usize,
pub include_chain: Vec<SourceLocation>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Concept {
pub kind: ConceptKind,
pub members: BTreeSet<ItemReference>,
pub documentation: Option<SourcedDocument>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct PackageRelationship {
pub from: PackageReference,
pub to: PackageReference,
pub kind: RelationshipKind,
pub version_constraint: Option<String>,
pub provenance: Vec<Provenance>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "kebab-case", deny_unknown_fields)]
pub enum PackageReference {
Workspace {
package: String,
},
External {
ecosystem: String,
name: String,
},
}