Duplicate query in Source, drop Registry parent type

.. and move query definitions to the struct impls.

diff --git a/src/cargo/core/source/mod.rs b/src/cargo/core/source/mod.rs
index 10418714bffc25caf125429355a7df0873d8ecdc..1c6eed63315d7c922d15bafb4ff12e4b7fb71c04 100644 (file)
--- a/src/cargo/core/source/mod.rs
+++ b/src/cargo/core/source/mod.rs
@@ -1,7 +1,7 @@
 use std::collections::hash_map::{HashMap, IterMut, Values};
 use std::fmt;
 
-use core::{Package, PackageId, Registry};
+use core::{Dependency, Package, PackageId, Summary};
 use util::CargoResult;
 
 mod source_id;
@@ -10,18 +10,27 @@ pub use self::source_id::{GitReference, SourceId};
 
 /// A Source finds and downloads remote packages based on names and
 /// versions.
-pub trait Source: Registry {
+pub trait Source {
     /// Returns the `SourceId` corresponding to this source
     fn source_id(&self) -> &SourceId;
 
-    /// Returns whether or not this registry will return summaries with
+    /// Returns whether or not this source will return summaries with
     /// checksums listed.
     fn supports_checksums(&self) -> bool;
 
-    /// Returns whether or not this registry will return summaries with
+    /// Returns whether or not this source will return summaries with
     /// the `precise` field in the source id listed.
     fn requires_precise(&self) -> bool;
 
+    /// Attempt to find the packages that match a dependency request.
+    fn query(&mut self, dep: &Dependency, f: &mut FnMut(Summary)) -> CargoResult<()>;
+
+    fn query_vec(&mut self, dep: &Dependency) -> CargoResult<Vec<Summary>> {
+        let mut ret = Vec::new();
+        self.query(dep, &mut |s| ret.push(s))?;
+        Ok(ret)
+    }
+
     /// The update method performs any network operations required to
     /// get the entire list of all names, versions and dependencies of
     /// packages managed by the Source.
@@ -70,6 +79,11 @@ impl<'a, T: Source + ?Sized + 'a> Source for Box<T> {
         (**self).requires_precise()
     }
 
+    /// Forwards to `Source::query`
+    fn query(&mut self, dep: &Dependency, f: &mut FnMut(Summary)) -> CargoResult<()> {
+        (**self).query(dep, f)
+    }
+
     /// Forwards to `Source::update`
     fn update(&mut self) -> CargoResult<()> {
         (**self).update()

diff --git a/src/cargo/sources/directory.rs b/src/cargo/sources/directory.rs
index 21a167ac1b335f99197213f93dcbf9f25335284d..2156164cf8cc38be62b6436a36991a7007cd5045 100644 (file)
--- a/src/cargo/sources/directory.rs
+++ b/src/cargo/sources/directory.rs
@@ -36,6 +36,15 @@ impl<'cfg> DirectorySource<'cfg> {
             packages: HashMap::new(),
         }
     }
+
+    fn query(&mut self, dep: &Dependency, f: &mut FnMut(Summary)) -> CargoResult<()> {
+        let packages = self.packages.values().map(|p| &p.0);
+        let matches = packages.filter(|pkg| dep.matches(pkg.summary()));
+        for summary in matches.map(|pkg| pkg.summary().clone()) {
+            f(summary);
+        }
+        Ok(())
+    }
 }
 
 impl<'cfg> Debug for DirectorySource<'cfg> {
@@ -46,12 +55,7 @@ impl<'cfg> Debug for DirectorySource<'cfg> {
 
 impl<'cfg> Registry for DirectorySource<'cfg> {
     fn query(&mut self, dep: &Dependency, f: &mut FnMut(Summary)) -> CargoResult<()> {
-        let packages = self.packages.values().map(|p| &p.0);
-        let matches = packages.filter(|pkg| dep.matches(pkg.summary()));
-        for summary in matches.map(|pkg| pkg.summary().clone()) {
-            f(summary);
-        }
-        Ok(())
+        self.query(dep, f)
     }
 }
 
@@ -68,6 +72,10 @@ impl<'cfg> Source for DirectorySource<'cfg> {
         true
     }
 
+    fn query(&mut self, dep: &Dependency, f: &mut FnMut(Summary)) -> CargoResult<()> {
+        self.query(dep, f)
+    }
+
     fn update(&mut self) -> CargoResult<()> {
         self.packages.clear();
         let entries = self.root.read_dir().chain_err(|| {

diff --git a/src/cargo/sources/git/source.rs b/src/cargo/sources/git/source.rs
index 332f37aa24077baed04c0e6c9db1fbdc3fc76b51..34e7f2c7c21660a39eb8d6daaff46fd37679b8c7 100644 (file)
--- a/src/cargo/sources/git/source.rs
+++ b/src/cargo/sources/git/source.rs
@@ -52,6 +52,13 @@ impl<'cfg> GitSource<'cfg> {
         self.remote.url()
     }
 
+    fn query(&mut self, dep: &Dependency, f: &mut FnMut(Summary)) -> CargoResult<()> {
+        let src = self.path_source
+            .as_mut()
+            .expect("BUG: update() must be called before query()");
+        Source::query(src, dep, f)
+    }
+
     pub fn read_packages(&mut self) -> CargoResult<Vec<Package>> {
         if self.path_source.is_none() {
             self.update()?;
@@ -126,10 +133,7 @@ impl<'cfg> Debug for GitSource<'cfg> {
 
 impl<'cfg> Registry for GitSource<'cfg> {
     fn query(&mut self, dep: &Dependency, f: &mut FnMut(Summary)) -> CargoResult<()> {
-        let src = self.path_source
-            .as_mut()
-            .expect("BUG: update() must be called before query()");
-        src.query(dep, f)
+        self.query(dep, f)
     }
 }
 
@@ -146,6 +150,10 @@ impl<'cfg> Source for GitSource<'cfg> {
         true
     }
 
+    fn query(&mut self, dep: &Dependency, f: &mut FnMut(Summary)) -> CargoResult<()> {
+        self.query(dep, f)
+    }
+
     fn update(&mut self) -> CargoResult<()> {
         let lock =
             self.config

diff --git a/src/cargo/sources/path.rs b/src/cargo/sources/path.rs
index e24e4996812dda02a7f8e12ed25d9f781c53e058..c8b9ab09575bab96d193f10a837447c581e01eb2 100644 (file)
--- a/src/cargo/sources/path.rs
+++ b/src/cargo/sources/path.rs
@@ -62,6 +62,15 @@ impl<'cfg> PathSource<'cfg> {
         self.packages.push(pkg);
     }
 
+    fn query(&mut self, dep: &Dependency, f: &mut FnMut(Summary)) -> CargoResult<()> {
+        for s in self.packages.iter().map(|p| p.summary()) {
+            if dep.matches(s) {
+                f(s.clone())
+            }
+        }
+        Ok(())
+    }
+
     pub fn root_package(&mut self) -> CargoResult<Package> {
         trace!("root_package; source={:?}", self);
 
@@ -477,12 +486,7 @@ impl<'cfg> Debug for PathSource<'cfg> {
 
 impl<'cfg> Registry for PathSource<'cfg> {
     fn query(&mut self, dep: &Dependency, f: &mut FnMut(Summary)) -> CargoResult<()> {
-        for s in self.packages.iter().map(|p| p.summary()) {
-            if dep.matches(s) {
-                f(s.clone())
-            }
-        }
-        Ok(())
+        self.query(dep, f)
     }
 }
 
@@ -499,6 +503,10 @@ impl<'cfg> Source for PathSource<'cfg> {
         false
     }
 
+    fn query(&mut self, dep: &Dependency, f: &mut FnMut(Summary)) -> CargoResult<()> {
+        self.query(dep, f)
+    }
+
     fn update(&mut self) -> CargoResult<()> {
         if !self.updated {
             let packages = self.read_packages()?;

diff --git a/src/cargo/sources/registry/mod.rs b/src/cargo/sources/registry/mod.rs
index 19c270ab018095a4dce87ff30f9478fc6b403142..4f6ae6bc5804aa7e9916c831a96a0383ce18c43f 100644 (file)
--- a/src/cargo/sources/registry/mod.rs
+++ b/src/cargo/sources/registry/mod.rs
@@ -352,6 +352,27 @@ impl<'cfg> RegistrySource<'cfg> {
         }
     }
 
+    fn query(&mut self, dep: &Dependency, f: &mut FnMut(Summary)) -> CargoResult<()> {
+        // If this is a precise dependency, then it came from a lockfile and in
+        // theory the registry is known to contain this version. If, however, we
+        // come back with no summaries, then our registry may need to be
+        // updated, so we fall back to performing a lazy update.
+        if dep.source_id().precise().is_some() && !self.updated {
+            let mut called = false;
+            self.index.query(dep, &mut *self.ops, &mut |s| {
+                called = true;
+                f(s);
+            })?;
+            if called {
+                return Ok(());
+            } else {
+                self.do_update()?;
+            }
+        }
+
+        self.index.query(dep, &mut *self.ops, f)
+    }
+
     /// Decode the configuration stored within the registry.
     ///
     /// This requires that the index has been at least checked out.
@@ -422,24 +443,7 @@ impl<'cfg> RegistrySource<'cfg> {
 
 impl<'cfg> Registry for RegistrySource<'cfg> {
     fn query(&mut self, dep: &Dependency, f: &mut FnMut(Summary)) -> CargoResult<()> {
-        // If this is a precise dependency, then it came from a lockfile and in
-        // theory the registry is known to contain this version. If, however, we
-        // come back with no summaries, then our registry may need to be
-        // updated, so we fall back to performing a lazy update.
-        if dep.source_id().precise().is_some() && !self.updated {
-            let mut called = false;
-            self.index.query(dep, &mut *self.ops, &mut |s| {
-                called = true;
-                f(s);
-            })?;
-            if called {
-                return Ok(());
-            } else {
-                self.do_update()?;
-            }
-        }
-
-        self.index.query(dep, &mut *self.ops, f)
+        self.query(dep, f)
     }
 }
 
@@ -456,6 +460,10 @@ impl<'cfg> Source for RegistrySource<'cfg> {
         false
     }
 
+    fn query(&mut self, dep: &Dependency, f: &mut FnMut(Summary)) -> CargoResult<()> {
+        self.query(dep, f)
+    }
+
     fn update(&mut self) -> CargoResult<()> {
         // If we have an imprecise version then we don't know what we're going
         // to look for, so we always attempt to perform an update here.

diff --git a/src/cargo/sources/replaced.rs b/src/cargo/sources/replaced.rs
index 84bab7f54077c1514bbc1607a4c80914b40dfea1..53fa3eab78b02a8a50e553aa975deb4f7b981ad0 100644 (file)
--- a/src/cargo/sources/replaced.rs
+++ b/src/cargo/sources/replaced.rs
@@ -19,9 +19,7 @@ impl<'cfg> ReplacedSource<'cfg> {
             inner: src,
         }
     }
-}
 
-impl<'cfg> Registry for ReplacedSource<'cfg> {
     fn query(&mut self, dep: &Dependency, f: &mut FnMut(Summary)) -> CargoResult<()> {
         let (replace_with, to_replace) = (&self.replace_with, &self.to_replace);
         let dep = dep.clone().map_source(to_replace, replace_with);
@@ -36,6 +34,12 @@ impl<'cfg> Registry for ReplacedSource<'cfg> {
     }
 }
 
+impl<'cfg> Registry for ReplacedSource<'cfg> {
+    fn query(&mut self, dep: &Dependency, f: &mut FnMut(Summary)) -> CargoResult<()> {
+        self.query(dep, f)
+    }
+}
+
 impl<'cfg> Source for ReplacedSource<'cfg> {
     fn source_id(&self) -> &SourceId {
         &self.to_replace
@@ -49,6 +53,10 @@ impl<'cfg> Source for ReplacedSource<'cfg> {
         self.inner.requires_precise()
     }
 
+    fn query(&mut self, dep: &Dependency, f: &mut FnMut(Summary)) -> CargoResult<()> {
+        self.query(dep, f)
+    }
+
     fn update(&mut self) -> CargoResult<()> {
         self.inner
             .update()