Significant progress on clap interface autogeneration.

src/object.rs

@@ -1,4 +1,3 @@
-use clap::{FromArgMatches, Subcommand};
 use microrm::prelude::*;
 use microrm::schema::datum::{Datum, DatumDiscriminatorRef};
 use microrm::schema::entity::{Entity, EntityID, EntityPartList, EntityPartVisitor};
@@ -6,6 +5,10 @@ use microrm::schema::entity::{Entity, EntityID, EntityPartList, EntityPartVisito
 use crate::schema::UIDCDatabase;
 use crate::UIDCError;
 
+mod clap_interface;
+
+pub use clap_interface::ClapInterface;
+
 mod role;
 mod user;
 
@@ -20,12 +23,25 @@ pub trait Object: Sized + Entity + std::fmt::Debug {
     fn db_object(db: &UIDCDatabase) -> &IDMap<Self>
     where
         Self: Sized;
-    fn build_uniques(strings: &Vec<String>) -> <Self::Uniques as EntityPartList>::DatumList;
 
     fn shortname(&self) -> &str;
 }
 
+/*
 pub trait ObjectExt: Sized + Object {
+    fn attach<L: Entity, R: Entity>(
+        ctx: impl Queryable<EntityOutput = L>,
+        local_uniques: <L::Uniques as EntityPartList>::DatumList,
+        relation: String,
+        remote_uniques: <R::Uniques as EntityPartList>::DatumList,
+    ) -> Result<(), UIDCError> {
+        ctx.count();
+        // ctx.unique(Self::build_uniques(&local_uniques));
+        // ctx.connect_to
+
+        Ok(())
+    }
+
     fn create(ctx: &impl Insertable<Self>, cp: &Self::CreateParameters) -> Result<(), UIDCError> {
         ctx.insert(Self::create_from_params(cp)?)?;
         Ok(())
@@ -112,142 +128,4 @@ pub trait ObjectExt: Sized + Object {
 }
 
 impl<T: Object + std::fmt::Debug> ObjectExt for T {}
-
-#[derive(Clone, Debug)]
-enum InterfaceVerb<O: ObjectExt> {
-    Attach,
-    Create(O::CreateParameters),
-    Delete(Vec<String>),
-    Detach,
-    ListAll,
-    Inspect(Vec<String>),
-}
-
-impl<O: ObjectExt> InterfaceVerb<O> {
-    fn from_matches(matches: &clap::ArgMatches) -> Result<Self, clap::Error> {
-        let (subcommand, matches) = matches
-            .subcommand()
-            .ok_or(clap::Error::new(clap::error::ErrorKind::MissingSubcommand))
-            .unwrap();
-
-        let parse_uniques = || {
-            struct UVisitor<'a>(&'a clap::ArgMatches, &'a mut Vec<String>);
-            impl<'a> EntityPartVisitor for UVisitor<'a> {
-                fn visit<EP: microrm::schema::entity::EntityPart>(&mut self) {
-                    self.1.push(
-                        self.0
-                            .get_one::<std::string::String>(EP::part_name())
-                            .unwrap()
-                            .clone(),
-                    );
-                }
-            }
-
-            let mut unique_values = vec![];
-            <O::Uniques as EntityPartList>::accept_part_visitor(&mut UVisitor(
-                matches,
-                &mut unique_values,
-            ));
-            unique_values
-        };
-
-        Ok(match subcommand {
-            "attach" => InterfaceVerb::Attach,
-            "create" => InterfaceVerb::Create(
-                <O::CreateParameters as clap::FromArgMatches>::from_arg_matches(matches)?,
-            ),
-            "delete" => InterfaceVerb::Delete(parse_uniques()),
-            "detach" => InterfaceVerb::Detach,
-            "list" => InterfaceVerb::ListAll,
-            "inspect" => InterfaceVerb::Inspect(parse_uniques()),
-            _ => unreachable!(),
-        })
-    }
-}
-
-#[derive(Debug)]
-pub struct ClapInterface<O: ObjectExt> {
-    verb: InterfaceVerb<O>,
-    // uniques: Vec<String>,
-    _ghost: std::marker::PhantomData<O>,
-}
-
-impl<O: ObjectExt> ClapInterface<O> {
-    pub fn perform(
-        &self,
-        query_ctx: impl microrm::prelude::Queryable<EntityOutput = O>,
-        insert_ctx: &impl microrm::prelude::Insertable<O>,
-    ) -> Result<(), UIDCError> {
-        match &self.verb {
-            InterfaceVerb::Attach => {
-                todo!()
-            }
-            InterfaceVerb::Create(params) => {
-                O::create(insert_ctx, &params)?;
-            }
-            InterfaceVerb::Delete(uniques) => {
-                O::delete(query_ctx, O::build_uniques(uniques))?;
-            }
-            InterfaceVerb::Detach => {
-                todo!()
-            }
-            InterfaceVerb::ListAll => {
-                O::list_all(query_ctx)?;
-            }
-            InterfaceVerb::Inspect(uniques) => {
-                O::inspect(query_ctx, O::build_uniques(uniques))?;
-            }
-        }
-        Ok(())
-    }
-
-    /// iterate across the list of unique parts (O::Uniques) and add args for each
-    fn add_uniques(mut cmd: clap::Command) -> clap::Command {
-        struct UVisitor<'a>(&'a mut clap::Command);
-        impl<'a> EntityPartVisitor for UVisitor<'a> {
-            fn visit<EP: microrm::schema::entity::EntityPart>(&mut self) {
-                let arg = clap::Arg::new(EP::part_name())
-                    .required(true)
-                    .help(EP::desc());
-                *self.0 = self.0.clone().arg(arg);
-            }
-        }
-
-        <O::Uniques as EntityPartList>::accept_part_visitor(&mut UVisitor(&mut cmd));
-
-        cmd
-    }
-}
-
-impl<O: ObjectExt> FromArgMatches for ClapInterface<O> {
-    fn from_arg_matches(matches: &clap::ArgMatches) -> Result<Self, clap::Error> {
-        let verb = InterfaceVerb::from_matches(matches);
-
-        Ok(Self {
-            verb: verb?,
-            _ghost: Default::default(),
-        })
-    }
-
-    fn update_from_arg_matches(&mut self, matches: &clap::ArgMatches) -> Result<(), clap::Error> {
-        todo!()
-    }
-}
-
-impl<O: ObjectExt> Subcommand for ClapInterface<O> {
-    fn has_subcommand(name: &str) -> bool {
-        todo!()
-    }
-
-    fn augment_subcommands(cmd: clap::Command) -> clap::Command {
-        cmd.subcommand(<O::CreateParameters as clap::CommandFactory>::command().name("create"))
-            .subcommand(Self::add_uniques(clap::Command::new("delete")))
-            .subcommand(Self::add_uniques(clap::Command::new("inspect")))
-            .subcommand(clap::Command::new("list"))
-            .subcommands(O::extra_commands())
-    }
-
-    fn augment_subcommands_for_update(cmd: clap::Command) -> clap::Command {
-        todo!()
-    }
-}
+*/

src/object/clap.rs

@@ -0,0 +1,131 @@
+use super::{Object,ObjectExt};
+
+#[derive(Debug)]
+pub struct ClapInterface<O: ObjectExt> {
+    verb: InterfaceVerb<O>,
+    _ghost: std::marker::PhantomData<O>,
+}
+
+impl<O: ObjectExt> ClapInterface<O> {
+    pub fn perform(
+        &self,
+        query_ctx: impl microrm::prelude::Queryable<EntityOutput = O>,
+        insert_ctx: &impl microrm::prelude::Insertable<O>,
+    ) -> Result<(), UIDCError> {
+        match &self.verb {
+            InterfaceVerb::Attach { relation, remote_uniques } => {
+                todo!()
+            }
+            InterfaceVerb::Create(params) => {
+                O::create(insert_ctx, &params)?;
+            }
+            InterfaceVerb::Delete(uniques) => {
+                O::delete(query_ctx, O::build_uniques(uniques))?;
+            }
+            InterfaceVerb::Detach => {
+                todo!()
+            }
+            InterfaceVerb::ListAll => {
+                O::list_all(query_ctx)?;
+            }
+            InterfaceVerb::Inspect(uniques) => {
+                O::inspect(query_ctx, O::build_uniques(uniques))?;
+            }
+        }
+        Ok(())
+    }
+
+    /// iterate across the list of unique parts (O::Uniques) and add args for each
+    fn add_uniques(mut cmd: clap::Command) -> clap::Command {
+        struct UVisitor<'a>(&'a mut clap::Command);
+        impl<'a> EntityPartVisitor for UVisitor<'a> {
+            fn visit<EP: microrm::schema::entity::EntityPart>(&mut self) {
+                let arg = clap::Arg::new(EP::part_name())
+                    .required(true)
+                    .help(EP::desc());
+                *self.0 = self.0.clone().arg(arg);
+            }
+        }
+
+        <O::Uniques as EntityPartList>::accept_part_visitor(&mut UVisitor(&mut cmd));
+
+        cmd
+    }
+
+    fn make_relation_subcommands() -> impl Iterator<Item = clap::Command> {
+        let mut out = vec![];
+
+        struct PartVisitor<'l>(&'l mut Vec<clap::Command>);
+        impl<'l> EntityPartVisitor for PartVisitor<'l> {
+            fn visit<EP: microrm::schema::entity::EntityPart>(&mut self) {
+                struct Discriminator<'l>(&'l mut Vec<clap::Command>, &'static str);
+
+                impl<'l> DatumDiscriminator for Discriminator<'l> {
+                    fn visit_entity_id<E: Entity>(&mut self) {}
+                    fn visit_serialized<T: serde::Serialize + serde::de::DeserializeOwned>(
+                        &mut self,
+                    ) {
+                    }
+                    fn visit_bare_field<T: Datum>(&mut self) {}
+                    fn visit_assoc_map<E: Entity>(&mut self) {
+                        self.0.push(clap::Command::new(self.1));
+                    }
+                    fn visit_assoc_domain<R: microrm::schema::Relation>(&mut self) {
+                        self.0.push(clap::Command::new(self.1));
+                    }
+                    fn visit_assoc_range<R: microrm::schema::Relation>(&mut self) {
+                        self.0.push(clap::Command::new(self.1));
+                    }
+                }
+
+                <EP::Datum as Datum>::accept_discriminator(&mut Discriminator(
+                    self.0,
+                    EP::part_name(),
+                ));
+            }
+        }
+
+        O::accept_part_visitor(&mut PartVisitor(&mut out));
+
+        out.into_iter()
+    }
+}
+
+impl<O: ObjectExt> FromArgMatches for ClapInterface<O> {
+    fn from_arg_matches(matches: &clap::ArgMatches) -> Result<Self, clap::Error> {
+        let verb = InterfaceVerb::from_matches(matches);
+
+        Ok(Self {
+            verb: verb?,
+            _ghost: Default::default(),
+        })
+    }
+
+    fn update_from_arg_matches(&mut self, matches: &clap::ArgMatches) -> Result<(), clap::Error> {
+        todo!()
+    }
+}
+
+impl<O: ObjectExt> Subcommand for ClapInterface<O> {
+    fn has_subcommand(name: &str) -> bool {
+        todo!()
+    }
+
+    fn augment_subcommands(cmd: clap::Command) -> clap::Command {
+        cmd.subcommand(
+            Self::add_uniques(clap::Command::new("attach"))
+                .subcommands(Self::make_relation_subcommands())
+                .subcommand_required(true),
+        )
+        .subcommand(<O::CreateParameters as clap::CommandFactory>::command().name("create"))
+        .subcommand(Self::add_uniques(clap::Command::new("delete")))
+        .subcommand(Self::add_uniques(clap::Command::new("inspect")))
+        .subcommand(clap::Command::new("list"))
+        .subcommands(O::extra_commands())
+    }
+
+    fn augment_subcommands_for_update(cmd: clap::Command) -> clap::Command {
+        todo!()
+    }
+}
+

