Cleanup after simplifying promises

src/ability.rs

@@ -33,10 +33,6 @@
 //! field may include a promise pointing at another invocation. Once fully
 //! resolved ("ready"), they must be validatable against the delegation chain.
 
-// FIXME feature flag each?
-// FIXME ability implementers guide (e.g. serde deny fields)
-//
-
 pub mod ucan;
 
 #[cfg(feature = "ability-crud")]
@@ -53,12 +49,9 @@ pub mod preset;
 
 pub mod arguments;
 pub mod command;
+pub mod parse;
 
 #[cfg(target_arch = "wasm32")]
 pub mod js;
 
-// // TODO move to crate::wasm? or hide behind "dynamic" feature flag?
 pub mod dynamic;
-
-// FIXME macro to derive promise versions & delagted builder versions
-// ... also maybe Ipld

src/ability/arguments/named.rs

@@ -1,4 +1,4 @@
-use crate::ipld;
+use crate::{invocation::promise::Pending, ipld};
 use libipld_core::ipld::Ipld;
 use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
@@ -293,20 +293,14 @@ impl From<Named<Ipld>> for Named<ipld::Promised> {
 }
 
 impl TryFrom<Named<ipld::Promised>> for Named<Ipld> {
-    type Error = Named<ipld::Promised>;
+    type Error = Pending;
 
     fn try_from(named: Named<ipld::Promised>) -> Result<Self, Self::Error> {
-        // FIXME lots of clone
-        // FIXME idea: what if they implemet a is_resoled, and then the try_from?
-        // This lets us check by ref, and then do the conversion and unwrap
-        named
-            .iter()
-            .try_fold(Named::new(), |mut acc, (ref k, v)| {
-                let ipld = v.clone().try_into().map_err(|_| ())?;
-                acc.insert(k.to_string(), ipld);
-                Ok(acc)
-            })
-            .map_err(|()| named.clone())
+        named.iter().try_fold(Named::new(), |mut acc, (ref k, v)| {
+            let ipld = v.clone().try_into()?;
+            acc.insert(k.to_string(), ipld);
+            Ok(acc)
+        })
     }
 }
 

src/ability/command.rs

@@ -16,11 +16,6 @@
 //! }
 //! ```
 
-use crate::ability::arguments;
-use libipld_core::ipld::Ipld;
-use std::fmt;
-use thiserror::Error;
-
 /// Attach a `cmd` field to a type
 ///
 /// Commands are the `cmd` field of a UCAN, and set the shape of the `args` field.
@@ -55,44 +50,6 @@ pub trait Command {
     const COMMAND: &'static str;
 }
 
