summaryrefslogtreecommitdiff
path: root/serde_dhall/src
diff options
context:
space:
mode:
authorNadrieril2020-03-21 21:30:30 +0000
committerNadrieril2020-03-31 21:44:01 +0100
commit85e2e8ee5e83dadd05b6974ba6c951350cb97a61 (patch)
tree637043ea591206f695c5b52b6625513de782ddcf /serde_dhall/src
parent110bfda418b7f1444a2d32b28c515c172a6572a2 (diff)
Introduce option builder
Diffstat (limited to 'serde_dhall/src')
-rw-r--r--serde_dhall/src/lib.rs16
-rw-r--r--serde_dhall/src/options.rs138
-rw-r--r--serde_dhall/src/value.rs32
3 files changed, 153 insertions, 33 deletions
diff --git a/serde_dhall/src/lib.rs b/serde_dhall/src/lib.rs
index 4b1a689..5b8f470 100644
--- a/serde_dhall/src/lib.rs
+++ b/serde_dhall/src/lib.rs
@@ -169,6 +169,8 @@
//! [serde::Deserialize]: https://docs.serde.rs/serde/trait.Deserialize.html
mod error;
+/// Finer-grained control over deserializing Dhall
+pub mod options;
mod serde;
/// Serde-compatible values and their type
pub mod simple;
@@ -198,14 +200,6 @@ pub trait Deserialize: sealed::Sealed + Sized {
fn from_dhall(v: &Value) -> Result<Self>;
}
-fn from_str_with_annot<T>(s: &str, ty: Option<&simple::Type>) -> Result<T>
-where
- T: Deserialize,
-{
- let val = Value::from_str_with_annot(s, ty)?;
- T::from_dhall(&val)
-}
-
/// Deserialize an instance of type `T` from a string of Dhall text.
///
/// This will recursively resolve all imports in the expression, and
@@ -216,7 +210,7 @@ pub fn from_str<T>(s: &str) -> Result<T>
where
T: Deserialize,
{
- from_str_with_annot(s, None)
+ options::from_str(s).parse()
}
/// Deserialize an instance of type `T` from a string of Dhall text,
@@ -228,7 +222,7 @@ pub fn from_str_check_type<T>(s: &str, ty: &simple::Type) -> Result<T>
where
T: Deserialize,
{
- from_str_with_annot(s, Some(ty))
+ options::from_str(s).type_annotation(ty).parse()
}
/// Deserialize an instance of type `T` from a string of Dhall text,
@@ -241,5 +235,5 @@ pub fn from_str_auto_type<T>(s: &str) -> Result<T>
where
T: Deserialize + StaticType,
{
- from_str_check_type(s, &<T as StaticType>::static_type())
+ options::from_str(s).static_type_annotation().parse()
}
diff --git a/serde_dhall/src/options.rs b/serde_dhall/src/options.rs
new file mode 100644
index 0000000..542804b
--- /dev/null
+++ b/serde_dhall/src/options.rs
@@ -0,0 +1,138 @@
+use std::path::{Path, PathBuf};
+
+use dhall::Parsed;
+
+use crate::simple::Type as SimpleType;
+use crate::{Deserialize, Error, Result, StaticType, Value};
+
+#[derive(Debug, Clone)]
+enum Source<'a> {
+ Str(&'a str),
+ File(PathBuf),
+ // Url(&'a str),
+}
+
+/// Options and flags which can be used to configure how a dhall value is read.
+///
+/// This builder exposes the ability to configure how a value is deserialized and what operations
+/// are permitted during evaluation. The functions in the crate root are aliases for
+/// commonly used options using this builder.
+///
+/// Generally speaking, when using `Options`, you'll create it with `from_str` or `from_file`, then
+/// chain calls to methods to set each option, then call `parse`. This will give you a
+/// `serde_dhall::Result<T>` where `T` a deserializable type of your choice.
+///
+/// # Examples
+///
+/// Reading from a file:
+///
+/// ```no_run
+/// # fn main() -> serde_dhall::Result<()> {
+/// use serde_dhall::options;
+///
+/// let data = options::from_file("foo.dhall").parse()?;
+/// # Ok(())
+/// # }
+/// ```
+///
+/// Reading from a file and checking the value against a provided type:
+///
+/// ```no_run
+/// # fn main() -> serde_dhall::Result<()> {
+/// use serde_dhall::options;
+///
+/// let ty = options::from_str("{ x: Natural, y: Natural }").parse()?;
+/// let data = options::from_file("foo.dhall")
+/// .type_annotation(&ty)
+/// .parse()?;
+/// # Ok(())
+/// # }
+/// ```
+#[derive(Debug, Clone)]
+pub struct Options<'a, T> {
+ source: Source<'a>,
+ annot: Option<SimpleType>,
+ allow_imports: bool,
+ // allow_remote_imports: bool,
+ // use_cache: bool,
+ target_type: std::marker::PhantomData<T>,
+}
+
+impl<'a, T> Options<'a, T> {
+ fn default_with_source(source: Source<'a>) -> Self {
+ Options {
+ source,
+ annot: None,
+ allow_imports: true,
+ // allow_remote_imports: true,
+ // use_cache: true,
+ target_type: std::marker::PhantomData,
+ }
+ }
+ fn from_str(s: &'a str) -> Self {
+ Self::default_with_source(Source::Str(s))
+ }
+ fn from_file<P: AsRef<Path>>(path: P) -> Self {
+ Self::default_with_source(Source::File(path.as_ref().to_owned()))
+ }
+ // fn from_url(url: &'a str) -> Self {
+ // Self::default_with_source(Source::Url(url))
+ // }
+
+ pub fn imports(&mut self, imports: bool) -> &mut Self {
+ self.allow_imports = imports;
+ self
+ }
+ // pub fn remote_imports(&mut self, imports: bool) -> &mut Self {
+ // self.allow_remote_imports = imports;
+ // if imports {
+ // self.allow_imports = true;
+ // }
+ // self
+ // }
+ pub fn type_annotation(&mut self, ty: &SimpleType) -> &mut Self {
+ self.annot = Some(ty.clone());
+ self
+ }
+ pub fn static_type_annotation(&mut self) -> &mut Self
+ where
+ T: StaticType,
+ {
+ self.annot = Some(T::static_type());
+ self
+ }
+
+ fn _parse(&self) -> dhall::error::Result<Value> {
+ let parsed = match &self.source {
+ Source::Str(s) => Parsed::parse_str(s)?,
+ Source::File(p) => Parsed::parse_file(p.as_ref())?,
+ };
+ let resolved = if self.allow_imports {
+ parsed.resolve()?
+ } else {
+ parsed.skip_resolve()?
+ };
+ let typed = match &self.annot {
+ None => resolved.typecheck()?,
+ Some(ty) => resolved.typecheck_with(&ty.to_value().hir)?,
+ };
+ Ok(Value::from_nir(typed.normalize().as_nir()))
+ }
+ pub fn parse(&self) -> Result<T>
+ where
+ T: Deserialize,
+ {
+ let val = self._parse().map_err(Error::Dhall)?;
+ T::from_dhall(&val)
+ }
+}
+
+pub fn from_str<'a, T>(s: &'a str) -> Options<'a, T> {
+ Options::from_str(s)
+}
+pub fn from_file<'a, T, P: AsRef<Path>>(path: P) -> Options<'a, T> {
+ Options::from_file(path)
+}
+// pub fn from_url<'a, T>(url: &'a str) -> Options<'a, T> {
+// Options::from_url(url)
+// }
diff --git a/serde_dhall/src/value.rs b/serde_dhall/src/value.rs
index 62632e5..d4ded90 100644
--- a/serde_dhall/src/value.rs
+++ b/serde_dhall/src/value.rs
@@ -1,9 +1,8 @@
use dhall::semantics::{Hir, Nir};
use dhall::syntax::Expr;
-use dhall::Parsed;
use crate::simple::{Type as SimpleType, Value as SimpleValue};
-use crate::Error;
+use crate::{sealed::Sealed, Deserialize, Error};
/// An arbitrary Dhall value.
#[derive(Debug, Clone)]
@@ -17,32 +16,13 @@ pub struct Value {
}
impl Value {
- /// Parse a string into a Value, and optionally ensure that the value matches the provided type
- /// annotation.
- pub fn from_str_with_annot(
- s: &str,
- ty: Option<&SimpleType>,
- ) -> Result<Self, Error> {
- Self::from_str_with_annot_dhall_error(s, ty).map_err(Error::Dhall)
- }
- fn from_nir(x: &Nir) -> Self {
+ pub(crate) fn from_nir(x: &Nir) -> Self {
Value {
hir: x.to_hir_noenv(),
as_simple_val: SimpleValue::from_nir(x),
as_simple_ty: SimpleType::from_nir(x),
}
}
- fn from_str_with_annot_dhall_error(
- s: &str,
- ty: Option<&SimpleType>,
- ) -> Result<Self, dhall::error::Error> {
- let resolved = Parsed::parse_str(s)?.resolve()?;
- let typed = match ty {
- None => resolved.typecheck()?,
- Some(ty) => resolved.typecheck_with(&ty.to_value().hir)?,
- };
- Ok(Self::from_nir(typed.normalize().as_nir()))
- }
/// Converts a Value into a SimpleValue.
pub fn to_simple_value(&self) -> Option<SimpleValue> {
@@ -70,3 +50,11 @@ impl std::fmt::Display for Value {
self.to_expr().fmt(f)
}
}
+
+impl Sealed for Value {}
+
+impl Deserialize for Value {
+ fn from_dhall(v: &Value) -> Result<Self, Error> {
+ Ok(v.clone())
+ }
+}