use alloc::{
collections::{
BTreeMap,
BTreeSet,
},
rc::Rc,
};
use core::{
cell::RefCell,
fmt,
};
use serde::Serialize;
use serde_json::Value;
use crate::{
data::catalog::{
document::{
CatalogEntry,
EntryKind,
},
error::{
CatalogRule,
catalog_error,
},
name::CatalogName,
presets::ResolvedPresetSet,
resolve::{
ResolvedBuild,
ResolvedTag,
ResolvedTemplateClass,
},
stack::BunsenCatalogStack,
},
errors::BunsenResult,
};
#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize)]
pub struct KindRef {
pub path: CatalogName,
pub kind: EntryKind,
}
#[derive(Clone, Debug, PartialEq, Serialize)]
pub struct SelectRow {
pub entry: KindRef,
pub weight: f64,
}
#[derive(Clone, Debug, PartialEq, Serialize)]
pub struct SelectTable {
pub kind: EntryKind,
pub rows: Vec<SelectRow>,
}
impl SelectTable {
pub fn universe(
env: &SelectEnv<'_>,
kind: EntryKind,
) -> Self {
let names: Vec<CatalogName> = env
.stack()
.of_kind(kind)
.into_iter()
.map(|e| e.name().clone())
.collect();
Self::of(kind, names)
}
pub fn of(
kind: EntryKind,
names: impl IntoIterator<Item = CatalogName>,
) -> Self {
let mut names: Vec<CatalogName> = names.into_iter().collect();
names.sort();
names.dedup();
Self {
kind,
rows: names
.into_iter()
.map(|path| SelectRow {
entry: KindRef { path, kind },
weight: 1.0,
})
.collect(),
}
}
pub fn names(&self) -> Vec<&CatalogName> {
self.rows.iter().map(|r| &r.entry.path).collect()
}
pub fn is_empty(&self) -> bool {
self.rows.is_empty()
}
pub fn len(&self) -> usize {
self.rows.len()
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct DerivedKey {
pub name: String,
pub description: String,
}
pub trait DeriveTags {
fn keys(&self) -> Vec<DerivedKey>;
fn tags(
&self,
build: &ResolvedBuild,
) -> BTreeMap<String, Value>;
}
pub struct DeriveEach<F> {
pub keys: Vec<DerivedKey>,
pub tags: F,
}
impl<F: Fn(&ResolvedBuild) -> BTreeMap<String, Value>> DeriveTags for DeriveEach<F> {
fn keys(&self) -> Vec<DerivedKey> {
self.keys.clone()
}
fn tags(
&self,
build: &ResolvedBuild,
) -> BTreeMap<String, Value> {
(self.tags)(build)
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct SelectBuild {
pub build: ResolvedBuild,
pub derived: BTreeMap<String, Value>,
}
#[derive(Clone, Debug, PartialEq)]
pub enum SelectEntry {
Build(Rc<SelectBuild>),
TemplateClass(ResolvedTemplateClass),
Declared {
entry: CatalogEntry,
within: BTreeSet<CatalogName>,
},
}
impl SelectEntry {
pub fn tags(&self) -> Option<&BTreeMap<CatalogName, ResolvedTag>> {
match self {
Self::Build(b) => Some(&b.build.tags),
Self::TemplateClass(c) => Some(&c.tags),
Self::Declared { .. } => None,
}
}
pub fn presets(&self) -> Option<&ResolvedPresetSet> {
match self {
Self::Build(b) => Some(&b.build.presets),
Self::TemplateClass(c) => Some(&c.presets),
Self::Declared { .. } => None,
}
}
pub fn build(&self) -> Option<&SelectBuild> {
match self {
Self::Build(b) => Some(b),
_ => None,
}
}
}
pub const RESERVED_WORDS: [&str; 14] = [
"any",
"all",
"not",
"weight",
"name",
"presets",
"released",
"license",
"origin",
"parent",
"template_class",
"contract",
"format",
"dtype",
];
pub struct SelectEnv<'a> {
stack: &'a BunsenCatalogStack,
derive: Vec<&'a dyn DeriveTags>,
derived_keys: Vec<DerivedKey>,
builds: RefCell<BTreeMap<CatalogName, Rc<SelectBuild>>>,
entries: RefCell<BTreeMap<CatalogName, Rc<SelectEntry>>>,
}
impl<'a> SelectEnv<'a> {
pub fn new(stack: &'a BunsenCatalogStack) -> Self {
Self {
stack,
derive: Vec::new(),
derived_keys: Vec::new(),
builds: RefCell::new(BTreeMap::new()),
entries: RefCell::new(BTreeMap::new()),
}
}
pub fn with_derive(
stack: &'a BunsenCatalogStack,
derive: Vec<&'a dyn DeriveTags>,
) -> BunsenResult<Self> {
let mut derived_keys: Vec<DerivedKey> = Vec::new();
for key in derive.iter().flat_map(|d| d.keys()) {
if RESERVED_WORDS.contains(&key.name.as_str()) {
return Err(catalog_error(
CatalogRule::Selection,
format!(
"the derived key `{}` would be the `$` word `${}`, which the query \
language defines",
key.name, key.name
),
));
}
if derived_keys.iter().any(|k| k.name == key.name) {
return Err(catalog_error(
CatalogRule::Selection,
format!("two derive steps write the key `{}`", key.name),
));
}
derived_keys.push(key);
}
Ok(Self {
stack,
derive,
derived_keys,
builds: RefCell::new(BTreeMap::new()),
entries: RefCell::new(BTreeMap::new()),
})
}
pub fn stack(&self) -> &'a BunsenCatalogStack {
self.stack
}
pub fn derived_keys(&self) -> &[DerivedKey] {
&self.derived_keys
}
pub fn build(
&self,
name: &CatalogName,
) -> BunsenResult<Rc<SelectBuild>> {
if let Some(found) = self.builds.borrow().get(name) {
return Ok(found.clone());
}
let build = self.stack.resolve_build(name).map_err(|e| {
catalog_error(
CatalogRule::Selection,
format!("`{name}` doesn't resolve: {e}"),
)
})?;
let mut derived = BTreeMap::new();
for step in &self.derive {
derived.extend(step.tags(&build));
}
let entry = Rc::new(SelectBuild { build, derived });
self.builds.borrow_mut().insert(name.clone(), entry.clone());
Ok(entry)
}
}
impl SelectEnv<'_> {
pub fn entry(
&self,
entry: &KindRef,
) -> BunsenResult<Rc<SelectEntry>> {
if let Some(found) = self.entries.borrow().get(&entry.path) {
return Ok(found.clone());
}
let name = &entry.path;
let unresolved = |why: String| {
catalog_error(
CatalogRule::Selection,
format!("`{name}` doesn't resolve: {why}"),
)
};
let decl = self
.stack
.declaration(name)
.filter(|d| d.kind() == entry.kind)
.ok_or_else(|| unresolved(format!("it isn't declared as a `{}`", entry.kind)))?;
let found = Rc::new(match entry.kind {
EntryKind::Build => SelectEntry::Build(self.build(name)?),
EntryKind::TemplateClass => SelectEntry::TemplateClass(
self.stack
.resolve_template_class(name)
.map_err(|e| unresolved(e.to_string()))?,
),
kind => {
let within = if kind.is_group() {
self.stack.group_closure(self.stack.direct_groups(decl))
} else {
let mut scopes = BTreeSet::new();
let mut scope = name.scope();
while let Some(s) = scope {
scope = s.scope();
scopes.insert(s);
}
scopes
};
SelectEntry::Declared {
entry: decl.body().clone(),
within,
}
}
});
self.entries
.borrow_mut()
.insert(name.clone(), found.clone());
Ok(found)
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum StageOrigin {
Prefix(Vec<String>),
Default,
Use(String),
Flag(String),
Query,
Tail,
}
impl fmt::Display for StageOrigin {
fn fmt(
&self,
f: &mut fmt::Formatter<'_>,
) -> fmt::Result {
match self {
Self::Prefix(flags) => write!(f, "prefix: {}", flags.join(" ")),
Self::Default => f.write_str("defaults"),
Self::Use(name) => write!(f, "use: {name}"),
Self::Flag(flag) => f.write_str(flag),
Self::Query => f.write_str("query"),
Self::Tail => f.write_str("tail"),
}
}
}
impl Serialize for StageOrigin {
fn serialize<S: serde::Serializer>(
&self,
serializer: S,
) -> Result<S::Ok, S::Error> {
serializer.collect_str(self)
}
}
#[derive(Clone, Debug, PartialEq, Serialize)]
pub struct StageTrace {
pub index: usize,
pub op: &'static str,
pub origin: StageOrigin,
#[serde(skip_serializing_if = "Option::is_none")]
pub label: Option<String>,
pub dropped: usize,
#[serde(skip_serializing_if = "Vec::is_empty")]
pub weights: Vec<(CatalogName, f64)>,
}
#[derive(Clone, Debug, PartialEq, Serialize)]
pub struct DroppedRow {
pub entry: KindRef,
pub stage: usize,
pub weight: f64,
pub why: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
pub struct SelectTrace {
pub stages: Vec<StageTrace>,
pub dropped: Vec<DroppedRow>,
}
#[derive(Clone, Debug, PartialEq, Serialize)]
pub struct SelectRun {
pub table: SelectTable,
pub trace: SelectTrace,
}