src/object/clap_interface.rs

@@ -0,0 +1,326 @@
+use microrm::{
+    prelude::*,
+    schema::{
+        datum::{
+            ConcreteDatumList, DatumDiscriminatorRef, DatumList, QueryEquivalentList, StringQuery,
+        },
+        entity::EntityID,
+    },
+};
+
+use super::Object;
+use crate::UIDCError;
+use clap::{FromArgMatches, Subcommand};
+use microrm::schema::{
+    datum::{Datum, DatumDiscriminator},
+    entity::{Entity, EntityPartList, EntityPartVisitor},
+};
+
+/// iterate across the list of unique parts (E::Uniques) and add args for each
+fn add_uniques<E: Entity>(mut cmd: clap::Command) -> clap::Command {
+    struct UVisitor<'a>(&'a mut clap::Command);
+    impl<'a> EntityPartVisitor for UVisitor<'a> {
+        fn visit<EP: microrm::schema::entity::EntityPart>(&mut self) {
+            let arg = clap::Arg::new(EP::part_name())
+                .required(true)
+                .help(EP::desc());
+            *self.0 = self.0.clone().arg(arg);
+        }
+    }
+
+    <E::Uniques as EntityPartList>::accept_part_visitor(&mut UVisitor(&mut cmd));
+
+    cmd
+}
+
+fn collect_uniques<E: Entity>(matches: &clap::ArgMatches) -> Vec<String> {
+    struct UVisitor<'a>(&'a clap::ArgMatches, &'a mut Vec<String>);
+    impl<'a> EntityPartVisitor for UVisitor<'a> {
+        fn visit<EP: microrm::schema::entity::EntityPart>(&mut self) {
+            self.1.push(
+                self.0
+                    .get_one::<std::string::String>(EP::part_name())
+                    .unwrap()
+                    .clone(),
+            );
+        }
+    }
+
+    let mut unique_values = vec![];
+    <E::Uniques as EntityPartList>::accept_part_visitor(&mut UVisitor(matches, &mut unique_values));
+    unique_values
+}
+
+#[derive(Clone, Debug)]
+pub enum InterfaceVerb<O: Object> {
+    Attach {
+        local_uniques: Vec<String>,
+        relation: String,
+        remote_uniques: Vec<String>,
+    },
+    Create(O::CreateParameters),
+    Delete(Vec<String>),
+    Detach {
+        local_uniques: Vec<String>,
+        relation: String,
+        remote_uniques: Vec<String>,
+    },
+    ListAll,
+    Inspect(Vec<String>),
+}
+
+// helper alias for later
+type UniqueList<O> = <<O as Entity>::Uniques as EntityPartList>::DatumList;
+
+impl<O: Object> InterfaceVerb<O> {
+    fn parse_attachment(
+        matches: &clap::ArgMatches,
+    ) -> Result<(Vec<String>, String, Vec<String>), clap::Error> {
+        let local_uniques = collect_uniques::<O>(matches);
+
+        let (subcommand, submatches) = matches
+            .subcommand()
+            .ok_or(clap::Error::new(clap::error::ErrorKind::MissingSubcommand))?;
+
+        // find the relevant relation
+        struct RelationFinder<'l> {
+            subcommand: &'l str,
+            submatches: &'l clap::ArgMatches,
+            uniques: &'l mut Vec<String>,
+        }
+        impl<'l> EntityPartVisitor for RelationFinder<'l> {
+            fn visit<EP: microrm::schema::entity::EntityPart>(&mut self) {
+                if EP::part_name() != self.subcommand {
+                    return;
+                }
+
+                *self.uniques = collect_uniques::<EP::Entity>(self.submatches);
+            }
+        }
+
+        let mut remote_uniques = vec![];
+        O::accept_part_visitor(&mut RelationFinder {
+            subcommand,
+            submatches,
+            uniques: &mut remote_uniques,
+        });
+
+        Ok((local_uniques, subcommand.into(), remote_uniques))
+    }
+
+    fn from_matches(matches: &clap::ArgMatches) -> Result<Self, clap::Error> {
+        let (subcommand, matches) = matches
+            .subcommand()
+            .ok_or(clap::Error::new(clap::error::ErrorKind::MissingSubcommand))?;
+
+        Ok(match subcommand {
+            "attach" => {
+                let (local_uniques, relation, remote_uniques) = Self::parse_attachment(matches)?;
+                InterfaceVerb::Attach {
+                    local_uniques,
+                    relation,
+                    remote_uniques,
+                }
+            }
+            "create" => InterfaceVerb::Create(
+                <O::CreateParameters as clap::FromArgMatches>::from_arg_matches(matches)?,
+            ),
+            "delete" => InterfaceVerb::Delete(collect_uniques::<O>(matches)),
+            "detach" => {
+                let (local_uniques, relation, remote_uniques) = Self::parse_attachment(matches)?;
+                InterfaceVerb::Detach {
+                    local_uniques,
+                    relation,
+                    remote_uniques,
+                }
+            }
+            "list" => InterfaceVerb::ListAll,
+            "inspect" => InterfaceVerb::Inspect(collect_uniques::<O>(matches)),
+            _ => unreachable!(),
+        })
+    }
+}
+
+#[derive(Debug)]
+pub struct ClapInterface<O: Object> {
+    verb: InterfaceVerb<O>,
+    _ghost: std::marker::PhantomData<O>,
+}
+
+impl<O: Object> ClapInterface<O> {
+    pub fn perform(
+        &self,
+        query_ctx: impl microrm::prelude::Queryable<EntityOutput = O>,
+        insert_ctx: &impl microrm::prelude::Insertable<O>,
+    ) -> Result<(), UIDCError> {
+        match &self.verb {
+            InterfaceVerb::Attach {
+                local_uniques,
+                relation,
+                remote_uniques,
+            } => {
+                // O::attach(query_ctx, local_uniques, relation, remote_uniques)?;
+                todo!()
+            }
+            InterfaceVerb::Create(params) => {
+                insert_ctx.insert(O::create_from_params(params)?)?;
+            }
+            InterfaceVerb::Delete(uniques) => {
+                query_ctx
+                    .unique(UniqueList::<O>::build_equivalent(uniques.iter().map(String::as_str)).unwrap())
+                    .delete()?;
+            }
+            InterfaceVerb::Detach {
+                local_uniques,
+                relation,
+                remote_uniques,
+            } => {
+                todo!()
+            }
+            InterfaceVerb::ListAll => {
+                println!(
+                    "Listing all {}(s): ({})",
+                    O::entity_name(),
+                    query_ctx.clone().count()?
+                );
+                for obj in query_ctx.get()?.into_iter() {
+                    println!(" - {}", obj.shortname());
+                }
+            }
+            InterfaceVerb::Inspect(uniques) => {
+                let obj = query_ctx
+                    .unique(UniqueList::<O>::build_equivalent(uniques.iter().map(String::as_str)).unwrap())
+                    .get()?
+                    .ok_or(UIDCError::Abort("no such element, cannot inspect"))?;
+                println!("{:#?}", obj.as_ref());
+
+                fn inspect_ai<AI: AssocInterface>(name: &'static str, ai: &AI) {
+                    println!("{}: ({})", name, ai.count().unwrap());
+                    for a in ai.get().expect("couldn't get object associations") {
+                        println!("[#{:3}]: {:?}", a.id().into_raw(), a.wrapped());
+                    }
+                }
+
+                struct AssocFieldWalker;
+                impl EntityPartVisitor for AssocFieldWalker {
+                    fn visit_datum<EP: microrm::schema::entity::EntityPart>(
+                        &mut self,
+                        datum: &EP::Datum,
+                    ) {
+                        struct Discriminator<'l, D: Datum>(&'l D, &'static str);
+
+                        impl<'l, D: Datum> DatumDiscriminatorRef for Discriminator<'l, D> {
+                            fn visit_serialized<
+                                T: serde::Serialize + serde::de::DeserializeOwned,
+                            >(
+                                &mut self,
+                                _: &T,
+                            ) {
+                            }
+                            fn visit_bare_field<T: Datum>(&mut self, _: &T) {}
+                            fn visit_entity_id<E: Entity>(&mut self, _: &E::ID) {}
+                            fn visit_assoc_map<E: Entity>(&mut self, amap: &AssocMap<E>) {
+                                inspect_ai(self.1, amap);
+                            }
+                            fn visit_assoc_domain<R: microrm::schema::Relation>(
+                                &mut self,
+                                adomain: &microrm::schema::AssocDomain<R>,
+                            ) {
+                                inspect_ai(self.1, adomain);
+                            }
+                            fn visit_assoc_range<R: microrm::schema::Relation>(
+                                &mut self,
+                                arange: &microrm::schema::AssocRange<R>,
+                            ) {
+                                inspect_ai(self.1, arange);
+                            }
+                        }
+
+                        datum.accept_discriminator_ref(&mut Discriminator(datum, EP::part_name()));
+                    }
+                }
+
+                obj.accept_part_visitor_ref(&mut AssocFieldWalker);
+            }
+        }
+        Ok(())
+    }
+
+    fn make_relation_subcommands() -> impl Iterator<Item = clap::Command> {
+        let mut out = vec![];
+
+        struct PartVisitor<'l>(&'l mut Vec<clap::Command>);
+        impl<'l> EntityPartVisitor for PartVisitor<'l> {
+            fn visit<EP: microrm::schema::entity::EntityPart>(&mut self) {
+                struct Discriminator<'l>(&'l mut Vec<clap::Command>, &'static str);
+
+                impl<'l> DatumDiscriminator for Discriminator<'l> {
+                    fn visit_entity_id<E: Entity>(&mut self) {}
+                    fn visit_serialized<T: serde::Serialize + serde::de::DeserializeOwned>(
+                        &mut self,
+                    ) {
+                    }
+                    fn visit_bare_field<T: Datum>(&mut self) {}
+                    fn visit_assoc_map<E: Entity>(&mut self) {
+                        self.0.push(add_uniques::<E>(clap::Command::new(self.1)));
+                    }
+                    fn visit_assoc_domain<R: microrm::schema::Relation>(&mut self) {
+                        self.0
+                            .push(add_uniques::<R::Range>(clap::Command::new(self.1)));
+                    }
+                    fn visit_assoc_range<R: microrm::schema::Relation>(&mut self) {
+                        self.0
+                            .push(add_uniques::<R::Domain>(clap::Command::new(self.1)));
+                    }
+                }
+
+                <EP::Datum as Datum>::accept_discriminator(&mut Discriminator(
+                    self.0,
+                    EP::part_name(),
+                ));
+            }
+        }
+
+        O::accept_part_visitor(&mut PartVisitor(&mut out));
+
+        out.into_iter()
+    }
+}
+
+impl<O: Object> FromArgMatches for ClapInterface<O> {
+    fn from_arg_matches(matches: &clap::ArgMatches) -> Result<Self, clap::Error> {
+        let verb = InterfaceVerb::from_matches(matches);
+
+        Ok(Self {
+            verb: verb?,
+            _ghost: Default::default(),
+        })
+    }
+
+    fn update_from_arg_matches(&mut self, matches: &clap::ArgMatches) -> Result<(), clap::Error> {
+        todo!()
+    }
+}
+
+impl<O: Object> Subcommand for ClapInterface<O> {
+    fn has_subcommand(name: &str) -> bool {
+        todo!()
+    }
+
+    fn augment_subcommands(cmd: clap::Command) -> clap::Command {
+        cmd.subcommand(
+            add_uniques::<O>(clap::Command::new("attach"))
+                .subcommands(Self::make_relation_subcommands())
+                .subcommand_required(true),
+        )
+        .subcommand(<O::CreateParameters as clap::CommandFactory>::command().name("create"))
+        .subcommand(add_uniques::<O>(clap::Command::new("delete")))
+        .subcommand(add_uniques::<O>(clap::Command::new("inspect")))
+        .subcommand(clap::Command::new("list"))
+        .subcommands(O::extra_commands())
+    }
+
+    fn augment_subcommands_for_update(cmd: clap::Command) -> clap::Command {
+        todo!()
+    }
+}

src/object/role.rs

@@ -25,10 +25,6 @@ impl Object for schema::Role {
         todo!()
     }
 
-    fn build_uniques(strings: &Vec<String>) -> <Self::Uniques as EntityPartList>::DatumList {
-        strings[0].clone()
-    }
-
     fn shortname(&self) -> &str {
         &self.shortname
     }

src/object/user.rs

@@ -26,10 +26,6 @@ impl Object for schema::User {
         todo!()
     }
 
-    fn build_uniques(strings: &Vec<String>) -> <Self::Uniques as EntityPartList>::DatumList {
-        strings[0].clone()
-    }
-
     fn shortname(&self) -> &str {
         &self.username
     }