Move to YAML

Author: LMG

src/bin/josh-filter.rs

@@ -103,6 +103,7 @@ fn run_filter(args: Vec<String>) -> josh::JoshResult<i32> {
                 .long("check-permission")
                 .short("c"),
         )
+        .arg(clap::Arg::with_name("missing-permission").long("missing-permission"))
         .arg(
             clap::Arg::with_name("whitelist")
                 .long("whitelist")
@@ -272,13 +273,13 @@ fn run_filter(args: Vec<String>) -> josh::JoshResult<i32> {
         permissions_filter = josh::filter::make_permissions_filter(filterobj, whitelist, blacklist)
     }
 
-    let updated_refs = josh::filter_ref(
-        &transaction,
-        filterobj,
-        &src,
-        &t,
-        permissions_filter,
-    )?;
+    let missing_permissions = args.is_present("missing-permission");
+    if missing_permissions {
+        filterobj = permissions_filter;
+        permissions_filter = josh::filter::empty();
+    }
+
+    let updated_refs = josh::filter_ref(&transaction, filterobj, &src, &t, permissions_filter)?;
     if args.value_of("update") != Some("FILTERED_HEAD") && updated_refs == 0 {
         println!(
             "Warning: reference {} wasn't updated",

src/filter/mod.rs

@@ -29,6 +29,7 @@ impl std::fmt::Debug for Filter {
         return to_op(*self).fmt(f);
     }
 }
+
 pub fn nop() -> Filter {
     to_filter(Op::Nop)
 }

src/lib.rs

@@ -180,6 +180,7 @@ pub fn filter_ref(
             s
         } else {
             tracing::trace!("apply_to_commit (permissions)");
+            println!("perm {:?}", permissions);
 
             filter::apply_to_commit(permissions, &original_commit, &transaction)?
         };
@@ -197,6 +198,7 @@ pub fn filter_ref(
             }
         }
 
+        println!("filter {:?}", filterobj);
         let filter_commit = if let Some(s) = transaction.get_ref(filterobj, oid) {
             s
         } else {
@@ -324,39 +326,40 @@ pub fn get_acl(
 ) -> JoshResult<(filter::Filter, filter::Filter)> {
     let users =
         std::fs::read_to_string(users).map_err(|_| josh_error("failed to read users file"))?;
-    let users: Users = toml::from_str(&users)
+    let users: Users = serde_yaml::from_str(&users)
         .map_err(|err| josh_error(format!("failed to parse users file: {}", err).as_str()))?;
     let groups =
         std::fs::read_to_string(groups).map_err(|_| josh_error("failed to read groups file"))?;
-    let groups: Groups = toml::from_str(&groups)
+    let groups: Groups = serde_yaml::from_str(&groups)
         .map_err(|err| josh_error(format!("failed to parse groups file: {}", err).as_str()))?;
 
     return users
         .get(user)
         .and_then(|u| {
-            let mut whitelist = filter::nop();
+            let mut whitelist = filter::empty();
             let mut blacklist = filter::empty();
             for g in &u.groups {
-                let group_lists = groups.get(g.as_str()?).and_then(|group| {
-                    group.get(repo).and_then(|repo| {
-                        let w = filter::parse(&repo.whitelist);
-                        let b = filter::parse(&repo.blacklist);
+                let lists = groups.get(repo).and_then(|repo| {
+                    repo.get(g.as_str()?).and_then(|group| {
+                        let w = filter::parse(&group.whitelist);
+                        let b = filter::parse(&group.blacklist);
                         Some((w, b))
                     })
                 })?;
-                if let Err(e) = group_lists.0 {
+                if let Err(e) = lists.0 {
                     return Some(Err(JoshError(format!("Error parsing whitelist: {}", e))));
                 }
-                if let Err(e) = group_lists.1 {
+                if let Err(e) = lists.1 {
                     return Some(Err(JoshError(format!("Error parsing blacklist: {}", e))));
                 }
-                if let Ok(w) = group_lists.0 {
+                if let Ok(w) = lists.0 {
                     whitelist = filter::compose(whitelist, w);
                 }
-                if let Ok(b) = group_lists.1 {
+                if let Ok(b) = lists.1 {
                     blacklist = filter::compose(blacklist, b);
                 }
             }
+            println!("w: {:?}, b: {:?}", whitelist, blacklist);
             Some(Ok((whitelist, blacklist)))
         })
         .unwrap_or(Ok((filter::empty(), filter::nop())));