-// FIXME definitely needs a better name
-// pub trait ParseAbility: TryFrom<arguments::Named<Ipld>> {
-pub trait ParseAbility: Sized {
-    type ArgsErr: fmt::Debug;
-
-    fn try_parse(
-        cmd: &str,
-        args: arguments::Named<Ipld>,
-    ) -> Result<Self, ParseAbilityError<Self::ArgsErr>>;
-}
-
-#[derive(Debug, Clone, Error)]
-pub enum ParseAbilityError<E> {
-    #[error("Unknown command: {0}")]
-    UnknownCommand(String),
-
-    #[error(transparent)]
-    InvalidArgs(#[from] E),
-}
-
-impl<T: Command + TryFrom<arguments::Named<Ipld>>> ParseAbility for T
-where
-    <T as TryFrom<arguments::Named<Ipld>>>::Error: fmt::Debug,
-{
-    type ArgsErr = <T as TryFrom<arguments::Named<Ipld>>>::Error;
-
-    fn try_parse(
-        cmd: &str,
-        args: arguments::Named<Ipld>,
-    ) -> Result<Self, ParseAbilityError<<Self as TryFrom<arguments::Named<Ipld>>>::Error>> {
-        if cmd != T::COMMAND {
-            return Err(ParseAbilityError::UnknownCommand(cmd.to_string()));
-        }
-
-        Self::try_from(args).map_err(ParseAbilityError::InvalidArgs)
-    }
-}
-
 // NOTE do not export; this is used to limit the Hierarchy
 // interface to [Parentful] and [Parentless] while enabling [Dynamic]
 // FIXME ^^^^ NOT ANYMORE?

src/ability/crud.rs

@@ -54,7 +54,8 @@ pub use parents::*;
 use crate::{
     ability::{
         arguments,
-        command::{ParseAbility, ParseAbilityError, ToCommand},
+        command::ToCommand,
+        parse::{ParseAbility, ParseAbilityError, ParsePromised},
     },
     delegation::Delegable,
     invocation::promise::Resolvable,
@@ -90,6 +91,49 @@ pub enum Promised {
     Destroy(destroy::Promised),
 }
 
+impl ParsePromised for Promised {
+    type PromisedArgsError = ();
+
+    fn try_parse_promised(
+        cmd: &str,
+        args: arguments::Named<ipld::Promised>,
+    ) -> Result<Self, ParseAbilityError<Self::PromisedArgsError>> {
+        match create::Promised::try_parse_promised(cmd, args.clone()) {
+            Ok(create) => return Ok(Promised::Create(create)),
+            Err(ParseAbilityError::InvalidArgs(_)) => {
+                return Err(ParseAbilityError::InvalidArgs(()))
+            }
+            Err(ParseAbilityError::UnknownCommand(_)) => (),
+        }
+
+        match read::Promised::try_parse_promised(cmd, args.clone()) {
+            Ok(read) => return Ok(Promised::Read(read)),
+            Err(ParseAbilityError::InvalidArgs(_)) => {
+                return Err(ParseAbilityError::InvalidArgs(()))
+            }
+            Err(ParseAbilityError::UnknownCommand(_)) => (),
+        }
+
+        match update::Promised::try_parse_promised(cmd, args.clone()) {
+            Ok(update) => return Ok(Promised::Update(update)),
+            Err(ParseAbilityError::InvalidArgs(_)) => {
+                return Err(ParseAbilityError::InvalidArgs(()))
+            }
+            Err(ParseAbilityError::UnknownCommand(_)) => (),
+        }
+
+        match destroy::Promised::try_parse_promised(cmd, args) {
+            Ok(destroy) => return Ok(Promised::Destroy(destroy)),
+            Err(ParseAbilityError::InvalidArgs(_)) => {
+                return Err(ParseAbilityError::InvalidArgs(()))
+            }
+            Err(ParseAbilityError::UnknownCommand(_)) => (),
+        }
+
+        Err(ParseAbilityError::UnknownCommand(cmd.into()))
+    }
+}
+
 impl Delegable for Ready {
     type Builder = Builder;
 }

src/ability/crud/any.rs

@@ -1,10 +1,7 @@
 //! "Any" CRUD ability (superclass of all CRUD abilities)
 
 use crate::{
-    ability::{
-        arguments,
-        command::{Command, ParseAbility, ParseAbilityError},
-    },
+    ability::{arguments, command::Command},
     proof::{error::OptionalFieldError, parentless::NoParents, same::CheckSame},
 };
 use libipld_core::{error::SerdeError, ipld::Ipld, serde as ipld_serde};
@@ -95,21 +92,6 @@ impl TryFrom<arguments::Named<Ipld>> for Any {
 
 impl NoParents for Any {}
 
-// impl ParseAbility for Any {
-//     type ArgsErr = ();
-//
-//     fn try_parse(
-//         cmd: &str,
-//         args: arguments::Named<Ipld>,
-//     ) -> Result<Self, ParseAbilityError<Self::ArgsErr>> {
-//         if cmd != Self::COMMAND {
-//             return Err(ParseAbilityError::CommandMismatch);
-//         }
-//
-//         Self::try_from(args).map_err(|_| ParseAbilityError::Args(Self::COMMAND))
-//     }
-// }
-
 impl CheckSame for Any {
     type Error = OptionalFieldError;
 

src/ability/crud/create.rs

@@ -7,9 +7,9 @@ use crate::{
     ipld,
     proof::{checkable::Checkable, parentful::Parentful, parents::CheckParents, same::CheckSame},
 };
-use libipld_core::{cid::Cid, error::SerdeError, ipld::Ipld, serde as ipld_serde};
+use libipld_core::ipld::Ipld;
 use serde::Serialize;
-use std::{collections::BTreeMap, path::PathBuf};
+use std::path::PathBuf;
 
 // FIXME deserialize instance
 
@@ -123,31 +123,57 @@ impl Command for Promised {
     const COMMAND: &'static str = COMMAND;
 }
 
-// impl TryFrom<Ipld> for Ready {
-//     type Error = (); // FIXME
-//
-//     fn try_from(ipld: Ipld) -> Result<Self, Self::Error> {
-//         if let Ipld::Map(mut map) = ipld {
-//             if map.len() > 2 {
-//                 return Err(()); // FIXME
-//             }
-//
-//             Ok(Generic {
-//                 path: map
-//                     .remove("path")
-//                     .map(|ipld| P::try_from(ipld).map_err(|_| ()))
-//                     .transpose()?,
-//
-//                 args: map
-//                     .remove("args")
-//                     .map(|ipld| A::try_from(ipld).map_err(|_| ()))
-//                     .transpose()?,
-//             })
-//         } else {
-//             Err(()) // FIXME
-//         }
-//     }
-// }
+impl TryFrom<arguments::Named<ipld::Promised>> for Promised {
+    type Error = ();
+
+    fn try_from(arguments: arguments::Named<ipld::Promised>) -> Result<Self, Self::Error> {
+        let mut path = None;
+        let mut args = None;
+
+        for (k, prom) in arguments {
+            match k.as_str() {
+                "path" => match prom {
+                    ipld::Promised::String(s) => {
+                        path = Some(promise::Resolves::Ok(
+                            promise::PromiseOk::Fulfilled(PathBuf::from(s)).into(),
+                        ));
+                    }
+                    ipld::Promised::WaitOk(cid) => {
+                        path = Some(promise::PromiseOk::Pending(cid).into());
+                    }
+                    ipld::Promised::WaitErr(cid) => {
+                        path = Some(promise::PromiseErr::Pending(cid).into());
+                    }
+                    ipld::Promised::WaitAny(cid) => {
+                        todo!() // FIXME //  path = Some(promise::PromiseAny::Pending(cid).into());
+                    }
+                    _ => return Err(()),
+                },
+
+                "args" => {
+                    args = match prom {
+                        ipld::Promised::Map(map) => {
+                            Some(promise::PromiseOk::Fulfilled(arguments::Named(map)).into())
+                        }
+                        ipld::Promised::WaitOk(cid) => {
+                            Some(promise::PromiseOk::Pending(cid).into())
+                        }
+                        ipld::Promised::WaitErr(cid) => {
+                            Some(promise::PromiseErr::Pending(cid).into())
+                        }
+                        ipld::Promised::WaitAny(cid) => {
+                            todo!() // FIXME // Some(promise::PromiseAny::Pending(cid).into())
+                        }
+                        _ => return Err(()),
+                    }
+                }
+                _ => return Err(()),
+            }
+        }
+
+        Ok(Promised { path, args })
+    }
+}
 
 impl TryFrom<arguments::Named<Ipld>> for Ready {
     type Error = ();
@@ -254,18 +280,6 @@ impl From<Ready> for Promised {
     }
 }
 
-// FIXME may want to name this something other than a TryFrom
-//  impl From<Promised> for Builder {
-//      fn from(promised: Promised) -> Self {
-//          Builder {
-//              path: promised.path.and_then(|x| x.try_resolve().ok()),
-//              args: promised
-//                  .args
-//                  .and_then(|x| x.try_resolve().ok()?.try_into().ok()),
-//          }
-//      }
-//  }
-
 impl promise::Resolvable for Ready {
     type Promised = Promised;
 }

src/ability/crud/destroy.rs

@@ -1,4 +1,5 @@
 //! Destroy a resource.
+
 use super::parents::MutableParents;
 use crate::{
     ability::{arguments, command::Command},
@@ -9,9 +10,7 @@ use crate::{
 };
 use libipld_core::ipld::Ipld;
 use serde::Serialize;
-use std::{collections::BTreeMap, path::PathBuf};
-
-// FIXME deserialize instance
+use std::path::PathBuf;
 
 /// A helper for creating lifecycle instances of `crud/create` with the correct shape.
 #[derive(Debug, Clone, PartialEq, Serialize)]
@@ -101,6 +100,39 @@ pub struct Promised {
     pub path: Option<promise::Resolves<PathBuf>>,
 }
 
+impl TryFrom<arguments::Named<ipld::Promised>> for Promised {
+    type Error = ();
+
+    fn try_from(arguments: arguments::Named<ipld::Promised>) -> Result<Self, Self::Error> {
+        let mut path = None;
+
+        for (k, prom) in arguments {
+            match k.as_str() {
+                "path" => match prom {
+                    ipld::Promised::String(s) => {
+                        path = Some(promise::Resolves::Ok(
+                            promise::PromiseOk::Fulfilled(PathBuf::from(s)).into(),
+                        ));
+                    }
+                    ipld::Promised::WaitOk(cid) => {
+                        path = Some(promise::PromiseOk::Pending(cid).into());
+                    }
+                    ipld::Promised::WaitErr(cid) => {
+                        path = Some(promise::PromiseErr::Pending(cid).into());
+                    }
+                    ipld::Promised::WaitAny(cid) => {
+                        todo!() // FIXME //  path = Some(promise::PromiseAny::Pending(cid).into());
+                    }
+                    _ => return Err(()),
+                },
+                _ => return Err(()),
+            }
+        }
+
+        Ok(Promised { path })
+    }
+}
+
 const COMMAND: &'static str = "crud/destroy";
 
 impl Command for Ready {

src/ability/crud/parents.rs

@@ -8,7 +8,8 @@ use super::error::ParentError;
 use crate::{
     ability::{
         arguments,
-        command::{ParseAbility, ParseAbilityError, ToCommand},
+        command::ToCommand,
+        parse::{ParseAbility, ParseAbilityError},
     },
     proof::{parents::CheckParents, same::CheckSame},
 };