Merge pull request #23 from zummenix/#19-remove-by-bundle-id

Remove profiles by bundle id

Author: zummenix

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "mprovision"
-version = "2.2.0"
+version = "3.0.0"
 authors = ["Aleksey Kuznetsov <zummenix@gmail.com>"]
 
 [[bin]]

Cargo.toml

@@ -41,7 +41,7 @@ It's very simple: `mprovision list`
 
 1. The `list` subcommand accepts an optional argument `-t` or `--text` that allows you to filter the list of 
 provisioning profiles by some text. 
-2. The `remove` subcommand allows you to remove one or more profiles by their uuids.
+2. The `remove` subcommand allows you to remove one or more profiles by their uuids or bundle ids.
 
 > WARNING: the `remove` subcommand is relatively dangerous since it removes profiles from the
 system completely.

README.md

@@ -62,8 +62,8 @@ pub struct ShowFileParams {
 #[derive(Debug, Default, PartialEq, StructOpt)]
 pub struct RemoveParams {
     #[structopt(raw(empty_values = "false"))]
-    /// uuid(s) of provisioning profiles
-    pub uuids: Vec<String>,
+    /// uuid(s) or bundle id(s) of provisioning profiles
+    pub ids: Vec<String>,
     #[structopt(long = "source", parse(from_os_str), raw(empty_values = "false"))]
     /// A directory where to search provisioning profiles
     pub directory: Option<PathBuf>,
@@ -287,17 +287,17 @@ mod tests {
     }
 
     #[test]
-    fn remove_uuid_command() {
+    fn remove_id_command() {
         expect!(parse(&["mprovision", "remove", "abcd"])).to(be_ok().value(Command::Remove(
             RemoveParams {
-                uuids: vec!["abcd".to_string()],
+                ids: vec!["abcd".to_string()],
                 directory: None,
             },
         )));
 
         expect!(parse(&["mprovision", "remove", "abcd", "ef"])).to(be_ok().value(Command::Remove(
             RemoveParams {
-                uuids: vec!["abcd".to_string(), "ef".to_string()],
+                ids: vec!["abcd".to_string(), "ef".to_string()],
                 directory: None,
             },
         )));
@@ -306,7 +306,7 @@ mod tests {
 
         expect!(parse(&["mprovision", "remove", "abcd", "--source", "."])).to(be_ok().value(
             Command::Remove(RemoveParams {
-                uuids: vec!["abcd".to_string()],
+                ids: vec!["abcd".to_string()],
                 directory: Some(".".into()),
             }),
         ));
@@ -319,7 +319,7 @@ mod tests {
             "--source",
             ".",
         ])).to(be_ok().value(Command::Remove(RemoveParams {
-            uuids: vec!["abcd".to_string(), "ef".to_string()],
+            ids: vec!["abcd".to_string(), "ef".to_string()],
             directory: Some(".".into()),
         })));
 

src/bin/cli.rs

@@ -7,11 +7,11 @@ extern crate mprovision;
 #[macro_use]
 extern crate structopt;
 
-use mprovision as mp;
+use chrono::*;
 use cli::Command;
+use mprovision as mp;
 use std::env;
 use std::path::PathBuf;
-use chrono::*;
 
 mod cli;
 
@@ -30,7 +30,7 @@ fn run(command: cli::Command) -> Result<(), cli::Error> {
         }) => list(text, expire_in_days, directory),
         Command::ShowUuid(cli::ShowUuidParams { uuid, directory }) => show_uuid(uuid, directory),
         Command::ShowFile(cli::ShowFileParams { file }) => show_file(file),
-        Command::Remove(cli::RemoveParams { uuids, directory }) => remove(uuids, directory),
+        Command::Remove(cli::RemoveParams { ids, directory }) => remove(ids, directory),
         Command::Clean(cli::CleanParams { directory }) => clean(directory),
     }
 }
