API tools faq
paste
Guest User

Untitled

a guest
Mar 23rd, 2018
89
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 24.44 KB | None | 0 0
raw download clone embed print report
  1. diff --git a/src/bin/commands/read_manifest.rs b/src/bin/commands/read_manifest.rs
  2. index d89fe5b..e08d864 100644
  3. --- a/src/bin/commands/read_manifest.rs
  4. +++ b/src/bin/commands/read_manifest.rs
  5. @@ -1,6 +1,5 @@
  6. use command_prelude::*;
  7.  
  8. -use cargo::core::Package;
  9. use cargo::print_json;
  10.  
  11. pub fn cli() -> App {
  12. @@ -11,8 +10,7 @@ Print a JSON representation of a Cargo.toml manifest.")
  13. }
  14.  
  15. pub fn exec(config: &mut Config, args: &ArgMatches) -> CliResult {
  16. - let root = args.root_manifest(config)?;
  17. - let pkg = Package::for_path(&root, config)?;
  18. - print_json(&pkg);
  19. + let ws = args.workspace(config)?;
  20. + print_json(&ws.current()?);
  21. Ok(())
  22. }
  23. diff --git a/src/cargo/core/dependency.rs b/src/cargo/core/dependency.rs
  24. index a85c83a..6894287 100644
  25. --- a/src/cargo/core/dependency.rs
  26. +++ b/src/cargo/core/dependency.rs
  27. @@ -329,9 +329,8 @@ impl Dependency {
  28. }
  29.  
  30. /// Returns true if the package (`sum`) can fulfill this dependency request.
  31. - pub fn matches_ignoring_source(&self, sum: &Summary) -> bool {
  32. - self.name() == sum.package_id().name() &&
  33. - self.version_req().matches(sum.package_id().version())
  34. + pub fn matches_ignoring_source(&self, id: &PackageId) -> bool {
  35. + self.name() == id.name() && self.version_req().matches(id.version())
  36. }
  37.  
  38. /// Returns true if the package (`id`) can fulfill this dependency request.
  39. diff --git a/src/cargo/core/package.rs b/src/cargo/core/package.rs
  40. index 6fdc1f1..7d8ebff 100644
  41. --- a/src/cargo/core/package.rs
  42. +++ b/src/cargo/core/package.rs
  43. @@ -12,7 +12,6 @@ use lazycell::LazyCell;
  44. use core::{Dependency, Manifest, PackageId, SourceId, Target};
  45. use core::{Summary, SourceMap};
  46. use core::interning::InternedString;
  47. -use ops;
  48. use util::{Config, internal, lev_distance};
  49. use util::errors::{CargoResult, CargoResultExt};
  50.  
  51. @@ -81,14 +80,6 @@ impl Package {
  52. }
  53. }
  54.  
  55. - /// Calculate the Package from the manifest path (and cargo configuration).
  56. - pub fn for_path(manifest_path: &Path, config: &Config) -> CargoResult<Package> {
  57. - let path = manifest_path.parent().unwrap();
  58. - let source_id = SourceId::for_path(path)?;
  59. - let (pkg, _) = ops::read_package(manifest_path, &source_id, config)?;
  60. - Ok(pkg)
  61. - }
  62. -
  63. /// Get the manifest dependencies
  64. pub fn dependencies(&self) -> &[Dependency] { self.manifest.dependencies() }
  65. /// Get the manifest
  66. diff --git a/src/cargo/core/registry.rs b/src/cargo/core/registry.rs
  67. index 56f6eed..703c111 100644
  68. --- a/src/cargo/core/registry.rs
  69. +++ b/src/cargo/core/registry.rs
  70. @@ -412,7 +412,7 @@ impl<'cfg> Registry for PackageRegistry<'cfg> {
  71. let mut patches = Vec::<Summary>::new();
  72. if let Some(extra) = self.patches.get(dep.source_id().url()) {
  73. patches.extend(extra.iter().filter(|s| {
  74. - dep.matches_ignoring_source(s)
  75. + dep.matches_ignoring_source(s.package_id())
  76. }).cloned());
  77. }
  78.  
  79. diff --git a/src/cargo/core/resolver/encode.rs b/src/cargo/core/resolver/encode.rs
  80. index b0f7264..7b4d43d 100644
  81. --- a/src/cargo/core/resolver/encode.rs
  82. +++ b/src/cargo/core/resolver/encode.rs
  83. @@ -6,7 +6,7 @@ use serde::ser;
  84. use serde::de;
  85.  
  86. use core::{Package, PackageId, SourceId, Workspace, Dependency};
  87. -use util::{Graph, Config, internal};
  88. +use util::{Graph, internal};
  89. use util::errors::{CargoResult, CargoResultExt, CargoError};
  90.  
  91. use super::Resolve;
  92. @@ -187,7 +187,7 @@ impl EncodableResolve {
  93. }
  94. }
  95.  
  96. -fn build_path_deps(ws: &Workspace) -> HashMap<String, SourceId> {
  97. +fn build_path_deps(ws: &Workspace) -> (HashMap<String, SourceId>) {
  98. // If a crate is *not* a path source, then we're probably in a situation
  99. // such as `cargo install` with a lock file from a remote dependency. In
  100. // that case we don't need to fixup any path dependencies (as they're not
  101. @@ -204,30 +204,30 @@ fn build_path_deps(ws: &Workspace) -> HashMap<String, SourceId> {
  102. visited.insert(member.package_id().source_id().clone());
  103. }
  104. for member in members.iter() {
  105. - build_pkg(member, ws.config(), &mut ret, &mut visited);
  106. + build_pkg(member, ws, &mut ret, &mut visited);
  107. }
  108. for deps in ws.root_patch().values() {
  109. for dep in deps {
  110. - build_dep(dep, ws.config(), &mut ret, &mut visited);
  111. + build_dep(dep, ws, &mut ret, &mut visited);
  112. }
  113. }
  114. for &(_, ref dep) in ws.root_replace() {
  115. - build_dep(dep, ws.config(), &mut ret, &mut visited);
  116. + build_dep(dep, ws, &mut ret, &mut visited);
  117. }
  118.  
  119. return ret;
  120.  
  121. fn build_pkg(pkg: &Package,
  122. - config: &Config,
  123. + ws: &Workspace,
  124. ret: &mut HashMap<String, SourceId>,
  125. visited: &mut HashSet<SourceId>) {
  126. for dep in pkg.dependencies() {
  127. - build_dep(dep, config, ret, visited);
  128. + build_dep(dep, ws, ret, visited);
  129. }
  130. }
  131.  
  132. fn build_dep(dep: &Dependency,
  133. - config: &Config,
  134. + ws: &Workspace,
  135. ret: &mut HashMap<String, SourceId>,
  136. visited: &mut HashSet<SourceId>) {
  137. let id = dep.source_id();
  138. @@ -238,14 +238,13 @@ fn build_path_deps(ws: &Workspace) -> HashMap<String, SourceId> {
  139. Ok(p) => p.join("Cargo.toml"),
  140. Err(_) => return,
  141. };
  142. - let pkg = match Package::for_path(&path, config) {
  143. + let pkg = match ws.load(&path) {
  144. Ok(p) => p,
  145. Err(_) => return,
  146. };
  147. - ret.insert(pkg.name().to_string(),
  148. - pkg.package_id().source_id().clone());
  149. + ret.insert(pkg.name().to_string(), pkg.package_id().source_id().clone());
  150. visited.insert(pkg.package_id().source_id().clone());
  151. - build_pkg(&pkg, config, ret, visited);
  152. + build_pkg(&pkg, ws, ret, visited);
  153. }
  154. }
  155.  
  156. diff --git a/src/cargo/core/resolver/mod.rs b/src/cargo/core/resolver/mod.rs
  157. index af3db55..abc8689 100644
  158. --- a/src/cargo/core/resolver/mod.rs
  159. +++ b/src/cargo/core/resolver/mod.rs
  160. @@ -363,6 +363,7 @@ type Activations = HashMap<(InternedString, SourceId), Rc<Vec<Summary>>>;
  161. pub fn resolve(summaries: &[(Summary, Method)],
  162. replacements: &[(PackageIdSpec, Dependency)],
  163. registry: &mut Registry,
  164. + try_to_use: &[&PackageId],
  165. config: Option<&Config>,
  166. print_warnings: bool) -> CargoResult<Resolve> {
  167. let cx = Context {
  168. @@ -374,7 +375,8 @@ pub fn resolve(summaries: &[(Summary, Method)],
  169. warnings: RcList::new(),
  170. };
  171. let _p = profile::start("resolving");
  172. - let cx = activate_deps_loop(cx, &mut RegistryQueryer::new(registry, replacements), summaries, config)?;
  173. + let mut registry = RegistryQueryer::new(registry, replacements, try_to_use);
  174. + let cx = activate_deps_loop(cx, &mut registry, summaries, config)?;
  175.  
  176. let mut resolve = Resolve {
  177. graph: cx.graph(),
  178. @@ -585,16 +587,20 @@ impl ConflictReason {
  179. struct RegistryQueryer<'a> {
  180. registry: &'a mut (Registry + 'a),
  181. replacements: &'a [(PackageIdSpec, Dependency)],
  182. + try_to_use: HashSet<&'a PackageId>,
  183. // TODO: with nll the Rc can be removed
  184. cache: HashMap<Dependency, Rc<Vec<Candidate>>>,
  185. }
  186.  
  187. impl<'a> RegistryQueryer<'a> {
  188. - fn new(registry: &'a mut Registry, replacements: &'a [(PackageIdSpec, Dependency)],) -> Self {
  189. + fn new(registry: &'a mut Registry,
  190. + replacements: &'a [(PackageIdSpec, Dependency)],
  191. + try_to_use: &'a [&'a PackageId]) -> Self {
  192. RegistryQueryer {
  193. registry,
  194. replacements,
  195. cache: HashMap::new(),
  196. + try_to_use: try_to_use.iter().cloned().collect(),
  197. }
  198. }
  199.  
  200. @@ -673,7 +679,11 @@ impl<'a> RegistryQueryer<'a> {
  201. // When we attempt versions for a package, we'll want to start at
  202. // the maximum version and work our way down.
  203. ret.sort_unstable_by(|a, b| {
  204. - b.summary.version().cmp(a.summary.version())
  205. + let a_in_previous = self.try_to_use.contains(a.summary.package_id());
  206. + let b_in_previous = self.try_to_use.contains(b.summary.package_id());
  207. + let a = (a_in_previous, a.summary.version());
  208. + let b = (b_in_previous, b.summary.version());
  209. + a.cmp(&b).reverse()
  210. });
  211.  
  212. let out = Rc::new(ret);
  213. diff --git a/src/cargo/core/workspace.rs b/src/cargo/core/workspace.rs
  214. index b91abd1..35599ea 100644
  215. --- a/src/cargo/core/workspace.rs
  216. +++ b/src/cargo/core/workspace.rs
  217. @@ -1,3 +1,4 @@
  218. +use std::cell::RefCell;
  219. use std::collections::hash_map::{HashMap, Entry};
  220. use std::collections::BTreeMap;
  221. use std::path::{Path, PathBuf};
  222. @@ -8,6 +9,9 @@ use url::Url;
  223.  
  224. use core::{Package, VirtualManifest, EitherManifest, SourceId};
  225. use core::{PackageIdSpec, Dependency, Profile, Profiles};
  226. +use core::registry::PackageRegistry;
  227. +use ops;
  228. +use sources::PathSource;
  229. use util::{Config, Filesystem};
  230. use util::errors::{CargoResult, CargoResultExt};
  231. use util::paths;
  232. @@ -67,6 +71,8 @@ pub struct Workspace<'cfg> {
  233. // needed by the current configuration (such as in cargo install). In some
  234. // cases `false` also results in the non-enforcement of dev-dependencies.
  235. require_optional_deps: bool,
  236. +
  237. + loaded_packages: RefCell<HashMap<PathBuf, Package>>,
  238. }
  239.  
  240. // Separate structure for tracking loaded packages (to avoid loading anything
  241. @@ -138,6 +144,7 @@ impl<'cfg> Workspace<'cfg> {
  242. default_members: Vec::new(),
  243. is_ephemeral: false,
  244. require_optional_deps: true,
  245. + loaded_packages: RefCell::new(HashMap::new()),
  246. };
  247. ws.root_manifest = ws.find_root(manifest_path)?;
  248. ws.find_members()?;
  249. @@ -171,6 +178,7 @@ impl<'cfg> Workspace<'cfg> {
  250. default_members: Vec::new(),
  251. is_ephemeral: true,
  252. require_optional_deps,
  253. + loaded_packages: RefCell::new(HashMap::new()),
  254. };
  255. {
  256. let key = ws.current_manifest.parent().unwrap();
  257. @@ -627,12 +635,48 @@ impl<'cfg> Workspace<'cfg> {
  258.  
  259. Ok(())
  260. }
  261. +
  262. + pub fn load(&self, manifest_path: &Path) -> CargoResult<Package> {
  263. + match self.packages.maybe_get(manifest_path) {
  264. + Some(&MaybePackage::Package(ref p)) => return Ok(p.clone()),
  265. + Some(&MaybePackage::Virtual(_)) => bail!("cannot load workspace root"),
  266. + None => {}
  267. + }
  268. +
  269. + let mut loaded = self.loaded_packages.borrow_mut();
  270. + if let Some(p) = loaded.get(manifest_path).cloned() {
  271. + return Ok(p)
  272. + }
  273. + let source_id = SourceId::for_path(manifest_path.parent().unwrap())?;
  274. + let (package, _nested_paths) =
  275. + ops::read_package(manifest_path, &source_id, self.config)?;
  276. + loaded.insert(manifest_path.to_path_buf(), package.clone());
  277. + Ok(package)
  278. + }
  279. +
  280. + pub fn preload(&self, registry: &mut PackageRegistry<'cfg>) {
  281. + for pkg in self.packages.packages.values() {
  282. + let pkg = match *pkg {
  283. + MaybePackage::Package(ref p) => p.clone(),
  284. + MaybePackage::Virtual(_) => continue,
  285. + };
  286. + let mut src = PathSource::new(pkg.manifest_path(),
  287. + pkg.package_id().source_id(),
  288. + self.config);
  289. + src.preload_with(pkg);
  290. + registry.add_preloaded(Box::new(src));
  291. + }
  292. + }
  293. }
  294.  
  295.  
  296. impl<'cfg> Packages<'cfg> {
  297. fn get(&self, manifest_path: &Path) -> &MaybePackage {
  298. - &self.packages[manifest_path.parent().unwrap()]
  299. + self.maybe_get(manifest_path).unwrap()
  300. + }
  301. +
  302. + fn maybe_get(&self, manifest_path: &Path) -> Option<&MaybePackage> {
  303. + self.packages.get(manifest_path.parent().unwrap())
  304. }
  305.  
  306. fn load(&mut self, manifest_path: &Path) -> CargoResult<&MaybePackage> {
  307. diff --git a/src/cargo/ops/cargo_rustc/mod.rs b/src/cargo/ops/cargo_rustc/mod.rs
  308. index 4cbdf2d..aba3ef1 100644
  309. --- a/src/cargo/ops/cargo_rustc/mod.rs
  310. +++ b/src/cargo/ops/cargo_rustc/mod.rs
  311. @@ -974,7 +974,7 @@ Cargo.toml. This warning might turn into a hard error in the future.",
  312. // to tighten up this in the future.
  313. let name = current.pkg.dependencies()
  314. .iter()
  315. - .filter(|d| d.matches_ignoring_source(dep.pkg.summary()))
  316. + .filter(|d| d.matches_ignoring_source(dep.pkg.package_id()))
  317. .filter_map(|d| d.rename())
  318. .next();
  319.  
  320. diff --git a/src/cargo/ops/registry.rs b/src/cargo/ops/registry.rs
  321. index 9edd720..31716e7 100644
  322. --- a/src/cargo/ops/registry.rs
  323. +++ b/src/cargo/ops/registry.rs
  324. @@ -400,8 +400,8 @@ pub fn modify_owners(config: &Config, opts: &OwnersOptions) -> CargoResult<()> {
  325. Some(ref name) => name.clone(),
  326. None => {
  327. let manifest_path = find_root_manifest_for_wd(None, config.cwd())?;
  328. - let pkg = Package::for_path(&manifest_path, config)?;
  329. - pkg.name().to_string()
  330. + let ws = Workspace::new(&manifest_path, config)?;
  331. + ws.current()?.package_id().name().to_string()
  332. }
  333. };
  334.  
  335. @@ -457,8 +457,8 @@ pub fn yank(config: &Config,
  336. Some(name) => name,
  337. None => {
  338. let manifest_path = find_root_manifest_for_wd(None, config.cwd())?;
  339. - let pkg = Package::for_path(&manifest_path, config)?;
  340. - pkg.name().to_string()
  341. + let ws = Workspace::new(&manifest_path, config)?;
  342. + ws.current()?.package_id().name().to_string()
  343. }
  344. };
  345. let version = match version {
  346. diff --git a/src/cargo/ops/resolve.rs b/src/cargo/ops/resolve.rs
  347. index 6ade551..611e8f3 100644
  348. --- a/src/cargo/ops/resolve.rs
  349. +++ b/src/cargo/ops/resolve.rs
  350. @@ -95,8 +95,13 @@ pub fn resolve_ws_with_method<'a>(ws: &Workspace<'a>,
  351. Ok((packages, resolved_with_overrides))
  352. }
  353.  
  354. -fn resolve_with_registry(ws: &Workspace, registry: &mut PackageRegistry, warn: bool)
  355. - -> CargoResult<Resolve> {
  356. +fn resolve_with_registry<'cfg>(
  357. + ws: &Workspace<'cfg>,
  358. + registry: &mut PackageRegistry<'cfg>,
  359. + warn: bool,
  360. +)
  361. + -> CargoResult<Resolve>
  362. +{
  363. let prev = ops::load_pkg_lockfile(ws)?;
  364. let resolve = resolve_with_previous(registry,
  365. ws,
  366. @@ -123,15 +128,18 @@ fn resolve_with_registry(ws: &Workspace, registry: &mut PackageRegistry, warn: b
  367. ///
  368. /// The previous resolve normally comes from a lockfile. This function does not
  369. /// read or write lockfiles from the filesystem.
  370. -pub fn resolve_with_previous<'a>(registry: &mut PackageRegistry,
  371. - ws: &Workspace,
  372. - method: Method,
  373. - previous: Option<&'a Resolve>,
  374. - to_avoid: Option<&HashSet<&'a PackageId>>,
  375. - specs: &[PackageIdSpec],
  376. - register_patches: bool,
  377. - warn: bool)
  378. - -> CargoResult<Resolve> {
  379. +pub fn resolve_with_previous<'a, 'cfg>(
  380. + registry: &mut PackageRegistry<'cfg>,
  381. + ws: &Workspace<'cfg>,
  382. + method: Method,
  383. + previous: Option<&'a Resolve>,
  384. + to_avoid: Option<&HashSet<&'a PackageId>>,
  385. + specs: &[PackageIdSpec],
  386. + register_patches: bool,
  387. + warn: bool,
  388. +)
  389. + -> CargoResult<Resolve>
  390. +{
  391. // Here we place an artificial limitation that all non-registry sources
  392. // cannot be locked at more than one revision. This means that if a git
  393. // repository provides more than one package, they must all be updated in
  394. @@ -174,14 +182,11 @@ pub fn resolve_with_previous<'a>(registry: &mut PackageRegistry,
  395. // ranges. To deal with this, we only actually lock a dependency
  396. // to the previously resolved version if the dependency listed
  397. // still matches the locked version.
  398. + let mut try_to_use = Vec::new();
  399. if let Some(r) = previous {
  400. trace!("previous: {:?}", r);
  401. - for node in r.iter().filter(keep) {
  402. - let deps = r.deps_not_replaced(node)
  403. - .filter(keep)
  404. - .cloned().collect();
  405. - registry.register_lock(node.clone(), deps);
  406. - }
  407. + register_previous_locks(ws, registry, r, keep);
  408. + try_to_use.extend(r.iter().filter(keep));
  409. }
  410.  
  411. if register_patches {
  412. @@ -277,9 +282,11 @@ pub fn resolve_with_previous<'a>(registry: &mut PackageRegistry,
  413. None => root_replace.to_vec(),
  414. };
  415.  
  416. + ws.preload(registry);
  417. let mut resolved = resolver::resolve(&summaries,
  418. &replace,
  419. registry,
  420. + &try_to_use,
  421. Some(ws.config()),
  422. warn)?;
  423. resolved.register_used_patches(registry.patches());
  424. @@ -325,3 +332,52 @@ fn get_resolved_packages<'a>(resolve: &Resolve,
  425. registry.get(&ids)
  426. }
  427.  
  428. +fn register_previous_locks<'a>(ws: &Workspace,
  429. + registry: &mut PackageRegistry,
  430. + resolve: &'a Resolve,
  431. + keep: &Fn(&&'a PackageId) -> bool) {
  432. + let mut avoid_locking = HashSet::new();
  433. + for node in resolve.iter() {
  434. + if !keep(&node) {
  435. + add_deps(resolve, node, &mut avoid_locking);
  436. + continue
  437. + }
  438. + let path = match node.source_id().url().to_file_path() {
  439. + Ok(path) => path,
  440. + Err(_) => continue,
  441. + };
  442. + let pkg = match ws.load(&path.join("Cargo.toml")) {
  443. + Ok(p) => p,
  444. + Err(_) => continue,
  445. + };
  446. + for dep in resolve.deps_not_replaced(node) {
  447. + // Note that the source is ignored here to account for `[patch]`.
  448. + // The correctness of this is... somewhat unknown, but it seems to
  449. + // work well enough for now.
  450. + if !pkg.dependencies().iter().any(|d| d.matches_ignoring_source(dep)) {
  451. + add_deps(resolve, dep, &mut avoid_locking);
  452. + }
  453. + }
  454. + }
  455. +
  456. + let ref keep = |id: &&'a PackageId| keep(id) && !avoid_locking.contains(id);
  457. +
  458. + for node in resolve.iter().filter(keep) {
  459. + let deps = resolve.deps_not_replaced(node)
  460. + .filter(keep)
  461. + .cloned()
  462. + .collect();
  463. + registry.register_lock(node.clone(), deps);
  464. + }
  465. +
  466. + fn add_deps<'a>(resolve: &'a Resolve,
  467. + node: &'a PackageId,
  468. + set: &mut HashSet<&'a PackageId>) {
  469. + if !set.insert(node) {
  470. + return
  471. + }
  472. + for dep in resolve.deps_not_replaced(node) {
  473. + add_deps(resolve, dep, set);
  474. + }
  475. + }
  476. +}
  477. diff --git a/src/cargo/sources/path.rs b/src/cargo/sources/path.rs
  478. index fa7fc13..a3deae1 100644
  479. --- a/src/cargo/sources/path.rs
  480. +++ b/src/cargo/sources/path.rs
  481. @@ -55,6 +55,14 @@ impl<'cfg> PathSource<'cfg> {
  482. }
  483. }
  484.  
  485. + pub fn preload_with(&mut self, pkg: Package) {
  486. + assert!(!self.updated);
  487. + assert!(!self.recursive);
  488. + assert!(self.packages.is_empty());
  489. + self.updated = true;
  490. + self.packages.push(pkg);
  491. + }
  492. +
  493. pub fn root_package(&mut self) -> CargoResult<Package> {
  494. trace!("root_package; source={:?}", self);
  495.  
  496. diff --git a/src/cargo/util/config.rs b/src/cargo/util/config.rs
  497. index 927d0e1..fc67b8a 100644
  498. --- a/src/cargo/util/config.rs
  499. +++ b/src/cargo/util/config.rs
  500. @@ -68,9 +68,7 @@ pub struct Config {
  501. }
  502.  
  503. impl Config {
  504. - pub fn new(shell: Shell,
  505. - cwd: PathBuf,
  506. - homedir: PathBuf) -> Config {
  507. + pub fn new(shell: Shell, cwd: PathBuf, homedir: PathBuf) -> Config {
  508. static mut GLOBAL_JOBSERVER: *mut jobserver::Client = 0 as *mut _;
  509. static INIT: Once = ONCE_INIT;
  510.  
  511. diff --git a/tests/testsuite/lib.rs b/tests/testsuite/lib.rs
  512. index 9f66a61..eb1f519 100644
  513. --- a/tests/testsuite/lib.rs
  514. +++ b/tests/testsuite/lib.rs
  515. @@ -81,6 +81,7 @@ mod search;
  516. mod small_fd_limits;
  517. mod test;
  518. mod tool_paths;
  519. +mod update;
  520. mod verify_project;
  521. mod version;
  522. mod warn_on_failure;
  523. diff --git a/tests/testsuite/resolve.rs b/tests/testsuite/resolve.rs
  524. index 735e216..1694ee0 100644
  525. --- a/tests/testsuite/resolve.rs
  526. +++ b/tests/testsuite/resolve.rs
  527. @@ -31,7 +31,12 @@ fn resolve(pkg: &PackageId, deps: Vec<Dependency>, registry: &[Summary])
  528. let mut registry = MyRegistry(registry);
  529. let summary = Summary::new(pkg.clone(), deps, BTreeMap::new(), None).unwrap();
  530. let method = Method::Everything;
  531. - let resolve = resolver::resolve(&[(summary, method)], &[], &mut registry, None, false)?;
  532. + let resolve = resolver::resolve(&[(summary, method)],
  533. + &[],
  534. + &mut registry,
  535. + &[],
  536. + None,
  537. + false)?;
  538. let res = resolve.iter().cloned().collect();
  539. Ok(res)
  540. }
  541. diff --git a/tests/testsuite/update.rs b/tests/testsuite/update.rs
  542. new file mode 100644
  543. index 0000000..186ca89
  544. --- /dev/null
  545. +++ b/tests/testsuite/update.rs
  546. @@ -0,0 +1,143 @@
  547. +use std::fs::File;
  548. +use std::io::prelude::*;
  549. +
  550. +use cargotest::support::{project, execs};
  551. +use cargotest::support::registry::Package;
  552. +use hamcrest::assert_that;
  553. +
  554. +#[test]
  555. +fn minor_update_two_places() {
  556. + Package::new("log", "0.1.0").publish();
  557. + let p = project("foo")
  558. + .file("Cargo.toml", r#"
  559. + [package]
  560. + name = "bar"
  561. + version = "0.0.1"
  562. + authors = []
  563. +
  564. + [dependencies]
  565. + log = "0.1"
  566. + foo = { path = "foo" }
  567. + "#)
  568. + .file("src/lib.rs", "")
  569. + .file("foo/Cargo.toml", r#"
  570. + [package]
  571. + name = "foo"
  572. + version = "0.0.1"
  573. + authors = []
  574. +
  575. + [dependencies]
  576. + log = "0.1"
  577. + "#)
  578. + .file("foo/src/lib.rs", "")
  579. + .build();
  580. +
  581. + assert_that(p.cargo("build"), execs().with_status(0));
  582. + Package::new("log", "0.1.1").publish();
  583. +
  584. + File::create(p.root().join("foo/Cargo.toml")).unwrap().write_all(br#"
  585. + [package]
  586. + name = "foo"
  587. + version = "0.0.1"
  588. + authors = []
  589. +
  590. + [dependencies]
  591. + log = "0.1.1"
  592. + "#).unwrap();
  593. +
  594. + assert_that(p.cargo("build").env("RUST_LOG", "cargo=trace"),
  595. + execs().with_status(0));
  596. +}
  597. +
  598. +#[test]
  599. +fn transitive_minor_update() {
  600. + Package::new("log", "0.1.0").publish();
  601. + Package::new("serde", "0.1.0")
  602. + .dep("log", "0.1")
  603. + .publish();
  604. +
  605. + let p = project("foo")
  606. + .file("Cargo.toml", r#"
  607. + [package]
  608. + name = "bar"
  609. + version = "0.0.1"
  610. + authors = []
  611. +
  612. + [dependencies]
  613. + serde = "0.1"
  614. + log = "0.1"
  615. + foo = { path = "foo" }
  616. + "#)
  617. + .file("src/lib.rs", "")
  618. + .file("foo/Cargo.toml", r#"
  619. + [package]
  620. + name = "foo"
  621. + version = "0.0.1"
  622. + authors = []
  623. +
  624. + [dependencies]
  625. + serde = "0.1"
  626. + "#)
  627. + .file("foo/src/lib.rs", "")
  628. + .build();
  629. +
  630. + assert_that(p.cargo("build"), execs().with_status(0));
  631. +
  632. + Package::new("log", "0.1.1").publish();
  633. + Package::new("serde", "0.1.1")
  634. + .dep("log", "0.1.1")
  635. + .publish();
  636. +
  637. + assert_that(p.cargo("update").arg("-p").arg("serde"),
  638. + execs().with_status(0).with_stderr("\
  639. +[UPDATING] registry `[..]`
  640. +[UPDATING] log v0.1.0 -> v0.1.1
  641. +[UPDATING] serde v0.1.0 -> v0.1.1
  642. +"));
  643. +}
  644. +
  645. +#[test]
  646. +fn conservative() {
  647. + Package::new("log", "0.1.0").publish();
  648. + Package::new("serde", "0.1.0")
  649. + .dep("log", "0.1")
  650. + .publish();
  651. +
  652. + let p = project("foo")
  653. + .file("Cargo.toml", r#"
  654. + [package]
  655. + name = "bar"
  656. + version = "0.0.1"
  657. + authors = []
  658. +
  659. + [dependencies]
  660. + serde = "0.1"
  661. + log = "0.1"
  662. + foo = { path = "foo" }
  663. + "#)
  664. + .file("src/lib.rs", "")
  665. + .file("foo/Cargo.toml", r#"
  666. + [package]
  667. + name = "foo"
  668. + version = "0.0.1"
  669. + authors = []
  670. +
  671. + [dependencies]
  672. + serde = "0.1"
  673. + "#)
  674. + .file("foo/src/lib.rs", "")
  675. + .build();
  676. +
  677. + assert_that(p.cargo("build"), execs().with_status(0));
  678. +
  679. + Package::new("log", "0.1.1").publish();
  680. + Package::new("serde", "0.1.1")
  681. + .dep("log", "0.1")
  682. + .publish();
  683. +
  684. + assert_that(p.cargo("update").arg("-p").arg("serde"),
  685. + execs().with_status(0).with_stderr("\
  686. +[UPDATING] registry `[..]`
  687. +[UPDATING] serde v0.1.0 -> v0.1.1
  688. +"));
  689. +}
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!