use std::collections::HashMap;
use arbitrary::Result as ArbitraryResult;
use crate::{
description::Description,
directive::{Directive, DirectiveLocation},
name::Name,
DocumentBuilder,
};
#[derive(Debug, Clone)]
pub struct ScalarTypeDef {
pub(crate) name: Name,
pub(crate) description: Option<Description>,
pub(crate) directives: HashMap<Name, Directive>,
pub(crate) extend: bool,
}
impl From<ScalarTypeDef> for apollo_encoder::ScalarDefinition {
fn from(scalar_def: ScalarTypeDef) -> Self {
let mut new_scalar_def = Self::new(scalar_def.name.into());
if let Some(description) = scalar_def.description {
new_scalar_def.description(description.into());
}
scalar_def
.directives
.into_iter()
.for_each(|(_, directive)| new_scalar_def.directive(directive.into()));
if scalar_def.extend {
new_scalar_def.extend();
}
new_scalar_def
}
}
#[cfg(feature = "parser-impl")]
impl TryFrom<apollo_parser::cst::ScalarTypeDefinition> for ScalarTypeDef {
type Error = crate::FromError;
fn try_from(scalar_def: apollo_parser::cst::ScalarTypeDefinition) -> Result<Self, Self::Error> {
Ok(Self {
description: scalar_def
.description()
.and_then(|d| d.string_value())
.map(|s| Description::from(Into::<String>::into(s))),
name: scalar_def.name().unwrap().into(),
directives: scalar_def
.directives()
.map(Directive::convert_directives)
.transpose()?
.unwrap_or_default(),
extend: false,
})
}
}
#[cfg(feature = "parser-impl")]
impl TryFrom<apollo_parser::cst::ScalarTypeExtension> for ScalarTypeDef {
type Error = crate::FromError;
fn try_from(scalar_def: apollo_parser::cst::ScalarTypeExtension) -> Result<Self, Self::Error> {
Ok(Self {
description: None,
name: scalar_def.name().unwrap().into(),
directives: scalar_def
.directives()
.map(Directive::convert_directives)
.transpose()?
.unwrap_or_default(),
extend: true,
})
}
}
impl<'a> DocumentBuilder<'a> {
pub fn scalar_type_definition(&mut self) -> ArbitraryResult<ScalarTypeDef> {
let extend = !self.scalar_type_defs.is_empty() && self.u.arbitrary().unwrap_or(false);
let name = if extend {
let available_scalars: Vec<&Name> = self
.scalar_type_defs
.iter()
.filter_map(|scalar| {
if scalar.extend {
None
} else {
Some(&scalar.name)
}
})
.collect();
(*self.u.choose(&available_scalars)?).clone()
} else {
self.type_name()?
};
let description = self
.u
.arbitrary()
.unwrap_or(false)
.then(|| self.description())
.transpose()?;
let directives = self.directives(DirectiveLocation::Scalar)?;
let extend = !directives.is_empty() && self.u.arbitrary().unwrap_or(false);
Ok(ScalarTypeDef {
name,
description,
directives,
extend,
})
}
}