@@ -49,21 +49,21 @@ fn list(
             let filter_string = text.as_ref();
             let mut profiles = mp::filter(entries, |profile| match (date, filter_string) {
                 (Some(date), Some(string)) => {
-                    profile.expiration_date <= date && profile.contains(string)
+                    profile.info.expiration_date <= date && profile.info.contains(string)
                 }
-                (Some(date), _) => profile.expiration_date <= date,
-                (_, Some(string)) => profile.contains(string),
+                (Some(date), _) => profile.info.expiration_date <= date,
+                (_, Some(string)) => profile.info.contains(string),
                 (_, _) => true,
             });
-            profiles.sort_by(|a, b| a.creation_date.cmp(&b.creation_date));
+            profiles.sort_by(|a, b| a.info.creation_date.cmp(&b.info.creation_date));
             (total, profiles)
         })
         .and_then(|(total, profiles)| {
             if profiles.is_empty() {
                 Ok(println!("Nothing found"))
             } else {
                 for profile in &profiles {
-                    println!("\n{}", profile.description());
+                    println!("\n{}", profile.info.description());
                 }
                 Ok(println!("\nFound {} of {}", profiles.len(), total))
             }
@@ -85,14 +85,14 @@ fn show_file(path: PathBuf) -> Result<(), cli::Error> {
         .map_err(|err| err.into())
 }
 
-fn remove(uuids: Vec<String>, directory: Option<PathBuf>) -> Result<(), cli::Error> {
+fn remove(ids: Vec<String>, directory: Option<PathBuf>) -> Result<(), cli::Error> {
     mp::with_directory(directory)
         .and_then(|directory| {
-            mp::find_by_uuids(&directory, uuids).and_then(|profiles| {
+            mp::find_by_ids(&directory, ids).and_then(|profiles| {
                 for profile in profiles {
                     match mp::remove(&profile.path) {
-                        Ok(_) => println!("'{}' was removed", profile.uuid),
-                        Err(_) => println!("Error while removing '{}'", profile.uuid),
+                        Ok(_) => println!("\nRemoved: {}", profile.info.description()),
+                        Err(_) => println!("\nError while removing '{}'", profile.info.uuid),
                     }
                 }
                 Ok(())
@@ -112,7 +112,7 @@ fn clean(directory: Option<PathBuf>) -> Result<(), cli::Error> {
         .map_err(|err| err.into())
         .map(|entries| {
             let date = Utc::now();
-            mp::filter(entries, |profile| profile.expiration_date <= date)
+            mp::filter(entries, |profile| profile.info.expiration_date <= date)
         })
         .and_then(|profiles| {
             if profiles.is_empty() {
@@ -122,8 +122,8 @@ fn clean(directory: Option<PathBuf>) -> Result<(), cli::Error> {
                     .iter()
                     .map(|profile| {
                         std::fs::remove_file(&profile.path)
-                            .map(|_| format!("'{}' was removed\n", profile.uuid))
-                            .map_err(|err| format!("'{}' {}\n", profile.uuid, err))
+                            .map(|_| format!("'{}' was removed\n", profile.info.uuid))
+                            .map_err(|err| format!("'{}' {}\n", profile.info.uuid, err))
                     })
                     .fold(Ok(String::new()), |acc, s| match (acc, s) {
                         (Ok(acc), Ok(s)) => Ok(concat(acc, s)),

src/bin/main.rs

@@ -1,6 +1,6 @@
-use std::io;
-use std::fmt;
 use std::error;
+use std::fmt;
+use std::io;
 use std::string::FromUtf8Error;
 
 /// An Error type.

src/error.rs

@@ -19,17 +19,17 @@ use futures::stream::Stream;
 use futures::Future;
 use futures_cpupool::CpuPool;
 
-use std::fs::{self, DirEntry, File};
-use std::path::{Path, PathBuf};
 use std::env;
+use std::fs::{self, DirEntry, File};
 use std::io::Read;
+use std::path::{Path, PathBuf};
 
 pub use error::Error;
 pub use profile::Profile;
 
 mod error;
-mod profile;
 mod plist_extractor;
+mod profile;
 
 /// A Result type for this crate.
 pub type Result<T> = std::result::Result<T, Error>;
@@ -134,29 +134,32 @@ where
 /// Searches a provisioning profile by its uuid.
 pub fn find_by_uuid(dir: &Path, uuid: &str) -> Result<Profile> {
     let entries: Vec<DirEntry> = entries(dir)?.collect();
-    if let Some(profile) = filter(entries, |profile| profile.uuid == uuid).pop() {
+    if let Some(profile) = filter(entries, |profile| profile.info.uuid == uuid).pop() {
         Ok(profile)
     } else {
         Err(Error::Own(format!("Profile '{}' is not found.", uuid)))
     }
 }
 
-/// Searches provisioning profiles by their uuid.
-pub fn find_by_uuids(dir: &Path, uuids: Vec<String>) -> Result<Vec<Profile>> {
+/// Searches provisioning profiles by their uuid(s) or bundle id(s).
+pub fn find_by_ids(dir: &Path, ids: Vec<String>) -> Result<Vec<Profile>> {
     let entries: Vec<DirEntry> = entries(dir)?.collect();
-    let profiles = filter(entries, |profile| uuids.contains(&profile.uuid));
+    let profiles = filter(entries, |profile| {
+        ids.iter()
+            .any(|id| id == &profile.info.uuid || profile.info.bundle_id() == Some(&id))
+    });
     Ok(profiles)
 }
 
 #[cfg(test)]
 mod tests {
-    use expectest::prelude::*;
     use super::*;
+    use expectest::prelude::*;
 
     #[test]
     fn filter_mobileprovision_files() {
-        use tempdir::TempDir;
         use std::fs::File;
+        use tempdir::TempDir;
 
         let temp_dir = TempDir::new("test").unwrap();
         let result = entries(temp_dir.path()).map(|iter| iter.count());

src/lib.rs

@@ -26,8 +26,8 @@ pub fn find(data: &[u8]) -> Option<&[u8]> {
 
 #[cfg(test)]
 mod tests {
-    use expectest::prelude::*;
     use super::*;
+    use expectest::prelude::*;
 
     #[test]
     fn test_find_plist() {

src/plist_extractor.rs

@@ -1,39 +1,47 @@
-use std::io::{self, Read};
-use std::fs::File;
-use std::path::{Path, PathBuf};
 use chrono::{DateTime, TimeZone, Utc};
-use plist::PlistEvent::*;
 use plist;
+use plist::PlistEvent::*;
+use std::fs::File;
+use std::io::{self, Read};
+use std::path::{Path, PathBuf};
 use {Error, Result};
 
-/// Represents provisioning profile data.
+/// Represents a file with a provisioning profile info.
 #[derive(Debug, Clone)]
 pub struct Profile {
     pub path: PathBuf,
-    pub uuid: String,
-    pub name: String,
-    pub app_identifier: String,
-    pub creation_date: DateTime<Utc>,
-    pub expiration_date: DateTime<Utc>,
+    pub info: ProfileInfo,
 }
 
 impl Profile {
     /// Returns instance of the `Profile` parsed from a file.
     pub fn from_file(path: &Path) -> Result<Self> {
         let mut buf = Vec::new();
         File::open(path)?.read_to_end(&mut buf)?;
-        Profile::from_xml_data(&buf)
-            .map(|mut p| {
-                p.path = path.to_owned();
-                p
-            })
-            .ok_or_else(|| Error::Own("Couldn't parse file.".into()))
+        let info = ProfileInfo::from_xml_data(&buf)
+            .ok_or_else(|| Error::Own("Couldn't parse file.".into()))?;
+        Ok(Profile {
+            path: path.to_owned(),
+            info,
+        })
     }
+}
 
+/// Represents provisioning profile info.
+#[derive(Debug, Clone)]
+pub struct ProfileInfo {
+    pub uuid: String,
+    pub name: String,
+    pub app_identifier: String,
+    pub creation_date: DateTime<Utc>,
+    pub expiration_date: DateTime<Utc>,
+}
+
+impl ProfileInfo {
     /// Returns instance of the `Profile` parsed from a `data`.
     pub fn from_xml_data(data: &[u8]) -> Option<Self> {
         if let Some(data) = ::plist_extractor::find(data) {
-            let mut profile = Profile::empty();
+            let mut profile = ProfileInfo::empty();
             let mut iter = plist::xml::EventReader::new(io::Cursor::new(data)).into_iter();
             while let Some(item) = iter.next() {
                 if let Ok(StringValue(key)) = item {
@@ -70,9 +78,9 @@ impl Profile {
         }
     }
 
+    /// Returns an empty profile info.
     pub fn empty() -> Self {
-        Profile {
-            path: PathBuf::new(),
+        ProfileInfo {
             uuid: "".into(),
             name: "".into(),
             app_identifier: "".into(),
@@ -93,6 +101,13 @@ impl Profile {
         false
     }
 
+    /// Returns a bundle id of a profile.
+    pub fn bundle_id(&self) -> Option<&str> {
+        self.app_identifier
+            .find(|ch| ch == '.')
+            .map(|i| &self.app_identifier[(i + 1)..])
+    }
+
     /// Returns profile in a text form.
     pub fn description(&self) -> String {
         let mut desc = String::new();
@@ -112,15 +127,13 @@ impl Profile {
 
 #[cfg(test)]
 mod tests {
-    use expectest::prelude::*;
-    use std::path::PathBuf;
-    use chrono::{TimeZone, Utc};
     use super::*;
+    use chrono::{TimeZone, Utc};
+    use expectest::prelude::*;
 
     #[test]
     fn contains() {
-        let profile = Profile {
-            path: PathBuf::new(),
+        let profile = ProfileInfo {
             uuid: "123".into(),
             name: "name".into(),
             app_identifier: "id".into(),
@@ -131,4 +144,25 @@ mod tests {
         expect!(profile.contains("me")).to(be_true());
         expect!(profile.contains("id")).to(be_true());
     }
+
+    #[test]
+    fn correct_bundle_id() {
+        let mut profile = ProfileInfo::empty();
+        profile.app_identifier = "12345ABCDE.com.exmaple.app".to_owned();
+        expect!(profile.bundle_id()).to(be_some().value("com.exmaple.app"));
+    }
+
+    #[test]
+    fn incorrect_bundle_id() {
+        let mut profile = ProfileInfo::empty();
+        profile.app_identifier = "12345ABCDE".to_owned();
+        expect!(profile.bundle_id()).to(be_none());
+    }
+
+    #[test]
+    fn wildcard_bundle_id() {
+        let mut profile = ProfileInfo::empty();
+        profile.app_identifier = "12345ABCDE.*".to_owned();
+        expect!(profile.bundle_id()).to(be_some().value("*"));
+    }
 }