Introduce option builder

4 files changed, 155 insertions, 33 deletions

diff --git a/serde_dhall/Cargo.toml b/serde_dhall/Cargo.toml
index 0ec792a..71a9b02 100644
--- a/serde_dhall/Cargo.toml
+++ b/serde_dhall/Cargo.toml
@@ -13,3 +13,5 @@ edition = "2018"
 serde = { version = "1.0", features = ["derive"] }
 dhall = { version = "=0.4.0", path = "../dhall" }
 dhall_proc_macros = { version = "=0.4.0", path = "../dhall_proc_macros" }
+reqwest = { version = "0.10", features = ["blocking"] }
+url = "2.1"
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())
+    }
+}