commit old work-in-progress

6 files changed, 1110 insertions, 437 deletions

diff --git a/rust/fatcat-cli/src/api.rs b/rust/fatcat-cli/src/api.rs
index 41718ea..3fa67e9 100644
--- a/rust/fatcat-cli/src/api.rs
+++ b/rust/fatcat-cli/src/api.rs
@@ -1,14 +1,18 @@
-
-use hyper::client::ResponseFuture;
-use fatcat_openapi::{ApiNoContext, ContextWrapperExt};
+use crate::{parse_macaroon_editor_id, ClientStatus, EntityType, Specifier};
+use anyhow::{anyhow, Context, Result};
 use fatcat_openapi::client::Client;
 use fatcat_openapi::models;
-use swagger::{AuthData, ContextBuilder, EmptyContext, Push, XSpanIdString, auth};
-use anyhow::{Result, anyhow, Context};
-use crate::{ClientStatus,parse_macaroon_editor_id,Specifier, EntityType};
+use fatcat_openapi::{ApiNoContext, ContextWrapperExt};
+use hyper::client::ResponseFuture;
+use swagger::{auth, AuthData, ContextBuilder, EmptyContext, Push, XSpanIdString};
 use tokio::runtime::current_thread::Runtime;
 
-type FatcatApiContextType = swagger::make_context_ty!( ContextBuilder, EmptyContext, Option<AuthData>, XSpanIdString);
+type FatcatApiContextType = swagger::make_context_ty!(
+    ContextBuilder,
+    EmptyContext,
+    Option<AuthData>,
+    XSpanIdString
+);
 
 pub struct FatcatApiClient<'a> {
     pub api: fatcat_openapi::ContextWrapper<'a, Client<ResponseFuture>, FatcatApiContextType>,
