fix(import): handle owner search (#41)

src/cmd/run/attach.rs

@@ -32,23 +32,20 @@ impl Run for AttachArgs {
             );
         }
 
-        let remote = config::must_get_remote(&self.remote)?;
-
         let query = Query::new(&db, vec![self.remote.clone(), self.query.clone()]);
-        let result = query.select_remote(
+        let (remote, repo, exists) = query.select_remote(
             SelectOptions::new()
                 .with_force(self.force)
                 .with_search(true)
                 .with_repo_path(format!("{}", config::current_dir().display())),
         )?;
-        if result.exists {
+        if exists {
             bail!(
                 "The repo {} has already been bound to {}, please detach it first",
-                result.repo.long_name(),
-                result.repo.get_path().display()
+                repo.long_name(),
+                repo.get_path().display()
             );
         }
-        let repo = result.repo;
 
         confirm!(
             "Do you want to attach current directory to {}",

src/cmd/run/home.rs

@@ -33,19 +33,18 @@ impl Run for HomeArgs {
     fn run(&self) -> Result<()> {
         let mut db = Database::read()?;
         let query = Query::new(&db, self.query.clone());
-        let result = query.select(
+        let (remote, repo, exists) = query.select(
             SelectOptions::new()
                 .with_force(self.force)
                 .with_search(self.search),
         )?;
-        if !result.exists {
+        if !exists {
             confirm!(
                 "Do you want to create {}/{}",
-                result.repo.owner.as_ref(),
-                result.repo.name.as_ref()
+                repo.owner.as_ref(),
+                repo.name.as_ref()
             );
         }
-        let (remote, repo) = result.as_repo();
 
         let dir = repo.get_path();
         match fs::read_dir(&dir) {

src/cmd/run/import.rs

@@ -85,15 +85,15 @@ impl Run for ImportArgs {
         let mut db = Database::read()?;
 
         let query = Query::new(&db, vec![self.remote.clone(), self.owner.clone()]);
-        let (remote, names) = query.list_remote(self.force, self.filter)?;
+        let (remote, owner, names) = query.list_remote(self.force, self.filter)?;
 
         if names.is_empty() {
             info!("Nothing to import");
             return Ok(());
         }
 
         let remote_arc = Arc::new(remote);
-        let owner_arc = Arc::new(self.owner.clone());
+        let owner_arc = Arc::new(owner);
 
         let mut tasks = Vec::with_capacity(names.len());
         for name in names {

src/repo/query.rs

@@ -48,18 +48,6 @@ impl SelectOptions {
     }
 }
 
-pub struct SelectResult {
-    pub remote: Remote,
-    pub repo: Rc<Repo>,
-    pub exists: bool,
-}
-
-impl SelectResult {
-    pub fn as_repo(self) -> (Remote, Rc<Repo>) {
-        (self.remote, self.repo)
-    }
-}
-
 pub struct Query<'a> {
     db: &'a Database,
 
@@ -86,19 +74,15 @@ impl<'a> Query<'_> {
         Query { db, query }
     }
 
-    pub fn select(&self, opts: SelectOptions) -> Result<SelectResult> {
+    pub fn select(&self, opts: SelectOptions) -> Result<(Remote, Rc<Repo>, bool)> {
         if self.query.is_empty() {
             let repo = if opts.search {
                 self.search_local(self.db.list_all(), NameLevel::Full)?
             } else {
                 self.db.must_latest("")?
             };
             let remote = config::must_get_remote(repo.remote.as_str())?;
-            return Ok(SelectResult {
-                remote,
-                repo,
-                exists: true,
-            });
+            return Ok((remote, repo, true));
         }
 
         if self.query.len() == 1 {
@@ -111,20 +95,12 @@ impl<'a> Query<'_> {
                         self.db.must_latest(&remote.name)?
                     };
                     let remote = config::must_get_remote(repo.remote.as_str())?;
-                    Ok(SelectResult {
-                        remote,
-                        repo,
-                        exists: true,
-                    })
+                    Ok((remote, repo, true))
                 }
                 None => {
                     let repo = self.db.must_get_fuzzy("", maybe_remote)?;
                     let remote = config::must_get_remote(repo.remote.as_str())?;
-                    Ok(SelectResult {
-                        remote,
-                        repo,
-                        exists: true,
-                    })
+                    Ok((remote, repo, true))
                 }
             };
         }
@@ -144,11 +120,7 @@ impl<'a> Query<'_> {
                     self.db.list_by_owner(remote.name.as_str(), owner),
                     NameLevel::Name,
                 )?;
-                return Ok(SelectResult {
-                    remote,
-                    repo,
-                    exists: true,
-                });
+                return Ok((remote, repo, true));
             }
 
             let provider = api::init_provider(&remote, opts.force)?;
@@ -161,24 +133,20 @@ impl<'a> Query<'_> {
         let (owner, name) = parse_owner(query);
         if owner.is_empty() {
             let repo = self.db.must_get_fuzzy(&remote.name, &name)?;
-            return Ok(SelectResult {
-                remote,
-                repo,
-                exists: true,
-            });
+            return Ok((remote, repo, true));
         }
         return Ok(self.get_repo(remote, owner, name, &opts));
     }
 
     pub fn must_select(&self, opts: SelectOptions) -> Result<(Remote, Rc<Repo>)> {
-        let result = self.select(opts)?;
-        if !result.exists {
-            bail!("Could not find repo {}", result.repo.full_name());
+        let (remote, repo, exists) = self.select(opts)?;
+        if !exists {
+            bail!("Could not find repo {}", repo.full_name());
         }
-        Ok(result.as_repo())
+        Ok((remote, repo))
     }
 
-    pub fn select_remote(&self, opts: SelectOptions) -> Result<SelectResult> {
+    pub fn select_remote(&self, opts: SelectOptions) -> Result<(Remote, Rc<Repo>, bool)> {
         assert!(self.query.len() == 2);
         let remote_name = &self.query[0];
         let remote = config::must_get_remote(remote_name)?;
@@ -216,19 +184,21 @@ impl<'a> Query<'_> {
         Ok(repo)
     }
 
-    fn get_repo<S>(&self, remote: Remote, owner: S, name: S, opts: &SelectOptions) -> SelectResult
+    fn get_repo<S>(
+        &self,
+        remote: Remote,
+        owner: S,
+        name: S,
+        opts: &SelectOptions,
+    ) -> (Remote, Rc<Repo>, bool)
     where
         S: AsRef<str>,
     {
         match self
             .db
             .get(remote.name.as_str(), owner.as_ref(), name.as_ref())
         {
-            Some(repo) => SelectResult {
-                remote,
-                repo,
-                exists: true,
-            },
+            Some(repo) => (remote, repo, true),
             None => {
                 let remote_name = remote.name.clone();
                 let repo = Repo::new(
@@ -237,11 +207,7 @@ impl<'a> Query<'_> {
                     name.as_ref().to_string(),
                     opts.repo_path.clone(),
                 );
-                SelectResult {
-                    remote,
-                    repo,
-                    exists: false,
-                }
+                (remote, repo, false)
             }
         }
     }
@@ -304,17 +270,17 @@ impl<'a> Query<'_> {
         Ok((vec![repo], NameLevel::Name))
     }
 
-    pub fn list_remote(&self, force: bool, filter: bool) -> Result<(Remote, Vec<String>)> {
-        let (remote, names) = self.list_remote_raw(force)?;
+    pub fn list_remote(&self, force: bool, filter: bool) -> Result<(Remote, String, Vec<String>)> {
+        let (remote, owner, names) = self.list_remote_raw(force)?;
         if filter {
             let names = utils::edit_items(names.clone())?;
-            return Ok((remote, names));
+            return Ok((remote, owner, names));
         }
 
-        Ok((remote, names))
+        Ok((remote, owner, names))
     }
 
-    fn list_remote_raw(&self, force: bool) -> Result<(Remote, Vec<String>)> {
+    fn list_remote_raw(&self, force: bool) -> Result<(Remote, String, Vec<String>)> {
         assert!(self.query.len() == 2);
 
         let remote_name = &self.query[0];
@@ -323,7 +289,7 @@ impl<'a> Query<'_> {
 
         let (owner, name) = parse_owner(&query);
         if !owner.is_empty() && !name.is_empty() {
-            return Ok((remote, vec![query.clone()]));
+            return Ok((remote, owner, vec![query.clone()]));
         }
         let owner = match query.strip_suffix("/") {
             Some(owner) => owner,
@@ -339,7 +305,7 @@ impl<'a> Query<'_> {
             .into_iter()
             .filter(|name| !attached_set.contains(name.as_str()))
             .collect();
-        Ok((remote, names))
+        Ok((remote, owner.to_string(), names))
     }
 }