@@ -19,11 +23,15 @@ pub struct FatcatApiClient<'a> {
 }
 
 impl<'a> FatcatApiClient<'a> {
-
-    pub fn new(client: &'a fatcat_openapi::client::Client<ResponseFuture>, api_host: String, api_token: Option<String>) -> Result<Self> {
-
+    pub fn new(
+        client: &'a fatcat_openapi::client::Client<ResponseFuture>,
+        api_host: String,
+        api_token: Option<String>,
+    ) -> Result<Self> {
         let auth_data = match api_token {
-            Some(ref token) => Some(AuthData::Bearer(auth::Bearer{ token: token.clone() })),
+            Some(ref token) => Some(AuthData::Bearer(auth::Bearer {
+                token: token.clone(),
+            })),
             None => None,
         };
         //info!("{:?}", auth_data);
@@ -34,14 +42,19 @@ impl<'a> FatcatApiClient<'a> {
             XSpanIdString::default()
         );
 
-        let wrapped_client: fatcat_openapi::ContextWrapper<Client<ResponseFuture>, FatcatApiContextType> = client.with_context(context);
+        let wrapped_client: fatcat_openapi::ContextWrapper<
+            Client<ResponseFuture>,
+            FatcatApiContextType,
+        > = client.with_context(context);
         let rt: Runtime = Runtime::new().expect("create tokio runtime");
 
         let editor_id = match api_token {
-            Some(ref token) => Some(parse_macaroon_editor_id(token).context("parse API auth token")?),
+            Some(ref token) => {
+                Some(parse_macaroon_editor_id(token).context("parse API auth token")?)
+            }
             None => None,
         };
-        
+
         Ok(FatcatApiClient {
             api: wrapped_client,
             rt,
@@ -53,20 +66,40 @@ impl<'a> FatcatApiClient<'a> {
 
     pub fn status(&mut self) -> Result<ClientStatus> {
         let last_changelog = match self.rt.block_on(self.api.get_changelog(Some(1))) {
-            Ok(fatcat_openapi::GetChangelogResponse::Success(entry_vec)) => Some(entry_vec[0].index),
+            Ok(fatcat_openapi::GetChangelogResponse::Success(entry_vec)) => {
+                Some(entry_vec[0].index)
+            }
             Ok(_) | Err(_) => None,
         };
         let has_api_token = self.api_token.is_some();
         let account: Option<models::Editor> = if has_api_token && last_changelog.is_some() {
-            match self.rt.block_on(self.api.auth_check(None)).context("check auth token")? {
+            match self
+                .rt
+                .block_on(self.api.auth_check(None))
+                .context("check auth token")?
+            {
                 fatcat_openapi::AuthCheckResponse::Success(_) => Ok(()),
-                fatcat_openapi::AuthCheckResponse::Forbidden(err) => Err(anyhow!("Forbidden ({}): {}", err.error, err.message)),
-                fatcat_openapi::AuthCheckResponse::NotAuthorized{body: err, ..} => Err(anyhow!("Bad Request ({}): {}", err.error, err.message)),
+                fatcat_openapi::AuthCheckResponse::Forbidden(err) => {
+                    Err(anyhow!("Forbidden ({}): {}", err.error, err.message))
+                }
+                fatcat_openapi::AuthCheckResponse::NotAuthorized { body: err, .. } => {
+                    Err(anyhow!("Bad Request ({}): {}", err.error, err.message))
+                }
                 resp => return Err(anyhow!("{:?}", resp)).context("auth check failed"),
-            }.context("check auth token")?;
-            match self.rt.block_on(self.api.get_editor(self.editor_id.as_ref().unwrap().to_string())).context("fetching editor account info")? {
+            }
+            .context("check auth token")?;
+            match self
+                .rt
+                .block_on(
+                    self.api
+                        .get_editor(self.editor_id.as_ref().unwrap().to_string()),
+                )
+                .context("fetching editor account info")?
+            {
                 fatcat_openapi::GetEditorResponse::Found(editor) => Some(editor),
-                fatcat_openapi::GetEditorResponse::NotFound(err) => return Err(anyhow!("Not Found: {}", err.message)),
+                fatcat_openapi::GetEditorResponse::NotFound(err) => {
+                    return Err(anyhow!("Not Found: {}", err.message))
+                }
                 resp => return Err(anyhow!("{:?}", resp)).context("editor fetch failed"),
             }
         } else {
@@ -80,18 +113,29 @@ impl<'a> FatcatApiClient<'a> {
         })
     }
 
-    pub fn update_editgroup_submit(&mut self, editgroup_id: String, submit: bool) -> Result<models::Editgroup> {
-        let result = self.rt.block_on(
-            self.api.get_editgroup(editgroup_id.clone())
-        ).context("fetch editgroups")?;
+    pub fn update_editgroup_submit(
+        &mut self,
+        editgroup_id: String,
+        submit: bool,
+    ) -> Result<models::Editgroup> {
+        let result = self
+            .rt
+            .block_on(self.api.get_editgroup(editgroup_id.clone()))
+            .context("fetch editgroups")?;
         let eg = match result {
             fatcat_openapi::GetEditgroupResponse::Found(eg) => eg,
-            other => return Err(anyhow!("{:?}", other))
-                .with_context(|| format!("failed to fetch editgroup {}", editgroup_id)),
+            other => {
+                return Err(anyhow!("{:?}", other))
+                    .with_context(|| format!("failed to fetch editgroup {}", editgroup_id))
+            }
         };
-        let result = self.rt.block_on(
-            self.api.update_editgroup(editgroup_id.clone(), eg, Some(submit))
-        ).context("submit editgroup")?;
+        let result = self
+            .rt
+            .block_on(
+                self.api
+                    .update_editgroup(editgroup_id.clone(), eg, Some(submit)),
+            )
+            .context("submit editgroup")?;
         match result {
             fatcat_openapi::UpdateEditgroupResponse::UpdatedEditgroup(eg) => Ok(eg),
             other => Err(anyhow!("{:?}", other))
@@ -99,11 +143,18 @@ impl<'a> FatcatApiClient<'a> {
         }
     }
 
-    pub fn delete_entity(&mut self, specifier: Specifier, editgroup_id: String) -> Result<models::EntityEdit> {
+    pub fn delete_entity(
+        &mut self,
+        specifier: Specifier,
+        editgroup_id: String,
+    ) -> Result<models::EntityEdit> {
         use Specifier::*;
         let specifier = specifier.into_entity_specifier(self)?;
         match specifier.clone() {
-            Release(fcid) => match self.rt.block_on(self.api.delete_release(editgroup_id, fcid))? {
+            Release(fcid) => match self
+                .rt
+                .block_on(self.api.delete_release(editgroup_id, fcid))?
+            {
                 fatcat_openapi::DeleteReleaseResponse::DeletedEntity(ee) => Ok(ee),
                 other => Err(anyhow!("{:?}", other)),
             },
@@ -111,11 +162,17 @@ impl<'a> FatcatApiClient<'a> {
                 fatcat_openapi::DeleteWorkResponse::DeletedEntity(ee) => Ok(ee),
                 other => Err(anyhow!("{:?}", other)),
             },
-            Container(fcid) => match self.rt.block_on(self.api.delete_container(editgroup_id, fcid))? {
+            Container(fcid) => match self
+                .rt
+                .block_on(self.api.delete_container(editgroup_id, fcid))?
+            {
                 fatcat_openapi::DeleteContainerResponse::DeletedEntity(ee) => Ok(ee),
                 other => Err(anyhow!("{:?}", other)),
             },
-            Creator(fcid) => match self.rt.block_on(self.api.delete_creator(editgroup_id, fcid))? {
+            Creator(fcid) => match self
+                .rt
+                .block_on(self.api.delete_creator(editgroup_id, fcid))?
+            {
                 fatcat_openapi::DeleteCreatorResponse::DeletedEntity(ee) => Ok(ee),
                 other => Err(anyhow!("{:?}", other)),
             },
@@ -123,104 +180,282 @@ impl<'a> FatcatApiClient<'a> {
                 fatcat_openapi::DeleteFileResponse::DeletedEntity(ee) => Ok(ee),
                 other => Err(anyhow!("{:?}", other)),
             },
-            FileSet(fcid) => match self.rt.block_on(self.api.delete_fileset(editgroup_id, fcid))? {
+            FileSet(fcid) => match self
+                .rt
+                .block_on(self.api.delete_fileset(editgroup_id, fcid))?
+            {
                 fatcat_openapi::DeleteFilesetResponse::DeletedEntity(ee) => Ok(ee),
                 other => Err(anyhow!("{:?}", other)),
             },
-            WebCapture(fcid) => match self.rt.block_on(self.api.delete_webcapture(editgroup_id, fcid))? {
+            WebCapture(fcid) => match self
+                .rt
+                .block_on(self.api.delete_webcapture(editgroup_id, fcid))?
+            {
                 fatcat_openapi::DeleteWebcaptureResponse::DeletedEntity(ee) => Ok(ee),
                 other => Err(anyhow!("{:?}", other)),
             },
             Editgroup(..) | Editor(..) => unimplemented!("deletion for this entity type"),
             Changelog(..) => return Err(anyhow!("mutating this entity type doesn't make sense")),
-            EditorUsername(..) | ReleaseLookup(..) | ContainerLookup(..) | FileLookup(..) | CreatorLookup(..) =>
-                return Err(anyhow!("into_entity_specifier() didn't work?")),
-        }.with_context(|| format!("failed to delete {:?}", specifier))
+            EditorUsername(..) | ReleaseLookup(..) | ContainerLookup(..) | FileLookup(..)
+            | CreatorLookup(..) => return Err(anyhow!("into_entity_specifier() didn't work?")),
+        }
+        .with_context(|| format!("failed to delete {:?}", specifier))
     }
 
-    pub fn create_entity_from_json(&mut self, entity_type: EntityType, json_str: &str, editgroup_id: String) -> Result<models::EntityEdit> {
+    pub fn create_entity_from_json(
+        &mut self,
+        entity_type: EntityType,
+        json_str: &str,
+        editgroup_id: String,
+    ) -> Result<models::EntityEdit> {
         match entity_type {
             EntityType::Release => {
-                match self.rt.block_on(self.api.create_release(editgroup_id, serde_json::from_str(&json_str)?))? {
+                match self.rt.block_on(
+                    self.api
+                        .create_release(editgroup_id, serde_json::from_str(&json_str)?),
+                )? {
                     fatcat_openapi::CreateReleaseResponse::CreatedEntity(ee) => Ok(ee),
                     other => Err(anyhow!("{:?}", other)),
                 }
-            },
+            }
             EntityType::Work => {
-                match self.rt.block_on(self.api.create_work(editgroup_id, serde_json::from_str(&json_str)?))? {
+                match self.rt.block_on(
+                    self.api
+                        .create_work(editgroup_id, serde_json::from_str(&json_str)?),
+                )? {
                     fatcat_openapi::CreateWorkResponse::CreatedEntity(ee) => Ok(ee),
                     other => Err(anyhow!("{:?}", other)),
                 }
-            },
+            }
             EntityType::Creator => {
-                match self.rt.block_on(self.api.create_creator(editgroup_id, serde_json::from_str(&json_str)?))? {
+                match self.rt.block_on(
+                    self.api
+                        .create_creator(editgroup_id, serde_json::from_str(&json_str)?),
+                )? {
                     fatcat_openapi::CreateCreatorResponse::CreatedEntity(ee) => Ok(ee),
                     other => Err(anyhow!("{:?}", other)),
                 }
-            },
+            }
             EntityType::Container => {
-                match self.rt.block_on(self.api.create_container(editgroup_id, serde_json::from_str(&json_str)?))? {
+                match self.rt.block_on(
+                    self.api
+                        .create_container(editgroup_id, serde_json::from_str(&json_str)?),
+                )? {
                     fatcat_openapi::CreateContainerResponse::CreatedEntity(ee) => Ok(ee),
                     other => Err(anyhow!("{:?}", other)),
                 }
-            },
+            }
             EntityType::File => {
-                match self.rt.block_on(self.api.create_file(editgroup_id, serde_json::from_str(&json_str)?))? {
+                match self.rt.block_on(
+                    self.api
+                        .create_file(editgroup_id, serde_json::from_str(&json_str)?),
+                )? {
                     fatcat_openapi::CreateFileResponse::CreatedEntity(ee) => Ok(ee),
                     other => Err(anyhow!("{:?}", other)),
                 }
-            },
+            }
             EntityType::FileSet => {
-                match self.rt.block_on(self.api.create_fileset(editgroup_id, serde_json::from_str(&json_str)?))? {
+                match self.rt.block_on(
+                    self.api
+                        .create_fileset(editgroup_id, serde_json::from_str(&json_str)?),
+                )? {
                     fatcat_openapi::CreateFilesetResponse::CreatedEntity(ee) => Ok(ee),
                     other => Err(anyhow!("{:?}", other)),
                 }
-            },
+            }
             EntityType::WebCapture => {
-                match self.rt.block_on(self.api.create_webcapture(editgroup_id, serde_json::from_str(&json_str)?))? {
+                match self.rt.block_on(
+                    self.api
+                        .create_webcapture(editgroup_id, serde_json::from_str(&json_str)?),
+                )? {
                     fatcat_openapi::CreateWebcaptureResponse::CreatedEntity(ee) => Ok(ee),
                     other => Err(anyhow!("{:?}", other)),
                 }
+            }
+        }
+        .with_context(|| format!("parsing and creating {:?} entity", entity_type))
+    }
+
+    pub fn existing_edit_in_editgroup(
+        &mut self,
+        editgroup: &models::Editgroup,
+        specifier: &Specifier,
+    ) -> Option<models::EntityEdit> {
+        use Specifier::*;
+        let (fcid, edit_list) = match specifier.clone() {
+            Release(fcid) => (fcid, editgroup.edits.as_ref().unwrap().releases.clone()),
+            Work(fcid) => (fcid, editgroup.edits.as_ref().unwrap().works.clone()),
+            Container(fcid) => (fcid, editgroup.edits.as_ref().unwrap().containers.clone()),
+            Creator(fcid) => (fcid, editgroup.edits.as_ref().unwrap().creators.clone()),
+            File(fcid) => (fcid, editgroup.edits.as_ref().unwrap().files.clone()),
+            FileSet(fcid) => (fcid, editgroup.edits.as_ref().unwrap().filesets.clone()),
+            WebCapture(fcid) => (fcid, editgroup.edits.as_ref().unwrap().webcaptures.clone()),
+            EditorUsername(..) | ReleaseLookup(..) | ContainerLookup(..) | FileLookup(..)
+            | CreatorLookup(..) | Editgroup(..) | Editor(..) | Changelog(..) => {
+                panic!("this entity type doesn't exist in editgroups")
+            }
+        };
+        for entity_edit in edit_list.unwrap() {
+            if entity_edit.ident == fcid {
+                return Some(entity_edit);
+            }
+        }
+        None
+    }
+
+    pub fn delete_editgroup_edit(
+        &mut self,
+        editgroup: &models::Editgroup,
+        specifier: &Specifier,
+        edit: &models::EntityEdit,
+    ) -> Result<()> {
+        use Specifier::*;
+        let editgroup_id = editgroup.editgroup_id.clone().unwrap();
+        let edit_id = edit.edit_id.clone();
+        match specifier.clone() {
+            Release(..) => match self
+                .rt
+                .block_on(self.api.delete_release_edit(editgroup_id, edit_id))?
+            {
+                fatcat_openapi::DeleteReleaseEditResponse::DeletedEdit(..) => Ok(()),
+                other => Err(anyhow!("{:?}", other)),
+            },
+            Work(..) => match self
+                .rt
+                .block_on(self.api.delete_work_edit(editgroup_id, edit_id))?
+            {
+                fatcat_openapi::DeleteWorkEditResponse::DeletedEdit(..) => Ok(()),
+                other => Err(anyhow!("{:?}", other)),
+            },
+            Container(..) => match self
+                .rt
+                .block_on(self.api.delete_container_edit(editgroup_id, edit_id))?
+            {
+                fatcat_openapi::DeleteContainerEditResponse::DeletedEdit(..) => Ok(()),
+                other => Err(anyhow!("{:?}", other)),
+            },
+            Creator(..) => match self
+                .rt
+                .block_on(self.api.delete_creator_edit(editgroup_id, edit_id))?
+            {
+                fatcat_openapi::DeleteCreatorEditResponse::DeletedEdit(..) => Ok(()),
+                other => Err(anyhow!("{:?}", other)),
+            },
+            File(..) => match self
+                .rt
+                .block_on(self.api.delete_file_edit(editgroup_id, edit_id))?
+            {
+                fatcat_openapi::DeleteFileEditResponse::DeletedEdit(..) => Ok(()),
+                other => Err(anyhow!("{:?}", other)),
+            },
+            FileSet(..) => match self
+                .rt
+                .block_on(self.api.delete_fileset_edit(editgroup_id, edit_id))?
+            {
+                fatcat_openapi::DeleteFilesetEditResponse::DeletedEdit(..) => Ok(()),
+                other => Err(anyhow!("{:?}", other)),
             },
-        }.with_context(|| format!("parsing and creating {:?} entity", entity_type))
+            WebCapture(..) => match self
+                .rt
+                .block_on(self.api.delete_webcapture_edit(editgroup_id, edit_id))?
+            {
+                fatcat_openapi::DeleteWebcaptureEditResponse::DeletedEdit(..) => Ok(()),
+                other => Err(anyhow!("{:?}", other)),
+            },
+            EditorUsername(..) | ReleaseLookup(..) | ContainerLookup(..) | FileLookup(..)
+            | CreatorLookup(..) | Editgroup(..) | Editor(..) | Changelog(..) => {
+                panic!("this entity type doesn't exist in editgroups")
+            }
+        }
     }
 
-    pub fn update_entity_from_json(&mut self, specifier: Specifier, json_str: &str, editgroup_id: String) -> Result<models::EntityEdit> {
+    pub fn update_entity_from_json(
+        &mut self,
+        specifier: Specifier,
+        json_str: &str,
+        editgroup_id: String,
+    ) -> Result<models::EntityEdit> {
         use Specifier::*;
         let specifier = specifier.into_entity_specifier(self)?;
+        let eg = match self
+            .rt
+            .block_on(self.api.get_editgroup(editgroup_id.clone()))?
+        {
+            fatcat_openapi::GetEditgroupResponse::Found(model) => Ok(model),
+            fatcat_openapi::GetEditgroupResponse::BadRequest(err) => {
+                Err(anyhow!("Bad Request ({}): {}", err.error, err.message))
+            }
+            fatcat_openapi::GetEditgroupResponse::NotFound(err) => {
+                Err(anyhow!("Not Found: {}", err.message))
+            }
+            resp => Err(anyhow!("{:?}", resp))
+                .with_context(|| format!("API GET failed: editgroup_{:?}", editgroup_id)),
+        }?;
+        if let Some(entity_edit) = self.existing_edit_in_editgroup(&eg, &specifier) {
+            self.delete_editgroup_edit(&eg, &specifier, &entity_edit)?;
+        };
         match specifier.clone() {
-            Release(fcid) => match self.rt.block_on(self.api.update_release(editgroup_id, fcid, serde_json::from_str(&json_str)?))? {
+            Release(fcid) => match self.rt.block_on(self.api.update_release(
+                editgroup_id,
+                fcid,
+                serde_json::from_str(&json_str)?,
+            ))? {
                 fatcat_openapi::UpdateReleaseResponse::UpdatedEntity(ee) => Ok(ee),
                 other => Err(anyhow!("{:?}", other)),
             },
-            Work(fcid) => match self.rt.block_on(self.api.update_work(editgroup_id, fcid, serde_json::from_str(&json_str)?))? {
+            Work(fcid) => match self.rt.block_on(self.api.update_work(
+                editgroup_id,
+                fcid,
+                serde_json::from_str(&json_str)?,
+            ))? {
                 fatcat_openapi::UpdateWorkResponse::UpdatedEntity(ee) => Ok(ee),
                 other => Err(anyhow!("{:?}", other)),
             },
-            Container(fcid) => match self.rt.block_on(self.api.update_container(editgroup_id, fcid, serde_json::from_str(&json_str)?))? {
+            Container(fcid) => match self.rt.block_on(self.api.update_container(
+                editgroup_id,
+                fcid,
+                serde_json::from_str(&json_str)?,
+            ))? {
                 fatcat_openapi::UpdateContainerResponse::UpdatedEntity(ee) => Ok(ee),
                 other => Err(anyhow!("{:?}", other)),
             },
-            Creator(fcid) => match self.rt.block_on(self.api.update_creator(editgroup_id, fcid, serde_json::from_str(&json_str)?))? {
+            Creator(fcid) => match self.rt.block_on(self.api.update_creator(
+                editgroup_id,
+                fcid,
+                serde_json::from_str(&json_str)?,
+            ))? {
                 fatcat_openapi::UpdateCreatorResponse::UpdatedEntity(ee) => Ok(ee),
                 other => Err(anyhow!("{:?}", other)),
             },
-            File(fcid) => match self.rt.block_on(self.api.update_file(editgroup_id, fcid, serde_json::from_str(&json_str)?))? {
+            File(fcid) => match self.rt.block_on(self.api.update_file(
+                editgroup_id,
+                fcid,
+                serde_json::from_str(&json_str)?,
+            ))? {
                 fatcat_openapi::UpdateFileResponse::UpdatedEntity(ee) => Ok(ee),
                 other => Err(anyhow!("{:?}", other)),
             },
-            FileSet(fcid) => match self.rt.block_on(self.api.update_fileset(editgroup_id, fcid, serde_json::from_str(&json_str)?))? {
+            FileSet(fcid) => match self.rt.block_on(self.api.update_fileset(
+                editgroup_id,
+                fcid,
+                serde_json::from_str(&json_str)?,
+            ))? {
                 fatcat_openapi::UpdateFilesetResponse::UpdatedEntity(ee) => Ok(ee),
                 other => Err(anyhow!("{:?}", other)),
             },
-            WebCapture(fcid) => match self.rt.block_on(self.api.update_webcapture(editgroup_id, fcid, serde_json::from_str(&json_str)?))? {
+            WebCapture(fcid) => match self.rt.block_on(self.api.update_webcapture(
+                editgroup_id,
+                fcid,
+                serde_json::from_str(&json_str)?,
+            ))? {
                 fatcat_openapi::UpdateWebcaptureResponse::UpdatedEntity(ee) => Ok(ee),
                 other => Err(anyhow!("{:?}", other)),
             },
             Editgroup(..) | Editor(..) => unimplemented!("updates for this entity type"),
             Changelog(..) => return Err(anyhow!("deleting this entity type doesn't make sense")),
-            EditorUsername(..) | ReleaseLookup(..) | ContainerLookup(..) | FileLookup(..) | CreatorLookup(..) =>
-                return Err(anyhow!("into_entity_specifier() didn't work?")),
-        }.with_context(|| format!("failed to update {:?}", specifier))
+            EditorUsername(..) | ReleaseLookup(..) | ContainerLookup(..) | FileLookup(..)
+            | CreatorLookup(..) => return Err(anyhow!("into_entity_specifier() didn't work?")),
+        }
+        .with_context(|| format!("failed to update {:?}", specifier))
     }
 }
diff --git a/rust/fatcat-cli/src/entities.rs b/rust/fatcat-cli/src/entities.rs
index c606d17..eee3946 100644
--- a/rust/fatcat-cli/src/entities.rs
+++ b/rust/fatcat-cli/src/entities.rs
@@ -1,11 +1,9 @@
-
-use std::str::FromStr;
-use anyhow::{Result, anyhow};
+use crate::Specifier;
+use anyhow::{anyhow, Result};
+use fatcat_openapi::models;
 use lazy_static::lazy_static;
 use regex::Regex;
-use fatcat_openapi::models;
-use crate::Specifier;
-
+use std::str::FromStr;
 
 #[derive(Debug, PartialEq, Clone)]
 pub struct Mutation {
@@ -22,7 +20,6 @@ impl FromStr for Mutation {
             static ref MUTATE_ENTITY_RE: Regex = Regex::new(r"^([a-z_]+)=(.*)$").unwrap();
         }
         if let Some(captures) = MUTATE_ENTITY_RE.captures(s) {
-            // XXX: Some() vs None for value
             return Ok(Mutation {
                 field: captures[1].to_string(),
                 value: match &captures[2] {
@@ -48,8 +45,7 @@ impl FromStr for Mutation {
  * - get by specifier
  */
 
-pub trait ApiEntityModel: ApiModelSer+ApiModelIdent+ApiModelMutate {
-}
+pub trait ApiEntityModel: ApiModelSer + ApiModelIdent + ApiModelMutate {}
 
 impl ApiEntityModel for models::ReleaseEntity {}
 impl ApiEntityModel for models::ContainerEntity {}
@@ -58,9 +54,9 @@ impl ApiEntityModel for models::WorkEntity {}
 impl ApiEntityModel for models::FileEntity {}
 impl ApiEntityModel for models::FilesetEntity {}
 impl ApiEntityModel for models::WebcaptureEntity {}
-impl ApiEntityModel for models::Editor{}
-impl ApiEntityModel for models::Editgroup{}
-impl ApiEntityModel for models::ChangelogEntry{}
+impl ApiEntityModel for models::Editor {}
+impl ApiEntityModel for models::Editgroup {}
+impl ApiEntityModel for models::ChangelogEntry {}
 
 pub trait ApiModelSer {
     fn to_json_string(&self) -> Result<String>;
@@ -68,7 +64,6 @@ pub trait ApiModelSer {
 }
 
 impl<T: serde::Serialize> ApiModelSer for T {
-
     fn to_json_string(&self) -> Result<String> {
         Ok(serde_json::to_string(self)?)
     }
@@ -85,20 +80,38 @@ pub trait ApiModelIdent {
 macro_rules! generic_entity_specifier {
     ($specifier_type:ident) => {
         fn specifier(&self) -> Specifier {
-            if let Some(fcid) = &self.ident { Specifier::$specifier_type(fcid.to_string()) } else { panic!("expected full entity") }
+            if let Some(fcid) = &self.ident {
+                Specifier::$specifier_type(fcid.to_string())
+            } else {
+                panic!("expected full entity")
+            }
         }
-    }
+    };
 }
 
-impl ApiModelIdent for models::ReleaseEntity { generic_entity_specifier!(Release); }
-impl ApiModelIdent for models::ContainerEntity { generic_entity_specifier!(Container); }
-impl ApiModelIdent for models::CreatorEntity { generic_entity_specifier!(Creator); }
-impl ApiModelIdent for models::WorkEntity { generic_entity_specifier!(Work); }
-impl ApiModelIdent for models::FileEntity { generic_entity_specifier!(File); }
-impl ApiModelIdent for models::FilesetEntity { generic_entity_specifier!(FileSet); }
-impl ApiModelIdent for models::WebcaptureEntity { generic_entity_specifier!(WebCapture); }
+impl ApiModelIdent for models::ReleaseEntity {
+    generic_entity_specifier!(Release);
+}
+impl ApiModelIdent for models::ContainerEntity {
+    generic_entity_specifier!(Container);
+}
+impl ApiModelIdent for models::CreatorEntity {
+    generic_entity_specifier!(Creator);
+}
+impl ApiModelIdent for models::WorkEntity {
+    generic_entity_specifier!(Work);
+}
+impl ApiModelIdent for models::FileEntity {
+    generic_entity_specifier!(File);
+}
+impl ApiModelIdent for models::FilesetEntity {
+    generic_entity_specifier!(FileSet);
+}
+impl ApiModelIdent for models::WebcaptureEntity {
+    generic_entity_specifier!(WebCapture);
+}
 
-impl ApiModelIdent for models::ChangelogEntry{
+impl ApiModelIdent for models::ChangelogEntry {
     fn specifier(&self) -> Specifier {
         Specifier::Changelog(self.index)
     }
@@ -106,13 +119,21 @@ impl ApiModelIdent for models::ChangelogEntry{
 
 impl ApiModelIdent for models::Editgroup {
     fn specifier(&self) -> Specifier {
-        if let Some(fcid) = &self.editgroup_id { Specifier::Editgroup(fcid.to_string()) } else { panic!("expected full entity") }
+        if let Some(fcid) = &self.editgroup_id {
+            Specifier::Editgroup(fcid.to_string())
+        } else {
+            panic!("expected full entity")
+        }
     }
 }
 
 impl ApiModelIdent for models::Editor {
     fn specifier(&self) -> Specifier {
-        if let Some(fcid) = &self.editor_id { Specifier::Editor(fcid.to_string()) } else { panic!("expected full entity") }
+        if let Some(fcid) = &self.editor_id {
+            Specifier::Editor(fcid.to_string())
+        } else {
+            panic!("expected full entity")
+        }
     }
 }
 
@@ -124,19 +145,45 @@ impl ApiModelMutate for models::ReleaseEntity {
     fn mutate(&mut self, mutations: Vec<Mutation>) -> Result<()> {
         for m in mutations {
             match (m.field.as_str(), m.value) {
-                ("title", val) => { self.title = val; },
-                ("subtitle", val) => { self.subtitle = val; },
-                ("container_id", val) => { self.container_id = val; },
-                ("work_id", val) => { self.work_id = val; },
-                ("release_type", val) => { self.release_type = val; },
-                ("release_stage", val) => { self.release_stage = val; },
-                ("withdrawn_status", val) => { self.withdrawn_status = val; },
-                ("license_slug", val) => { self.license_slug= val; },
-                ("volume", val) => { self.volume = val; },
-                ("issue", val) => { self.issue = val; },
-                ("number", val) => { self.number = val; },
-                ("publisher", val) => { self.publisher = val; },
-                ("language", val) => { self.language = val; },
+                ("title", val) => {
+                    self.title = val;
+                }
+                ("subtitle", val) => {
+                    self.subtitle = val;
+                }
+                ("container_id", val) => {
+                    self.container_id = val;
+                }
+                ("work_id", val) => {
+                    self.work_id = val;
+                }
+                ("release_type", val) => {
+                    self.release_type = val;
+                }
+                ("release_stage", val) => {
+                    self.release_stage = val;
+                }
+                ("withdrawn_status", val) => {
+                    self.withdrawn_status = val;
+                }
+                ("license_slug", val) => {
+                    self.license_slug = val;
+                }
+                ("volume", val) => {
+                    self.volume = val;
+                }
+                ("issue", val) => {
+                    self.issue = val;
+                }
+                ("number", val) => {
+                    self.number = val;
+                }
+                ("publisher", val) => {
+                    self.publisher = val;
+                }
+                ("language", val) => {
+                    self.language = val;
+                }
                 (field, _) => unimplemented!("setting field {} on a release", field),
             }
         }
@@ -148,10 +195,18 @@ impl ApiModelMutate for models::ContainerEntity {
     fn mutate(&mut self, mutations: Vec<Mutation>) -> Result<()> {
         for m in mutations {
             match (m.field.as_str(), m.value) {
-                ("name", val) => { self.name = val; },
-                ("container_type", val) => { self.container_type = val; },
-                ("publisher", val) => { self.publisher = val; },
-                ("issnl", val) => { self.issnl = val; },
+                ("name", val) => {
+                    self.name = val;
+                }
+                ("container_type", val) => {
+                    self.container_type = val;
+                }
+                ("publisher", val) => {
+                    self.publisher = val;
+                }
+                ("issnl", val) => {
+                    self.issnl = val;
+                }
                 (field, _) => unimplemented!("setting field {} on a container", field),
             }
         }
@@ -163,9 +218,15 @@ impl ApiModelMutate for models::CreatorEntity {
     fn mutate(&mut self, mutations: Vec<Mutation>) -> Result<()> {
         for m in mutations {
             match (m.field.as_str(), m.value) {
-                ("display_name", val) => { self.display_name = val; },
-                ("given_name", val) => { self.given_name = val; },
-                ("surname", val) => { self.surname = val; },
+                ("display_name", val) => {
+                    self.display_name = val;
+                }
+                ("given_name", val) => {
+                    self.given_name = val;
+                }
+                ("surname", val) => {
+                    self.surname = val;
+                }
                 (field, _) => unimplemented!("setting field {} on a creator", field),
             }
         }
@@ -183,12 +244,24 @@ impl ApiModelMutate for models::FileEntity {
     fn mutate(&mut self, mutations: Vec<Mutation>) -> Result<()> {
         for m in mutations {
             match (m.field.as_str(), m.value) {
-                ("size", Some(val)) => { self.size = Some(i64::from_str(&val)?); },
-                ("size", None) => { self.size = None; },
-                ("md5", val) => { self.md5 = val; },
-                ("sha1", val) => { self.sha1 = val; },
-                ("sha256", val) => { self.sha256 = val; },
-                ("mimetype", val) => { self.mimetype = val; },
+                ("size", Some(val)) => {
+                    self.size = Some(i64::from_str(&val)?);
+                }
+                ("size", None) => {
+                    self.size = None;
+                }
+                ("md5", val) => {
+                    self.md5 = val;
+                }
+                ("sha1", val) => {
+                    self.sha1 = val;
+                }
+                ("sha256", val) => {
+                    self.sha256 = val;
+                }
+                ("mimetype", val) => {
+                    self.mimetype = val;
+                }
                 (field, _) => unimplemented!("setting field {} on a file", field),
             }
         }
@@ -212,7 +285,9 @@ impl ApiModelMutate for models::Editor {
     fn mutate(&mut self, mutations: Vec<Mutation>) -> Result<()> {
         for m in mutations {
             match (m.field.as_str(), m.value) {
-                ("username", Some(val)) => { self.username = val; },
+                ("username", Some(val)) => {
+                    self.username = val;
+                }
                 (field, _) => unimplemented!("setting field {} on an editor", field),
             }
         }
@@ -224,7 +299,9 @@ impl ApiModelMutate for models::Editgroup {
     fn mutate(&mut self, mutations: Vec<Mutation>) -> Result<()> {
         for m in mutations {
             match (m.field.as_str(), m.value) {
-                ("description", val) => { self.description = val; },
+                ("description", val) => {
+                    self.description = val;
+                }
                 (field, _) => unimplemented!("setting field {} on an editgroup", field),
             }
         }
@@ -245,12 +322,26 @@ mod tests {
     #[test]
     fn test_mutation_from_str() -> () {
         assert!(Mutation::from_str("release_asdf").is_err());
-        assert_eq!(Mutation::from_str("title=blah").unwrap(),
-            Mutation { field: "title".to_string(), value: Some("blah".to_string()) });
-        assert_eq!(Mutation::from_str("title=").unwrap(),
-            Mutation { field: "title".to_string(), value: None });
-        assert_eq!(Mutation::from_str("title=string with spaces and stuff").unwrap(),
-            Mutation { field: "title".to_string(), value: Some("string with spaces and stuff".to_string()) });
+        assert_eq!(
+            Mutation::from_str("title=blah").unwrap(),
+            Mutation {
+                field: "title".to_string(),
+                value: Some("blah".to_string())
+            }
+        );
+        assert_eq!(
+            Mutation::from_str("title=").unwrap(),
+            Mutation {
+                field: "title".to_string(),
+                value: None
+            }
+        );
+        assert_eq!(
+            Mutation::from_str("title=string with spaces and stuff").unwrap(),
+            Mutation {
+                field: "title".to_string(),
+                value: Some("string with spaces and stuff".to_string())
+            }
+        );
     }
-
 }
diff --git a/rust/fatcat-cli/src/lib.rs b/rust/fatcat-cli/src/lib.rs
index 1fffd50..fc9f209 100644
--- a/rust/fatcat-cli/src/lib.rs
+++ b/rust/fatcat-cli/src/lib.rs
@@ -1,28 +1,27 @@
-
-use std::io::Read;
-use std::path::PathBuf;
-use std::io::BufRead;
-use tabwriter::TabWriter;
+use anyhow::{anyhow, Context, Result};
 use chrono_humanize::HumanTime;
-use anyhow::{Result, anyhow, Context};
-use std::io::Write;
-use termcolor::{ColorChoice, StandardStream, Color, ColorSpec, WriteColor};
 use data_encoding::BASE64;
-use macaroon::{Macaroon, Verifier};
 use fatcat_openapi::models;
 #[allow(unused_imports)]
-use log::{self,info,debug};
+use log::{self, debug, info};
+use macaroon::{Macaroon, Verifier};
+use std::io::BufRead;
+use std::io::Read;
+use std::io::Write;
+use std::path::PathBuf;
 use std::str::FromStr;
+use tabwriter::TabWriter;
+use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};
 
+mod api;
 mod entities;
 mod search;
 mod specifier;
-mod api;
 
-pub use entities::{ApiEntityModel,ApiModelSer,ApiModelIdent,Mutation};
-pub use specifier::Specifier;
 pub use api::FatcatApiClient;
+pub use entities::{ApiEntityModel, ApiModelIdent, ApiModelSer, Mutation};
 pub use search::crude_search;
+pub use specifier::Specifier;
 
 // Want to show:
 // - whether api_token found
@@ -39,16 +38,12 @@ pub struct ClientStatus {
 }
 
 impl ClientStatus {
-
     pub fn pretty_print(self) -> Result<()> {
-
-        let mut color_stdout = StandardStream::stdout(
-            if atty::is(atty::Stream::Stdout) {
-                ColorChoice::Auto
-            } else {
-                ColorChoice::Never
-            }
-        );
+        let mut color_stdout = StandardStream::stdout(if atty::is(atty::Stream::Stdout) {
+            ColorChoice::Auto
+        } else {
+            ColorChoice::Never
+        });
         let color_normal = ColorSpec::new();
         let mut color_bold = ColorSpec::new();
         color_bold.set_bold(true);
@@ -69,7 +64,7 @@ impl ClientStatus {
                 write!(&mut color_stdout, "{:>16}: ", "Last changelog")?;
                 color_stdout.set_color(&color_bold)?;
                 writeln!(&mut color_stdout, "{}", index)?;
-            },
+            }
             None => {
                 color_stdout.set_color(&color_sad)?;
                 writeln!(&mut color_stdout, " [Failed to connect]")?;
@@ -90,25 +85,32 @@ impl ClientStatus {
             color_stdout.set_color(&color_bold)?;
             write!(&mut color_stdout, "{}", editor.username)?;
             if editor.is_bot == Some(true) {
-                color_stdout.set_color(ColorSpec::new().set_fg(Some(Color::Blue)).set_bold(true))?;
+                color_stdout
+                    .set_color(ColorSpec::new().set_fg(Some(Color::Blue)).set_bold(true))?;
                 write!(&mut color_stdout, " [bot]")?;
             }
             if editor.is_admin == Some(true) {
-                color_stdout.set_color(ColorSpec::new().set_fg(Some(Color::Magenta)).set_bold(true))?;
+                color_stdout
+                    .set_color(ColorSpec::new().set_fg(Some(Color::Magenta)).set_bold(true))?;
                 write!(&mut color_stdout, " [admin]")?;
             }
             match editor.is_active {
                 Some(true) => {
                     color_stdout.set_color(&color_happy)?;
                     writeln!(&mut color_stdout, " [active]")?;
-                },
+                }
                 Some(false) | None => {
                     color_stdout.set_color(&color_sad)?;
                     writeln!(&mut color_stdout, " [disabled]")?;
-                },
+                }
             };
             color_stdout.set_color(&color_normal)?;
-            writeln!(&mut color_stdout, "{:>16}  editor_{}", "", editor.editor_id.unwrap())?;
+            writeln!(
+                &mut color_stdout,
+                "{:>16}  editor_{}",
+                "",
+                editor.editor_id.unwrap()
+            )?;
         };
         color_stdout.set_color(&color_normal)?;
         Ok(())
@@ -145,14 +147,25 @@ impl FromStr for EntityType {
 
 /// Takes a macaroon token (as base64-encoded string) and tries to parse out an editor id
 pub fn parse_macaroon_editor_id(s: &str) -> Result<String> {
-    let raw = BASE64.decode(s.as_bytes()).context("macaroon parsing failed")?;
-    let mac = Macaroon::deserialize(&raw).map_err(|err| anyhow!("macaroon deserialization failed: {:?}", err))?;
-    let mac = mac.validate().map_err(|err| anyhow!("macaroon validation failed: {:?}", err))?;
+    let raw = BASE64
+        .decode(s.as_bytes())
+        .context("macaroon parsing failed")?;
+    let mac = Macaroon::deserialize(&raw)
+        .map_err(|err| anyhow!("macaroon deserialization failed: {:?}", err))?;
+    let mac = mac
+        .validate()
+        .map_err(|err| anyhow!("macaroon validation failed: {:?}", err))?;
     let mut verifier = Verifier::new();
     let mut editor_id: Option<String> = None;
     for caveat in mac.first_party_caveats() {
         if caveat.predicate().starts_with("editor_id = ") {
-            editor_id = Some(caveat.predicate().get(12..).context("parsing macaroon")?.to_string());
+            editor_id = Some(
+                caveat
+                    .predicate()
+                    .get(12..)
+                    .context("parsing macaroon")?
+                    .to_string(),
+            );
             break;
         }
     }
@@ -171,14 +184,23 @@ pub fn print_editgroups(eg_list: Vec<models::Editgroup>, json: bool) -> Result<(
         }
     } else {
         let mut tw = TabWriter::new(std::io::stdout());
-        writeln!(tw, "editgroup_id\tchangelog_index\tcreated\tsubmitted\tdescription")?;
+        writeln!(
+            tw,
+            "editgroup_id\tchangelog_index\tcreated\tsubmitted\tdescription"
+        )?;
         for eg in eg_list {
-            writeln!(tw, "{}\t{}\t{}\t{}\t{}",
+            writeln!(
+                tw,
+                "{}\t{}\t{}\t{}\t{}",
                 eg.editgroup_id.unwrap(),
-                eg.changelog_index.map_or("-".to_string(), |v| v.to_string()),
-                eg.created.map_or("-".to_string(), |v| HumanTime::from(v).to_string()),
-                eg.submitted.map_or("-".to_string(), |v| HumanTime::from(v).to_string()),
-                eg.description.unwrap_or_else(|| "-".to_string()))?;
+                eg.changelog_index
+                    .map_or("-".to_string(), |v| v.to_string()),
+                eg.created
+                    .map_or("-".to_string(), |v| HumanTime::from(v).to_string()),
+                eg.submitted
+                    .map_or("-".to_string(), |v| HumanTime::from(v).to_string()),
+                eg.description.unwrap_or_else(|| "-".to_string())
+            )?;
         }
         tw.flush()?;
     }
@@ -196,22 +218,23 @@ pub fn read_entity_file(input_path: Option<PathBuf>) -> Result<String> {
             let mut line = String::new();
             std::io::stdin().read_line(&mut line)?;
             Ok(line)
-        },
+        }
         Some(path) if path.extension().map(|v| v.to_str()) == Some(Some("toml")) => {
             info!("reading {:?} as TOML", path);
             // as a hack, read TOML but then serialize it back to JSON
             let mut contents = String::new();
-            let mut input_file = std::fs::File::open(path).context("reading entity from TOML file")?;
+            let mut input_file =
+                std::fs::File::open(path).context("reading entity from TOML file")?;
             input_file.read_to_string(&mut contents)?;
             let value: toml::Value = contents.parse().context("parsing TOML file")?;
             Ok(serde_json::to_string(&value)?)
-        },
+        }
         Some(path) => {
             let mut line = String::new();
             let input_file = std::fs::File::open(path)?;
             let mut buffered = std::io::BufReader::new(input_file);
             buffered.read_line(&mut line)?;
             Ok(line)
-        },
+        }
     }
 }
diff --git a/rust/fatcat-cli/src/main.rs b/rust/fatcat-cli/src/main.rs
index 05b003d..ce12f9d 100644
--- a/rust/fatcat-cli/src/main.rs
+++ b/rust/fatcat-cli/src/main.rs
@@ -1,27 +1,36 @@
-
-use std::path::PathBuf;
+use anyhow::{anyhow, Context, Result};
 use fatcat_cli::ApiModelSer;
-use std::io::Write;
-use termcolor::{ColorChoice, StandardStream, Color, ColorSpec, WriteColor};
-use anyhow::{Result, Context, anyhow};
-#[allow(unused_imports)]
-use log::{self,info,debug};
-use structopt::StructOpt;
 use fatcat_cli::*;
 use fatcat_openapi::{client, models, ApiNoContext};
-
+#[allow(unused_imports)]
+use log::{self, debug, info};
+use std::io::Write;
+use std::path::PathBuf;
+use structopt::StructOpt;
+use termcolor::{Color, ColorChoice, ColorSpec, StandardStream, WriteColor};
 
 #[derive(StructOpt)]
-#[structopt(rename_all = "kebab-case", about = "CLI interface to Fatcat API" )]
+#[structopt(rename_all = "kebab-case", about = "CLI interface to Fatcat API")]
 struct Opt {
-
-    #[structopt(long = "--api-host", env = "FATCAT_API_HOST", default_value = "https://api.fatcat.wiki")]
+    #[structopt(
+        long = "--api-host",
+        env = "FATCAT_API_HOST",
+        default_value = "https://api.fatcat.wiki"
+    )]
     api_host: String,
 
-    #[structopt(long = "--api-token", env = "FATCAT_API_AUTH_TOKEN", hide_env_values = true)]
+    #[structopt(
+        long = "--api-token",
+        env = "FATCAT_API_AUTH_TOKEN",
+        hide_env_values = true
+    )]
     api_token: Option<String>,
 
-    #[structopt(long = "--search-host", env = "FATCAT_SEARCH_HOST", default_value = "https://search.fatcat.wiki")]
+    #[structopt(
+        long = "--search-host",
+        env = "FATCAT_SEARCH_HOST",
+        default_value = "https://search.fatcat.wiki"
+    )]
     search_host: String,
 
     /// Pass many times for more log output
@@ -97,7 +106,12 @@ enum Command {
         #[structopt(long = "--file", short = "-f", parse(from_os_str))]
         input_path: Option<PathBuf>,
 
-        #[structopt(long = "--editgroup-id", short, env = "FATCAT_EDITGROUP", hide_env_values = true)]
+        #[structopt(
+            long = "--editgroup-id",
+            short,
+            env = "FATCAT_EDITGROUP",
+            hide_env_values = true
+        )]
         editgroup_id: String,
     },
     Update {
@@ -107,7 +121,12 @@ enum Command {
         #[structopt(long = "--file", short = "-f", parse(from_os_str))]
         input_path: Option<PathBuf>,
 
-        #[structopt(long = "--editgroup-id", short, env = "FATCAT_EDITGROUP", hide_env_values = true)]
+        #[structopt(
+            long = "--editgroup-id",
+            short,
+            env = "FATCAT_EDITGROUP",
+            hide_env_values = true
+        )]
         editgroup_id: String,
 
         mutations: Vec<Mutation>,
@@ -115,7 +134,12 @@ enum Command {
     Edit {
         specifier: Specifier,
 
-        #[structopt(long = "--editgroup-id", short, env = "FATCAT_EDITGROUP", hide_env_values = true)]
+        #[structopt(
+            long = "--editgroup-id",
+            short,
+            env = "FATCAT_EDITGROUP",
+            hide_env_values = true
+        )]
         editgroup_id: String,
 
         #[structopt(long)]
@@ -127,7 +151,12 @@ enum Command {
     Delete {
         specifier: Specifier,
 
-        #[structopt(long = "--editgroup-id", short, env = "FATCAT_EDITGROUP", hide_env_values = true)]
+        #[structopt(
+            long = "--editgroup-id",
+            short,
+            env = "FATCAT_EDITGROUP",
+            hide_env_values = true
+        )]
         editgroup_id: String,
     },
     Editgroup {
@@ -138,7 +167,6 @@ enum Command {
     //Download
     //History
     Search {
-
         entity_type: EntityType,
 
         terms: Vec<String>,
@@ -186,13 +214,11 @@ fn main() -> Result<()> {
                 std::process::exit(0);
             }
         }
-        let mut color_stderr = StandardStream::stderr(
-            if atty::is(atty::Stream::Stderr) {
-                ColorChoice::Auto
-            } else {
-                ColorChoice::Never
-            }
-        );
+        let mut color_stderr = StandardStream::stderr(if atty::is(atty::Stream::Stderr) {
+            ColorChoice::Auto
+        } else {
+            ColorChoice::Never
+        });
         color_stderr.set_color(ColorSpec::new().set_fg(Some(Color::Red)).set_bold(true))?;
         eprintln!("Error: {:?}", err);
         color_stderr.set_color(&ColorSpec::new())?;
@@ -212,46 +238,69 @@ fn run(opt: Opt) -> Result<()> {
         return Err(anyhow!("unsupported API Host prefix: {}", opt.api_host));
     };
 
-    let mut api_client = FatcatApiClient::new(&client, opt.api_host.clone(), opt.api_token.clone())?;
+    let mut api_client =
+        FatcatApiClient::new(&client, opt.api_host.clone(), opt.api_token.clone())?;
 
     match opt.cmd {
-        Command::Get {toml, specifier, expand, hide } => {
+        Command::Get {
+            toml,
+            specifier,
+            expand,
+            hide,
+        } => {
             let result = specifier.get_from_api(&mut api_client, expand, hide)?;
             if toml {
                 writeln!(&mut std::io::stdout(), "{}", result.to_toml_string()?)?
             } else {
                 writeln!(&mut std::io::stdout(), "{}", result.to_json_string()?)?
             }
-        },
-        Command::Create { entity_type, input_path, editgroup_id } => {
+        }
+        Command::Create {
+            entity_type,
+            input_path,
+            editgroup_id,
+        } => {
             let json_str = read_entity_file(input_path)?;
             let ee = api_client.create_entity_from_json(entity_type, &json_str, editgroup_id)?;
             println!("{}", serde_json::to_string(&ee)?);
-        },
-        Command::Update { specifier, input_path, editgroup_id, mutations } => {
-            let (json_str, exact_specifier): (String, Specifier) = match (&input_path, mutations.len()) {
-                // input path or no mutations: read from path or stdin
-                (Some(_), _) | (None, 0) => {
-                    (read_entity_file(input_path)?, specifier.into_entity_specifier(&mut api_client)?)
-                },
-                // no input path *and* mutations: fetch from API
-                (None, _) => {
-                    let mut entity = specifier.get_from_api(&mut api_client, None, None)?;
-                    entity.mutate(mutations)?;
-                    (entity.to_json_string()?, entity.specifier())
-                },
-            };
-            let ee = api_client.update_entity_from_json(exact_specifier, &json_str, editgroup_id)?;
+        }
+        Command::Update {
+            specifier,
+            input_path,
+            editgroup_id,
+            mutations,
+        } => {
+            let (json_str, exact_specifier): (String, Specifier) =
+                match (&input_path, mutations.len()) {
+                    // input path or no mutations: read from path or stdin
+                    (Some(_), _) | (None, 0) => (
+                        read_entity_file(input_path)?,
+                        specifier.into_entity_specifier(&mut api_client)?,
+                    ),
+                    // no input path *and* mutations: fetch from API
+                    (None, _) => {
+                        let mut entity = specifier.get_from_api(&mut api_client, None, None)?;
+                        entity.mutate(mutations)?;
+                        (entity.to_json_string()?, entity.specifier())
+                    }
+                };
+            let ee =
+                api_client.update_entity_from_json(exact_specifier, &json_str, editgroup_id)?;
             println!("{}", serde_json::to_string(&ee)?);
-        },
-        Command::Edit { specifier, editgroup_id, json, editing_command } => {
+        }
+        Command::Edit {
+            specifier,
+            editgroup_id,
+            json,
+            editing_command,
+        } => {
             // TODO: fetch editgroup, check if this entity is already being updated in it. If so,
             // need to fetch that revision, do the edit, parse that synatx is good, then delete the
             // existing edit and update with the new one.
             let original_entity = specifier.get_from_api(&mut api_client, None, None)?;
             let exact_specifier = original_entity.specifier();
             let tmp_file = tempfile::Builder::new()
-                .suffix( if json { ".json" } else { ".toml"} )
+                .suffix(if json { ".json" } else { ".toml" })
                 .tempfile()?;
             if json {
                 writeln!(&tmp_file, "{}", original_entity.to_json_string()?)?
@@ -264,16 +313,35 @@ fn run(opt: Opt) -> Result<()> {
                 .expect("failed to execute process");
             let cmd_status = editor_cmd.wait()?;
             if !cmd_status.success() {
-                return Err(anyhow!("editor ({}) exited with non-success status code ({}), bailing on edit", editing_command, cmd_status.code().map(|v| v.to_string()).unwrap_or_else(|| "N/A".to_string())));
+                return Err(anyhow!(
+                    "editor ({}) exited with non-success status code ({}), bailing on edit",
+                    editing_command,
+                    cmd_status
+                        .code()
+                        .map(|v| v.to_string())
+                        .unwrap_or_else(|| "N/A".to_string())
+                ));
             };
             let json_str = read_entity_file(Some(tmp_file.path().to_path_buf()))?;
             // for whatever reason api_client's TCP connection is broken after spawning, so try a
             // dummy call, expected to fail, but connection should re-establish after this
-            specifier.get_from_api(&mut api_client, None, None).context("re-fetch").ok();
-            let ee = api_client.update_entity_from_json(exact_specifier, &json_str, editgroup_id).context("updating after edit")?;
+            specifier
+                .get_from_api(&mut api_client, None, None)
+                .context("re-fetch")
+                .ok();
+            let ee = api_client
+                .update_entity_from_json(exact_specifier, &json_str, editgroup_id)
+                .context("updating after edit")?;
             println!("{}", serde_json::to_string(&ee)?);
-        },
-        Command::Search { entity_type, terms, limit, search_schema, expand, hide } => {
+        }
+        Command::Search {
+            entity_type,
+            terms,
+            limit,
+            search_schema,
+            expand,
+            hide,
+        } => {
             let limit: Option<u64> = match limit {
                 l if l < 0 => None,
                 l => Some(l as u64),
@@ -286,79 +354,137 @@ fn run(opt: Opt) -> Result<()> {
                 match (search_schema, entity_type) {
                     (true, _) => writeln!(&mut std::io::stdout(), "{}", hit.to_string())?,
                     (false, EntityType::Release) => {
-                        let specifier = Specifier::Release(hit["ident"].as_str().unwrap().to_string());
-                        let entity = specifier.get_from_api(&mut api_client, expand.clone(), hide.clone())?;
+                        let specifier =
+                            Specifier::Release(hit["ident"].as_str().unwrap().to_string());
+                        let entity = specifier.get_from_api(
+                            &mut api_client,
+                            expand.clone(),
+                            hide.clone(),
+                        )?;
                         writeln!(&mut std::io::stdout(), "{}", entity.to_json_string()?)?
-                    },
+                    }
                     (false, _) => unimplemented!("searching other entity types"),
                 }
             }
-        },
-        Command::Delete { specifier, editgroup_id } => {
-            let result = api_client.delete_entity(specifier.clone(), editgroup_id)
+        }
+        Command::Delete {
+            specifier,
+            editgroup_id,
+        } => {
+            let result = api_client
+                .delete_entity(specifier.clone(), editgroup_id)
                 .with_context(|| format!("delete entity: {:?}", specifier))?;
             println!("{}", serde_json::to_string(&result)?);
-        },
-        Command::Editgroup { cmd: EditgroupCommand::List { editor_id, limit, json } } => {
+        }
+        Command::Editgroup {
+            cmd:
+                EditgroupCommand::List {
+                    editor_id,
+                    limit,
+                    json,
+                },
+        } => {
             let editor_id = match editor_id.or(api_client.editor_id) {
                 Some(eid) => eid,
                 None => return Err(anyhow!("require either working auth token or --editor-id")),
             };
-            let result = api_client.rt.block_on(
-                api_client.api.get_editor_editgroups(editor_id.clone(), Some(limit), None, None)
-            ).context("fetch editgroups")?;
+            let result = api_client
+                .rt
+                .block_on(api_client.api.get_editor_editgroups(
+                    editor_id.clone(),
+                    Some(limit),
+                    None,
+                    None,
+                ))
+                .context("fetch editgroups")?;
             match result {
                 fatcat_openapi::GetEditorEditgroupsResponse::Found(eg_list) => {
                     print_editgroups(eg_list, json)?;
-                },
-                other => return Err(anyhow!("{:?}", other)).with_context(|| format!("failed to fetch editgroups for editor_{}", editor_id)),
+                }
+                other => {
+                    return Err(anyhow!("{:?}", other)).with_context(|| {
+                        format!("failed to fetch editgroups for editor_{}", editor_id)
+                    })
+                }
             }
-        },
-        Command::Editgroup { cmd: EditgroupCommand::Reviewable { limit, json } } => {
-            let result = api_client.rt.block_on(
-                api_client.api.get_editgroups_reviewable(Some("editors".to_string()), Some(limit), None, None)
-            ).context("fetch reviewable editgroups")?;
+        }
+        Command::Editgroup {
+            cmd: EditgroupCommand::Reviewable { limit, json },
+        } => {
+            let result = api_client
+                .rt
+                .block_on(api_client.api.get_editgroups_reviewable(
+                    Some("editors".to_string()),
+                    Some(limit),
+                    None,
+                    None,
+                ))
+                .context("fetch reviewable editgroups")?;
             match result {
                 fatcat_openapi::GetEditgroupsReviewableResponse::Found(eg_list) => {
                     print_editgroups(eg_list, json)?;
-                },
-                other => return Err(anyhow!("{:?}", other)).context("failed to fetch reviewable editgroups"),
+                }
+                other => {
+                    return Err(anyhow!("{:?}", other))
+                        .context("failed to fetch reviewable editgroups")
+                }
             }
-        },
-        Command::Editgroup { cmd: EditgroupCommand::Create { description }} => {
+        }
+        Command::Editgroup {
+            cmd: EditgroupCommand::Create { description },
+        } => {
             let mut eg = models::Editgroup::new();
             eg.description = Some(description);
             eg.extra = Some({
                 let mut extra = std::collections::HashMap::new();
-                extra.insert("agent".to_string(), serde_json::Value::String("fatcat-cli".to_string()));
+                extra.insert(
+                    "agent".to_string(),
+                    serde_json::Value::String("fatcat-cli".to_string()),
+                );
                 extra
             });
-            let result = api_client.rt.block_on(
-                api_client.api.create_editgroup(eg))?;
+            let result = api_client
+                .rt
+                .block_on(api_client.api.create_editgroup(eg))?;
             match result {
-                fatcat_openapi::CreateEditgroupResponse::SuccessfullyCreated(eg) =>
-                    println!("{}", serde_json::to_string(&eg)?),
+                fatcat_openapi::CreateEditgroupResponse::SuccessfullyCreated(eg) => {
+                    println!("{}", serde_json::to_string(&eg)?)
+                }
                 other => return Err(anyhow!("{:?}", other)).context("failed to create editgroup"),
             }
-        },
-        Command::Editgroup { cmd: EditgroupCommand::Accept { editgroup_id } } => {
-            let result = api_client.rt.block_on(
-                api_client.api.accept_editgroup(editgroup_id.clone())
-            ).context("accept editgroup")?;
+        }
+        Command::Editgroup {
+            cmd: EditgroupCommand::Accept { editgroup_id },
+        } => {
+            let result = api_client
+                .rt
+                .block_on(api_client.api.accept_editgroup(editgroup_id.clone()))
+                .context("accept editgroup")?;
             match result {
-                fatcat_openapi::AcceptEditgroupResponse::MergedSuccessfully(msg) =>
-                    println!("{}", serde_json::to_string(&msg)?),
-                other => return Err(anyhow!("failed to accept editgroup {}: {:?}", editgroup_id, other)),
+                fatcat_openapi::AcceptEditgroupResponse::MergedSuccessfully(msg) => {
+                    println!("{}", serde_json::to_string(&msg)?)
+                }
+                other => {
+                    return Err(anyhow!(
+                        "failed to accept editgroup {}: {:?}",
+                        editgroup_id,
+                        other
+                    ))
+                }
             }
-        },
-        Command::Editgroup { cmd: EditgroupCommand::Submit{ editgroup_id } } => {
+        }
+        Command::Editgroup {
+            cmd: EditgroupCommand::Submit { editgroup_id },
+        } => {
             let eg = api_client.update_editgroup_submit(editgroup_id, true)?;
             println!("{}", eg.to_json_string()?);
-        },
-        Command::Editgroup { cmd: EditgroupCommand::Unsubmit { editgroup_id } } => {
+        }
+        Command::Editgroup {
+            cmd: EditgroupCommand::Unsubmit { editgroup_id },
+        } => {
             let eg = api_client.update_editgroup_submit(editgroup_id, false)?;
             println!("{}", eg.to_json_string()?);
-        },
+        }
         Command::Status { json } => {
             let status = api_client.status()?;
             if json {
@@ -366,7 +492,7 @@ fn run(opt: Opt) -> Result<()> {
             } else {
                 status.pretty_print()?;
             }
-        },
+        }
     }
     Ok(())
 }
diff --git a/rust/fatcat-cli/src/search.rs b/rust/fatcat-cli/src/search.rs
index d7fbbad..133ea41 100644
--- a/rust/fatcat-cli/src/search.rs
+++ b/rust/fatcat-cli/src/search.rs
@@ -1,10 +1,8 @@
-
+use crate::EntityType;
+use anyhow::{anyhow, Result};
+use log::{self, info};
 use serde_json::json;
 use std::time::Duration;
-use anyhow::{Result, anyhow};
-use log::{self,info};
-use crate::EntityType;
-
 
 pub struct SearchResults {
     pub entity_type: EntityType,
@@ -25,17 +23,22 @@ impl Iterator for SearchResults {
         // if we already hit limit, bail early
         if let Some(l) = self.limit {
             if self.offset >= l {
-                return None
+                return None;
             }
         }
         // if current batch is empty, and we are scrolling, refill the current batch
         if self.batch.is_empty() && self.scroll_id.is_some() {
-            let response = self.http_client.get(&self.scroll_url)
+            let response = self
+                .http_client
+                .get(&self.scroll_url)
                 .header("Content-Type", "application/json")
-                .body(json!({
-                    "scroll": "2m",
-                    "scroll_id": self.scroll_id.clone().unwrap(),
-                }).to_string())
+                .body(
+                    json!({
+                        "scroll": "2m",
+                        "scroll_id": self.scroll_id.clone().unwrap(),
+                    })
+                    .to_string(),
+                )
                 .send();
             let mut response = match response {
                 Err(e) => return Some(Err(e.into())),
@@ -66,13 +69,22 @@ impl Iterator for SearchResults {
     }
 }
 
-pub fn crude_search(api_host: &str, entity_type: EntityType, limit: Option<u64>, terms: Vec<String>) -> Result<SearchResults> {
-
+pub fn crude_search(
+    api_host: &str,
+    entity_type: EntityType,
+    limit: Option<u64>,
+    terms: Vec<String>,
+) -> Result<SearchResults> {
     let index = match entity_type {
         EntityType::Release => "fatcat_release",
         EntityType::File => "fatcat_file",
         EntityType::Container => "fatcat_container",
-        _ => return Err(anyhow!("No search index for entity type: {:?}", entity_type)),
+        _ => {
+            return Err(anyhow!(
+                "No search index for entity type: {:?}",
+                entity_type
+            ))
+        }
     };
     let http_client = reqwest::Client::builder()
         .timeout(Duration::from_secs(10))
@@ -94,50 +106,51 @@ pub fn crude_search(api_host: &str, entity_type: EntityType, limit: Option<u64>,
         None => (true, "_doc", 100),
         Some(l) if l > 100 => (true, "_doc", 100),
         Some(l) => (false, "_score", l),
-
     };
 
     let query_body = json!({
-            "query": {
-                "boosting": {
-                    "positive": {
-                        "bool": {
-                            "must": {
-                                "query_string": {
-                                    "query": query,
-                                    "default_operator": "AND",
-                                    "analyze_wildcard": true,
-                                    "allow_leading_wildcard": false,
-                                    "lenient": true,
-                                    "fields": [
-                                        "title^2",
-                                        "biblio",
-                                    ],
-                                },
-                            },
-                            "should": {
-                                "term": { "in_ia": true },
+        "query": {
+            "boosting": {
+                "positive": {
+                    "bool": {
+                        "must": {
+                            "query_string": {
+                                "query": query,
+                                "default_operator": "AND",
+                                "analyze_wildcard": true,
+                                "allow_leading_wildcard": false,
+                                "lenient": true,
+                                "fields": [
+                                    "title^2",
+                                    "biblio",
+                                ],
                             },
                         },
-                    },
-                    "negative": {
-                        "bool": {
-                            "should": [
-                                {"bool": { "must_not" : { "exists": { "field": "title" }}}},
-                                {"bool": { "must_not" : { "exists": { "field": "year" }}}},
-                                {"bool": { "must_not" : { "exists": { "field": "type" }}}},
-                                {"bool": { "must_not" : { "exists": { "field": "stage" }}}},
-                            ],
+                        "should": {
+                            "term": { "in_ia": true },
                         },
                     },
-                    "negative_boost": 0.5,
                 },
+                "negative": {
+                    "bool": {
+                        "should": [
+                            {"bool": { "must_not" : { "exists": { "field": "title" }}}},
+                            {"bool": { "must_not" : { "exists": { "field": "year" }}}},
+                            {"bool": { "must_not" : { "exists": { "field": "type" }}}},
+                            {"bool": { "must_not" : { "exists": { "field": "stage" }}}},
+                        ],
+                    },
+                },
+                "negative_boost": 0.5,
             },
-            "size": size,
-            "sort": [ sort_mode ],
-        }).to_string();
+        },
+        "size": size,
+        "sort": [ sort_mode ],
+    })
+    .to_string();
 
-    let mut request = http_client.get(&request_url)
+    let mut request = http_client
+        .get(&request_url)
         .header("Content-Type", "application/json")
         .body(query_body);
 
@@ -154,9 +167,9 @@ pub fn crude_search(api_host: &str, entity_type: EntityType, limit: Option<u64>,
     let body: serde_json::Value = response.json()?;
 
     let scroll_id = if scroll_mode {
-        None
-    } else {
         Some(body["_scroll_id"].as_str().unwrap().to_string())
+    } else {
+        None
     };
 
     Ok(SearchResults {
diff --git a/rust/fatcat-cli/src/specifier.rs b/rust/fatcat-cli/src/specifier.rs
index 3085345..c9bc581 100644
--- a/rust/fatcat-cli/src/specifier.rs
+++ b/rust/fatcat-cli/src/specifier.rs
@@ -1,11 +1,9 @@
-
+use crate::{ApiEntityModel, FatcatApiClient};
+use anyhow::{anyhow, Context, Result};
 use fatcat_openapi::ApiNoContext;
-use anyhow::{Result, anyhow, Context};
-use std::str::FromStr;
 use lazy_static::lazy_static;
 use regex::Regex;
-use crate::{ApiEntityModel, FatcatApiClient};
-
+use std::str::FromStr;
 
 #[derive(Debug, PartialEq, Clone)]
 pub enum ReleaseLookupKey {
@@ -53,156 +51,305 @@ pub enum Specifier {
 }
 
 impl Specifier {
-
     /// If this Specifier is a lookup, call the API to do the lookup and return the resulting
     /// specific entity specifier (eg, with an FCID). If already specific, just pass through.
     pub fn into_entity_specifier(self, api_client: &mut FatcatApiClient) -> Result<Specifier> {
         use Specifier::*;
         match self {
-            Release(_) | Work(_) | Creator(_) | Container(_) | File(_) | FileSet(_) | WebCapture(_) | Editgroup(_) | Editor(_) | Changelog(_) => Ok(self),
+            Release(_) | Work(_) | Creator(_) | Container(_) | File(_) | FileSet(_)
+            | WebCapture(_) | Editgroup(_) | Editor(_) | Changelog(_) => Ok(self),
             ReleaseLookup(_, _) => Ok(self.get_from_api(api_client, None, None)?.specifier()),
             ContainerLookup(_, _) => Ok(self.get_from_api(api_client, None, None)?.specifier()),
             CreatorLookup(_, _) => Ok(self.get_from_api(api_client, None, None)?.specifier()),
             FileLookup(_, _) => Ok(self.get_from_api(api_client, None, None)?.specifier()),
-            EditorUsername(_username) => {
-                Err(anyhow!("editor lookup by username isn't implemented in fatcat-server API yet, sorry"))
-            },
+            EditorUsername(_username) => Err(anyhow!(
+                "editor lookup by username isn't implemented in fatcat-server API yet, sorry"
+            )),
         }
     }
 
-    pub fn get_from_api(&self, api_client: &mut FatcatApiClient, expand: Option<String>, hide: Option<String>) -> Result<Box<dyn ApiEntityModel>> {
+    pub fn get_from_api(
+        &self,
+        api_client: &mut FatcatApiClient,
+        expand: Option<String>,
+        hide: Option<String>,
+    ) -> Result<Box<dyn ApiEntityModel>> {
         use Specifier::*;
         let ret: Result<Box<dyn ApiEntityModel>> = match self {
-            Release(fcid) =>
-                match api_client.rt.block_on(api_client.api.get_release(fcid.to_string(), expand, hide))? {
-                    fatcat_openapi::GetReleaseResponse::FoundEntity(model) => Ok(Box::new(model)),
-                    fatcat_openapi::GetReleaseResponse::BadRequest(err) => Err(anyhow!("Bad Request ({}): {}", err.error, err.message)),
-                    fatcat_openapi::GetReleaseResponse::NotFound(err) => Err(anyhow!("Not Found: {}", err.message)),
-                    resp => Err(anyhow!("{:?}", resp)).with_context(|| format!("API GET failed: {:?}", self)),
-                },
+            Release(fcid) => match api_client.rt.block_on(api_client.api.get_release(
+                fcid.to_string(),
+                expand,
+                hide,
+            ))? {
+                fatcat_openapi::GetReleaseResponse::FoundEntity(model) => Ok(Box::new(model)),
+                fatcat_openapi::GetReleaseResponse::BadRequest(err) => {
+                    Err(anyhow!("Bad Request ({}): {}", err.error, err.message))
+                }
+                fatcat_openapi::GetReleaseResponse::NotFound(err) => {
+                    Err(anyhow!("Not Found: {}", err.message))
+                }
+                resp => Err(anyhow!("{:?}", resp))
+                    .with_context(|| format!("API GET failed: {:?}", self)),
+            },
             ReleaseLookup(ext_id, key) => {
                 use ReleaseLookupKey::*;
                 let (doi, pmcid, pmid, arxiv) = (
-                    if let DOI = ext_id { Some(key.to_string()) } else { None },
-                    if let PMCID = ext_id { Some(key.to_string()) } else { None },
-                    if let PMID = ext_id { Some(key.to_string()) } else { None },
-                    if let Arxiv = ext_id { Some(key.to_string()) } else { None },
+                    if let DOI = ext_id {
+                        Some(key.to_string())
+                    } else {
+                        None
+                    },
+                    if let PMCID = ext_id {
+                        Some(key.to_string())
+                    } else {
+                        None
+                    },
+                    if let PMID = ext_id {
+                        Some(key.to_string())
+                    } else {
+                        None
+                    },
+                    if let Arxiv = ext_id {
+                        Some(key.to_string())
+                    } else {
+                        None
+                    },
                 );
                 // doi, wikidata, isbn13, pmid, pmcid, core, arxiv, jstor, ark, mag
-                let result = api_client.rt.block_on(
-                    api_client.api.lookup_release(doi, None, None, pmid, pmcid, None, arxiv, None, None, None, expand, hide))?;
+                let result = api_client.rt.block_on(api_client.api.lookup_release(
+                    doi, None, None, pmid, pmcid, None, arxiv, None, None, None, expand, hide,
+                ))?;
                 match result {
-                    fatcat_openapi::LookupReleaseResponse::FoundEntity(model) => Ok(Box::new(model)),
-                    fatcat_openapi::LookupReleaseResponse::BadRequest(err) => Err(anyhow!("Bad Request ({}): {}", err.error, err.message)),
-                    fatcat_openapi::LookupReleaseResponse::NotFound(err) => Err(anyhow!("Not Found: {}", err.message)),
-                    resp => Err(anyhow!("{:?}", resp)).with_context(|| format!("API GET failed: {:?}", self)),
+                    fatcat_openapi::LookupReleaseResponse::FoundEntity(model) => {
+                        Ok(Box::new(model))
+                    }
+                    fatcat_openapi::LookupReleaseResponse::BadRequest(err) => {
+                        Err(anyhow!("Bad Request ({}): {}", err.error, err.message))
+                    }
+                    fatcat_openapi::LookupReleaseResponse::NotFound(err) => {
+                        Err(anyhow!("Not Found: {}", err.message))
+                    }
+                    resp => Err(anyhow!("{:?}", resp))
+                        .with_context(|| format!("API GET failed: {:?}", self)),
+                }
+            }
+            Work(fcid) => match api_client.rt.block_on(api_client.api.get_work(
+                fcid.to_string(),
+                expand,
+                hide,
+            ))? {
+                fatcat_openapi::GetWorkResponse::FoundEntity(model) => Ok(Box::new(model)),
+                fatcat_openapi::GetWorkResponse::BadRequest(err) => {
+                    Err(anyhow!("Bad Request ({}): {}", err.error, err.message))
                 }
+                fatcat_openapi::GetWorkResponse::NotFound(err) => {
+                    Err(anyhow!("Not Found: {}", err.message))
+                }
+                resp => Err(anyhow!("{:?}", resp))
+                    .with_context(|| format!("API GET failed: {:?}", self)),
+            },
+            Container(fcid) => match api_client.rt.block_on(api_client.api.get_container(
+                fcid.to_string(),
+                expand,
+                hide,
+            ))? {
+                fatcat_openapi::GetContainerResponse::FoundEntity(model) => Ok(Box::new(model)),
+                fatcat_openapi::GetContainerResponse::BadRequest(err) => {
+                    Err(anyhow!("Bad Request ({}): {}", err.error, err.message))
+                }
+                fatcat_openapi::GetContainerResponse::NotFound(err) => {
+                    Err(anyhow!("Not Found: {}", err.message))
+                }
+                resp => Err(anyhow!("{:?}", resp))
+                    .with_context(|| format!("API GET failed: {:?}", self)),
             },
-            Work(fcid) =>
-                match api_client.rt.block_on(api_client.api.get_work(fcid.to_string(), expand, hide))? {
-                    fatcat_openapi::GetWorkResponse::FoundEntity(model) => Ok(Box::new(model)),
-                    fatcat_openapi::GetWorkResponse::BadRequest(err) => Err(anyhow!("Bad Request ({}): {}", err.error, err.message)),
-                    fatcat_openapi::GetWorkResponse::NotFound(err) => Err(anyhow!("Not Found: {}", err.message)),
-                    resp => Err(anyhow!("{:?}", resp)).with_context(|| format!("API GET failed: {:?}", self)),
-                },
-            Container(fcid) =>
-                match api_client.rt.block_on(api_client.api.get_container(fcid.to_string(), expand, hide))? {
-                    fatcat_openapi::GetContainerResponse::FoundEntity(model) => Ok(Box::new(model)),
-                    fatcat_openapi::GetContainerResponse::BadRequest(err) => Err(anyhow!("Bad Request ({}): {}", err.error, err.message)),
-                    fatcat_openapi::GetContainerResponse::NotFound(err) => Err(anyhow!("Not Found: {}", err.message)),
-                    resp => Err(anyhow!("{:?}", resp)).with_context(|| format!("API GET failed: {:?}", self)),
-                },
             ContainerLookup(ext_id, key) => {
                 let result = api_client.rt.block_on(match ext_id {
-                    ContainerLookupKey::ISSNL => api_client.api.lookup_container(Some(key.to_string()), None, expand, hide),
+                    ContainerLookupKey::ISSNL => {
+                        api_client
+                            .api
+                            .lookup_container(Some(key.to_string()), None, expand, hide)
+                    }
                 })?;
                 match result {
-                    fatcat_openapi::LookupContainerResponse::FoundEntity(model) => Ok(Box::new(model)),
-                    fatcat_openapi::LookupContainerResponse::BadRequest(err) => Err(anyhow!("Bad Request ({}): {}", err.error, err.message)),
-                    fatcat_openapi::LookupContainerResponse::NotFound(err) => Err(anyhow!("Not Found: {}", err.message)),
-                    resp => Err(anyhow!("{:?}", resp)).with_context(|| format!("API GET failed: {:?}", self)),
+                    fatcat_openapi::LookupContainerResponse::FoundEntity(model) => {
+                        Ok(Box::new(model))
+                    }
+                    fatcat_openapi::LookupContainerResponse::BadRequest(err) => {
+                        Err(anyhow!("Bad Request ({}): {}", err.error, err.message))
+                    }
+                    fatcat_openapi::LookupContainerResponse::NotFound(err) => {
+                        Err(anyhow!("Not Found: {}", err.message))
+                    }
+                    resp => Err(anyhow!("{:?}", resp))
+                        .with_context(|| format!("API GET failed: {:?}", self)),
+                }
+            }
+            Creator(fcid) => match api_client.rt.block_on(api_client.api.get_creator(
+                fcid.to_string(),
+                expand,
+                hide,
+            ))? {
+                fatcat_openapi::GetCreatorResponse::FoundEntity(model) => Ok(Box::new(model)),
+                fatcat_openapi::GetCreatorResponse::BadRequest(err) => {
+                    Err(anyhow!("Bad Request ({}): {}", err.error, err.message))
+                }
+                fatcat_openapi::GetCreatorResponse::NotFound(err) => {
+                    Err(anyhow!("Not Found: {}", err.message))
                 }
+                resp => Err(anyhow!("{:?}", resp))
+                    .with_context(|| format!("API GET failed: {:?}", self)),
             },
-            Creator(fcid) =>
-                match api_client.rt.block_on(api_client.api.get_creator(fcid.to_string(), expand, hide))? {
-                    fatcat_openapi::GetCreatorResponse::FoundEntity(model) => Ok(Box::new(model)),
-                    fatcat_openapi::GetCreatorResponse::BadRequest(err) => Err(anyhow!("Bad Request ({}): {}", err.error, err.message)),
-                    fatcat_openapi::GetCreatorResponse::NotFound(err) => Err(anyhow!("Not Found: {}", err.message)),
-                    resp => Err(anyhow!("{:?}", resp)).with_context(|| format!("API GET failed: {:?}", self)),
-                },
             CreatorLookup(ext_id, key) => {
                 let result = api_client.rt.block_on(match ext_id {
-                    CreatorLookupKey::Orcid => api_client.api.lookup_creator(Some(key.to_string()), None, expand, hide),
+                    CreatorLookupKey::Orcid => {
+                        api_client
+                            .api
+                            .lookup_creator(Some(key.to_string()), None, expand, hide)
+                    }
                 })?;
                 match result {
-                    fatcat_openapi::LookupCreatorResponse::FoundEntity(model) => Ok(Box::new(model)),
-                    fatcat_openapi::LookupCreatorResponse::BadRequest(err) => Err(anyhow!("Bad Request ({}): {}", err.error, err.message)),
-                    fatcat_openapi::LookupCreatorResponse::NotFound(err) => Err(anyhow!("Not Found: {}", err.message)),
-                    resp => Err(anyhow!("{:?}", resp)).with_context(|| format!("API GET failed: {:?}", self)),
+                    fatcat_openapi::LookupCreatorResponse::FoundEntity(model) => {
+                        Ok(Box::new(model))
+                    }
+                    fatcat_openapi::LookupCreatorResponse::BadRequest(err) => {
+                        Err(anyhow!("Bad Request ({}): {}", err.error, err.message))
+                    }
+                    fatcat_openapi::LookupCreatorResponse::NotFound(err) => {
+                        Err(anyhow!("Not Found: {}", err.message))
+                    }
+                    resp => Err(anyhow!("{:?}", resp))
+                        .with_context(|| format!("API GET failed: {:?}", self)),
                 }
+            }
+            File(fcid) => match api_client.rt.block_on(api_client.api.get_file(
+                fcid.to_string(),
+                expand,
+                hide,
+            ))? {
+                fatcat_openapi::GetFileResponse::FoundEntity(model) => Ok(Box::new(model)),
+                fatcat_openapi::GetFileResponse::BadRequest(err) => {
+                    Err(anyhow!("Bad Request ({}): {}", err.error, err.message))
+                }
+                fatcat_openapi::GetFileResponse::NotFound(err) => {
+                    Err(anyhow!("Not Found: {}", err.message))
+                }
+                resp => Err(anyhow!("{:?}", resp))
+                    .with_context(|| format!("API GET failed: {:?}", self)),
             },
-            File(fcid) =>
-                match api_client.rt.block_on(api_client.api.get_file(fcid.to_string(), expand, hide))? {
-                    fatcat_openapi::GetFileResponse::FoundEntity(model) => Ok(Box::new(model)),
-                    fatcat_openapi::GetFileResponse::BadRequest(err) => Err(anyhow!("Bad Request ({}): {}", err.error, err.message)),
-                    fatcat_openapi::GetFileResponse::NotFound(err) => Err(anyhow!("Not Found: {}", err.message)),
-                    resp => Err(anyhow!("{:?}", resp)).with_context(|| format!("API GET failed: {:?}", self)),
-                },
             FileLookup(hash, key) => {
                 use FileLookupKey::*;
                 let (sha1, sha256, md5) = (
-                    if let SHA1 = hash { Some(key.to_string()) } else { None },
-                    if let SHA256 = hash { Some(key.to_string()) } else { None },
-                    if let MD5 = hash { Some(key.to_string()) } else { None },
+                    if let SHA1 = hash {
+                        Some(key.to_string())
+                    } else {
+                        None
+                    },
+                    if let SHA256 = hash {
+                        Some(key.to_string())
+                    } else {
+                        None
+                    },
+                    if let MD5 = hash {
+                        Some(key.to_string())
+                    } else {
+                        None
+                    },
                 );
-                let result = api_client.rt.block_on(
-                    api_client.api.lookup_file(sha1, sha256, md5, expand, hide),
-                )?;
+                let result = api_client
+                    .rt
+                    .block_on(api_client.api.lookup_file(sha1, sha256, md5, expand, hide))?;
                 match result {
                     fatcat_openapi::LookupFileResponse::FoundEntity(model) => Ok(Box::new(model)),
-                    fatcat_openapi::LookupFileResponse::BadRequest(err) => Err(anyhow!("Bad Request ({}): {}", err.error, err.message)),
-                    fatcat_openapi::LookupFileResponse::NotFound(err) => Err(anyhow!("Not Found: {}", err.message)),
-                    resp => Err(anyhow!("{:?}", resp)).with_context(|| format!("API GET failed: {:?}", self)),
+                    fatcat_openapi::LookupFileResponse::BadRequest(err) => {
+                        Err(anyhow!("Bad Request ({}): {}", err.error, err.message))
+                    }
+                    fatcat_openapi::LookupFileResponse::NotFound(err) => {
+                        Err(anyhow!("Not Found: {}", err.message))
+                    }
+                    resp => Err(anyhow!("{:?}", resp))
+                        .with_context(|| format!("API GET failed: {:?}", self)),
+                }
+            }
+            FileSet(fcid) => match api_client.rt.block_on(api_client.api.get_fileset(
+                fcid.to_string(),
+                expand,
+                hide,
+            ))? {
+                fatcat_openapi::GetFilesetResponse::FoundEntity(model) => Ok(Box::new(model)),
+                fatcat_openapi::GetFilesetResponse::BadRequest(err) => {
+                    Err(anyhow!("Bad Request ({}): {}", err.error, err.message))
                 }
+                fatcat_openapi::GetFilesetResponse::NotFound(err) => {
+                    Err(anyhow!("Not Found: {}", err.message))
+                }
+                resp => Err(anyhow!("{:?}", resp))
+                    .with_context(|| format!("API GET failed: {:?}", self)),
             },
-            FileSet(fcid) =>
-                match api_client.rt.block_on(api_client.api.get_fileset(fcid.to_string(), expand, hide))? {
-                    fatcat_openapi::GetFilesetResponse::FoundEntity(model) => Ok(Box::new(model)),
-                    fatcat_openapi::GetFilesetResponse::BadRequest(err) => Err(anyhow!("Bad Request ({}): {}", err.error, err.message)),
-                    fatcat_openapi::GetFilesetResponse::NotFound(err) => Err(anyhow!("Not Found: {}", err.message)),
-                    resp => Err(anyhow!("{:?}", resp)).with_context(|| format!("API GET failed: {:?}", self)),
-                },
-            WebCapture(fcid) =>
-                match api_client.rt.block_on(api_client.api.get_webcapture(fcid.to_string(), expand, hide))? {
-                    fatcat_openapi::GetWebcaptureResponse::FoundEntity(model) => Ok(Box::new(model)),
-                    fatcat_openapi::GetWebcaptureResponse::BadRequest(err) => Err(anyhow!("Bad Request ({}): {}", err.error, err.message)),
-                    fatcat_openapi::GetWebcaptureResponse::NotFound(err) => Err(anyhow!("Not Found: {}", err.message)),
-                    resp => Err(anyhow!("{:?}", resp)).with_context(|| format!("API GET failed: {:?}", self)),
-                },
-            Editgroup(fcid) =>
-                match api_client.rt.block_on(api_client.api.get_editgroup(fcid.to_string()))? {
-                    fatcat_openapi::GetEditgroupResponse::Found(model) => Ok(Box::new(model)),
-                    fatcat_openapi::GetEditgroupResponse::BadRequest(err) => Err(anyhow!("Bad Request ({}): {}", err.error, err.message)),
-                    fatcat_openapi::GetEditgroupResponse::NotFound(err) => Err(anyhow!("Not Found: {}", err.message)),
-                    resp => Err(anyhow!("{:?}", resp)).with_context(|| format!("API GET failed: {:?}", self)),
-                },
-            Editor(fcid) =>
-                match api_client.rt.block_on(api_client.api.get_editor(fcid.to_string()))? {
-                    fatcat_openapi::GetEditorResponse::Found(model) => Ok(Box::new(model)),
-                    fatcat_openapi::GetEditorResponse::BadRequest(err) => Err(anyhow!("Bad Request ({}): {}", err.error, err.message)),
-                    fatcat_openapi::GetEditorResponse::NotFound(err) => Err(anyhow!("Not Found: {}", err.message)),
-                    resp => Err(anyhow!("{:?}", resp)).with_context(|| format!("API GET failed: {:?}", self)),
-                },
-            Changelog(index) =>
-                match api_client.rt.block_on(api_client.api.get_changelog_entry(*index))? {
-                    fatcat_openapi::GetChangelogEntryResponse::FoundChangelogEntry(model) => Ok(Box::new(model)),
-                    fatcat_openapi::GetChangelogEntryResponse::BadRequest(err) => Err(anyhow!("Bad Request ({}): {}", err.error, err.message)),
-                    fatcat_openapi::GetChangelogEntryResponse::NotFound(err) => Err(anyhow!("Not Found: {}", err.message)),
-                    resp => Err(anyhow!("{:?}", resp)).with_context(|| format!("API GET failed: {:?}", self)),
-                },
-            EditorUsername(_username) => {
-                unimplemented!("editor lookup by username isn't implemented in fatcat-server API yet, sorry")
+            WebCapture(fcid) => match api_client.rt.block_on(api_client.api.get_webcapture(
+                fcid.to_string(),
+                expand,
+                hide,
+            ))? {
+                fatcat_openapi::GetWebcaptureResponse::FoundEntity(model) => Ok(Box::new(model)),
+                fatcat_openapi::GetWebcaptureResponse::BadRequest(err) => {
+                    Err(anyhow!("Bad Request ({}): {}", err.error, err.message))
+                }
+                fatcat_openapi::GetWebcaptureResponse::NotFound(err) => {
+                    Err(anyhow!("Not Found: {}", err.message))
+                }
+                resp => Err(anyhow!("{:?}", resp))
+                    .with_context(|| format!("API GET failed: {:?}", self)),
+            },
+            Editgroup(fcid) => match api_client
+                .rt
+                .block_on(api_client.api.get_editgroup(fcid.to_string()))?
+            {
+                fatcat_openapi::GetEditgroupResponse::Found(model) => Ok(Box::new(model)),
+                fatcat_openapi::GetEditgroupResponse::BadRequest(err) => {
+                    Err(anyhow!("Bad Request ({}): {}", err.error, err.message))
+                }
+                fatcat_openapi::GetEditgroupResponse::NotFound(err) => {
+                    Err(anyhow!("Not Found: {}", err.message))
+                }
+                resp => Err(anyhow!("{:?}", resp))
+                    .with_context(|| format!("API GET failed: {:?}", self)),
             },
+            Editor(fcid) => match api_client
+                .rt
+                .block_on(api_client.api.get_editor(fcid.to_string()))?
+            {
+                fatcat_openapi::GetEditorResponse::Found(model) => Ok(Box::new(model)),
+                fatcat_openapi::GetEditorResponse::BadRequest(err) => {
+                    Err(anyhow!("Bad Request ({}): {}", err.error, err.message))
+                }
+                fatcat_openapi::GetEditorResponse::NotFound(err) => {
+                    Err(anyhow!("Not Found: {}", err.message))
+                }
+                resp => Err(anyhow!("{:?}", resp))
+                    .with_context(|| format!("API GET failed: {:?}", self)),
+            },
+            Changelog(index) => match api_client
+                .rt
+                .block_on(api_client.api.get_changelog_entry(*index))?
+            {
+                fatcat_openapi::GetChangelogEntryResponse::FoundChangelogEntry(model) => {
+                    Ok(Box::new(model))
+                }
+                fatcat_openapi::GetChangelogEntryResponse::BadRequest(err) => {
+                    Err(anyhow!("Bad Request ({}): {}", err.error, err.message))
+                }
+                fatcat_openapi::GetChangelogEntryResponse::NotFound(err) => {
+                    Err(anyhow!("Not Found: {}", err.message))
+                }
+                resp => Err(anyhow!("{:?}", resp))
+                    .with_context(|| format!("API GET failed: {:?}", self)),
+            },
+            EditorUsername(_username) => {
+                unimplemented!(
+                    "editor lookup by username isn't implemented in fatcat-server API yet, sorry"
+                )
+            }
         };
         match ret {
             Ok(_) => ret,
@@ -236,18 +383,42 @@ impl FromStr for Specifier {
 
         // then try lookup prefixes
         lazy_static! {
-            static ref SPEC_LOOKUP_RE: Regex = Regex::new(r"^(doi|pmcid|pmid|arxiv|issnl|orcid|sha1|sha256|md5|username|changelog):(\S+)$").unwrap();
+            static ref SPEC_LOOKUP_RE: Regex = Regex::new(
+                r"^(doi|pmcid|pmid|arxiv|issnl|orcid|sha1|sha256|md5|username|changelog):(\S+)$"
+            )
+            .unwrap();
         }
         if let Some(caps) = SPEC_LOOKUP_RE.captures(s) {
             return match (&caps[1], &caps[2]) {
-                ("doi", key) => Ok(Specifier::ReleaseLookup(ReleaseLookupKey::DOI, key.to_string())),
-                ("pmcid", key) => Ok(Specifier::ReleaseLookup(ReleaseLookupKey::PMCID, key.to_string())),
-                ("pmid", key) => Ok(Specifier::ReleaseLookup(ReleaseLookupKey::PMID, key.to_string())),
-                ("arxiv", key) => Ok(Specifier::ReleaseLookup(ReleaseLookupKey::Arxiv, key.to_string())),
-                ("issnl", key) => Ok(Specifier::ContainerLookup(ContainerLookupKey::ISSNL, key.to_string())),
-                ("orcid", key) => Ok(Specifier::CreatorLookup(CreatorLookupKey::Orcid, key.to_string())),
+                ("doi", key) => Ok(Specifier::ReleaseLookup(
+                    ReleaseLookupKey::DOI,
+                    key.to_string(),
+                )),
+                ("pmcid", key) => Ok(Specifier::ReleaseLookup(
+                    ReleaseLookupKey::PMCID,
+                    key.to_string(),
+                )),
+                ("pmid", key) => Ok(Specifier::ReleaseLookup(
+                    ReleaseLookupKey::PMID,
+                    key.to_string(),
+                )),
+                ("arxiv", key) => Ok(Specifier::ReleaseLookup(
+                    ReleaseLookupKey::Arxiv,
+                    key.to_string(),
+                )),
+                ("issnl", key) => Ok(Specifier::ContainerLookup(
+                    ContainerLookupKey::ISSNL,
+                    key.to_string(),
+                )),
+                ("orcid", key) => Ok(Specifier::CreatorLookup(
+                    CreatorLookupKey::Orcid,
+                    key.to_string(),
+                )),
                 ("sha1", key) => Ok(Specifier::FileLookup(FileLookupKey::SHA1, key.to_string())),
-                ("sha256", key) => Ok(Specifier::FileLookup(FileLookupKey::SHA256, key.to_string())),
+                ("sha256", key) => Ok(Specifier::FileLookup(
+                    FileLookupKey::SHA256,
+                    key.to_string(),
+                )),
                 ("md5", key) => Ok(Specifier::FileLookup(FileLookupKey::MD5, key.to_string())),
                 ("username", key) => Ok(Specifier::EditorUsername(key.to_string())),
                 _ => Err(anyhow!("unexpected entity lookup type: {}", &caps[1])),
@@ -260,7 +431,10 @@ impl FromStr for Specifier {
         if let Some(caps) = SPEC_CHANGELOG_RE.captures(s) {
             return Ok(Specifier::Changelog(caps[1].parse::<i64>()?));
         }
-        Err(anyhow!("expecting a specifier: entity identifier or key/value lookup: {}", s))
+        Err(anyhow!(
+            "expecting a specifier: entity identifier or key/value lookup: {}",
+            s
+        ))
     }
 }
 
@@ -271,12 +445,23 @@ mod tests {
     #[test]
     fn test_specifier_from_str() -> () {
         assert!(Specifier::from_str("release_asdf").is_err());
-        assert_eq!(Specifier::from_str("creator_iimvc523xbhqlav6j3sbthuehu").unwrap(), Specifier::Creator("iimvc523xbhqlav6j3sbthuehu".to_string()));
-        assert_eq!(Specifier::from_str("username:big-bot").unwrap(), Specifier::EditorUsername("big-bot".to_string()));
-        assert_eq!(Specifier::from_str("doi:10.1234/a!s.df+-d").unwrap(), Specifier::ReleaseLookup(ReleaseLookupKey::DOI, "10.1234/a!s.df+-d".to_string()));
+        assert_eq!(
+            Specifier::from_str("creator_iimvc523xbhqlav6j3sbthuehu").unwrap(),
+            Specifier::Creator("iimvc523xbhqlav6j3sbthuehu".to_string())
+        );
+        assert_eq!(
+            Specifier::from_str("username:big-bot").unwrap(),
+            Specifier::EditorUsername("big-bot".to_string())
+        );
+        assert_eq!(
+            Specifier::from_str("doi:10.1234/a!s.df+-d").unwrap(),
+            Specifier::ReleaseLookup(ReleaseLookupKey::DOI, "10.1234/a!s.df+-d".to_string())
+        );
         assert!(Specifier::from_str("doi:").is_err());
-        assert_eq!(Specifier::from_str("changelog_1234").unwrap(), Specifier::Changelog(1234));
+        assert_eq!(
+            Specifier::from_str("changelog_1234").unwrap(),
+            Specifier::Changelog(1234)
+        );
         assert!(Specifier::from_str("changelog_12E4").is_err());
     }
-
 }