---

yaml
---
r: 69338
b: refs/heads/auto
c: 467d381
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -14,6 +14,6 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: bfac584a03f1e52808dc94aaa95703dd8847ab94
+refs/heads/auto: 467d381d3afce474309d6ba9a334fa9b463c3a7f
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c

branches/auto/src/etc/tidy.py

@@ -49,9 +49,9 @@ def do_license_check(name, contents):
                     report_err("FIXME without issue number")
             if line.find("TODO") != -1:
                 report_err("TODO is deprecated; use FIXME")
-            idx = line.find("// NOTE")
-            if idx != -1:
-                report_warn("NOTE" + line[idx + len("// NOTE"):])
+            match = re.match(r'^.*//\s*(NOTE.*)$', line)
+            if match:
+                report_warn(match.group(1))
         if (line.find('\t') != -1 and
             fileinput.filename().find("Makefile") == -1):
             report_err("tab character")

branches/auto/src/librustpkg/package_source.rs

@@ -11,13 +11,14 @@
 use target::*;
 use package_id::PkgId;
 use std::path::Path;
-use std::{os, str};
+use std::{os, run, str};
 use context::*;
 use crate::Crate;
 use messages::*;
-use source_control::{git_clone, git_clone_general};
+use source_control::git_clone;
 use path_util::pkgid_src_in_workspace;
 use util::compile_crate;
+use version::{ExactRevision, SemanticVersion, NoVersion};
 
 // An enumeration of the unpacked source of a package workspace.
 // This contains a list of files found in the source workspace.
@@ -101,13 +102,22 @@ impl PkgSrc {
         }
 
         let url = fmt!("https://%s", self.id.remote_path.to_str());
-        note(fmt!("Fetching package: git clone %s %s [version=%s]",
-                  url, local.to_str(), self.id.version.to_str()));
-        if git_clone_general(url, &local, &self.id.version) {
-            Some(local)
+        let branch_args = match self.id.version {
+                      NoVersion => ~[],
+                      ExactRevision(ref s) => ~[~"--branch", (*s).clone()],
+                      SemanticVersion(ref s) => ~[~"--branch", s.to_str()]
+        };
+
+
+        note(fmt!("Fetching package: git clone %s %s %?", url, local.to_str(), branch_args));
+
+        if run::process_output("git",
+                               ~[~"clone", url.clone(), local.to_str()] + branch_args).status != 0 {
+            note(fmt!("fetching %s failed: can't clone repository", url));
+            None
         }
         else {
-            None
+            Some(local)
         }
     }
 

branches/auto/src/librustpkg/path_util.rs

@@ -52,7 +52,6 @@ pub fn rust_path() -> ~[Path] {
         }
         None => ~[]
     };
-    debug!("RUST_PATH entries from environment: %?", env_rust_path);
     let cwd = os::getcwd();
     // now add in default entries
     env_rust_path.push(cwd.clone());
@@ -346,12 +345,7 @@ fn target_file_in_workspace(pkgid: &PkgId, workspace: &Path,
     let subdir = match what {
         Lib => "lib", Main | Test | Bench => "bin"
     };
-    // Artifacts in the build directory live in a package-ID-specific subdirectory,
-    // but installed ones don't.
-    let result = match where {
-                Build => workspace.push(subdir).push_rel(&*pkgid.local_path),
-                _     => workspace.push(subdir)
-    };
+    let result = workspace.push(subdir);
     if !os::path_exists(&result) && !mkdir_recursive(&result, U_RWX) {
         cond.raise((result.clone(), fmt!("target_file_in_workspace couldn't \
             create the %s dir (pkgid=%s, workspace=%s, what=%?, where=%?",

branches/auto/src/librustpkg/source_control.rs

@@ -18,14 +18,22 @@ pub fn git_clone(source: &Path, target: &Path, v: &Version) {
     assert!(os::path_is_dir(source));
     assert!(is_git_dir(source));
     if !os::path_exists(target) {
-        debug!("Running: git clone %s %s", source.to_str(),
+        let version_args = match v {
+            &ExactRevision(ref s) => ~[~"--branch", s.to_owned()],
+            _ => ~[]
+        };
+        debug!("Running: git clone %s %s %s", version_args.to_str(), source.to_str(),
                target.to_str());
-        assert!(git_clone_general(source.to_str(), target, v));
+        let outp = run::process_output("git", ~[~"clone"] + version_args +
+                                       ~[source.to_str(), target.to_str()]);
+        if outp.status != 0 {
+            io::println(str::from_bytes_owned(outp.output.clone()));
+            io::println(str::from_bytes_owned(outp.error));
+            fail!("Couldn't `git clone` %s", source.to_str());
+        }
     }
     else {
         // Pull changes
-        // Note that this ignores tags, which is probably wrong. There are no tests for
-        // it, though.
         debug!("Running: git --work-tree=%s --git-dir=%s pull --no-edit %s",
                target.to_str(), target.push(".git").to_str(), source.to_str());
         let outp = run::process_output("git", [fmt!("--work-tree=%s", target.to_str()),
@@ -35,34 +43,6 @@ pub fn git_clone(source: &Path, target: &Path, v: &Version) {
     }
 }
 
-/// Source can be either a URL or a local file path.
-/// true if successful
-pub fn git_clone_general(source: &str, target: &Path, v: &Version) -> bool {
-    let outp = run::process_output("git", [~"clone", source.to_str(), target.to_str()]);
-    if outp.status != 0 {
-         debug!(str::from_bytes_owned(outp.output.clone()));
-         debug!(str::from_bytes_owned(outp.error));
-         false
-    }
-    else {
-        match v {
-            &ExactRevision(ref s) | &Tagged(ref s) => {
-                    let outp = run::process_output_in_cwd("git", [~"checkout", fmt!("tags/%s", *s)],
-                                                         target);
-                    if outp.status != 0 {
-                        debug!(str::from_bytes_owned(outp.output.clone()));
-                        debug!(str::from_bytes_owned(outp.error));
-                        false
-                    }
-                    else {
-                        true
-                    }
-                }
-                _ => true
-            }
-        }
-}
-
 pub fn is_git_dir(p: &Path) -> bool {
     os::path_is_dir(&p.push(".git"))
 }

branches/auto/src/librustpkg/tests.rs

@@ -18,7 +18,7 @@ use std::run::ProcessOutput;
 use installed_packages::list_installed_packages;
 use package_path::*;
 use package_id::{PkgId};
-use version::{ExactRevision, NoVersion, Version, Tagged};
+use version::{ExactRevision, NoVersion, Version};
 use path_util::{target_executable_in_workspace, target_library_in_workspace,
                target_test_in_workspace, target_bench_in_workspace,
                make_dir_rwx, U_RWX, library_in_workspace,
@@ -61,16 +61,6 @@ fn git_repo_pkg() -> PkgId {
     }
 }
 
-fn git_repo_pkg_with_tag(a_tag: ~str) -> PkgId {
-    let remote = RemotePath(Path("mockgithub.com/catamorphism/test-pkg"));
-    PkgId {
-        local_path: normalize(remote.clone()),
-        remote_path: remote,
-        short_name: ~"test_pkg",
-        version: Tagged(a_tag)
-    }
-}
-
 fn writeFile(file_path: &Path, contents: &str) {
     let out: @io::Writer =
         result::unwrap(io::file_writer(file_path,
@@ -160,13 +150,9 @@ fn init_git_repo(p: &Path) -> Path {
     }
 }
 
-fn add_all_and_commit(repo: &Path) {
-    git_add_all(repo);
-    git_commit(repo, ~"floop");
-}
-
-fn git_commit(repo: &Path, msg: ~str) {
-    let mut prog = run::Process::new("git", [~"commit", ~"-m", msg],
+fn add_git_tag(repo: &Path, tag: ~str) {
+    assert!(repo.is_absolute());
+    let mut prog = run::Process::new("git", [~"add", ~"-A"],
                                      run::ProcessOptions { env: None,
                                                           dir: Some(repo),
                                                           in_fd: None,
@@ -175,14 +161,9 @@ fn git_commit(repo: &Path, msg: ~str) {
                                                          });
     let output = prog.finish_with_output();
     if output.status != 0 {
-        fail!("Couldn't commit in %s: output was %s", repo.to_str(),
-              str::from_bytes(output.output + output.error))
+        fail!("Couldn't add all files in %s", repo.to_str())
     }
-
-}
-
-fn git_add_all(repo: &Path) {
-    let mut prog = run::Process::new("git", [~"add", ~"-A"],
+    prog = run::Process::new("git", [~"commit", ~"-m", ~"whatever"],
                                      run::ProcessOptions { env: None,
                                                           dir: Some(repo),
                                                           in_fd: None,
@@ -191,16 +172,10 @@ fn git_add_all(repo: &Path) {
                                                          });
     let output = prog.finish_with_output();
     if output.status != 0 {
-        fail!("Couldn't add all files in %s: output was %s",
-              repo.to_str(), str::from_bytes(output.output + output.error))
+        fail!("Couldn't commit in %s", repo.to_str())
     }
-}
 
-fn add_git_tag(repo: &Path, tag: ~str) {
-    assert!(repo.is_absolute());
-    git_add_all(repo);
-    git_commit(repo, ~"whatever");
-    let mut prog = run::Process::new("git", [~"tag", tag.clone()],
+    prog = run::Process::new("git", [~"tag", tag.clone()],
                                      run::ProcessOptions { env: None,
                                                           dir: Some(repo),
                                                           in_fd: None,
@@ -649,6 +624,31 @@ fn test_package_request_version() {
     writeFile(&repo_subdir.push("version-0.4-file.txt"), "hello");
     add_git_tag(&repo_subdir, ~"0.4");
 
+/*
+
+    let pkg_src = PkgSrc::new(&repo, &repo, &temp_pkg_id);
+    match temp_pkg_id.version {
+        ExactRevision(~"0.3") => {
+            debug!("Version matches, calling fetch_git");
+            match pkg_src.fetch_git() {
+                Some(p) => {
+                    debug!("does version-0.3-file exist?");
+                    assert!(os::path_exists(&p.push("version-0.3-file.txt")));
+                    debug!("does version-0.4-file exist?");
+                    assert!(!os::path_exists(&p.push("version-0.4-file.txt")));
+
+                }
+                None => fail!("test_package_request_version: fetch_git failed")
+            }
+        }
+        ExactRevision(n) => {
+            fail!("n is %? and %? %s %?", n, n, if n == ~"0.3" { "==" } else { "!=" }, "0.3");
+        }
+        _ => fail!(fmt!("test_package_version: package version was %?, expected ExactRevision(0.3)",
+                        temp_pkg_id.version))
+    }
+*/
+
     command_line_test([~"install", fmt!("%s#0.3", local_path)], &repo);
 
     assert!(match installed_library_in_workspace("test_pkg_version", &repo.push(".rust")) {
@@ -681,7 +681,6 @@ fn rustpkg_install_url_2() {
 }
 
 // FIXME: #7956: temporarily disabled
-#[test]
 fn rustpkg_library_target() {
     let foo_repo = init_git_repo(&Path("foo"));
     let package_dir = foo_repo.push("foo");
@@ -708,10 +707,8 @@ fn rustpkg_local_pkg() {
     assert_executable_exists(&dir, "foo");
 }
 
-// FIXME: #7956: temporarily disabled
-//  Failing on dist-linux bot
 #[test]
-#[ignore]
+#[ignore] // XXX Failing on dist-linux bot
 fn package_script_with_default_build() {
     let dir = create_local_package(&PkgId::new("fancy-lib", &os::getcwd()));
     debug!("dir = %s", dir.to_str());
@@ -770,7 +767,7 @@ fn rustpkg_clean_no_arg() {
 }
 
 #[test]
-#[ignore (reason = "Specifying env doesn't work -- see #8028")]
+#[ignore (reason = "Un-ignore when #7071 is fixed")]
 fn rust_path_test() {
     let dir_for_path = mkdtemp(&os::tmpdir(), "more_rust").expect("rust_path_test failed");
     let dir = mk_workspace(&dir_for_path, &normalize(RemotePath(Path("foo"))), &NoVersion);
@@ -779,13 +776,9 @@ fn rust_path_test() {
 
     let cwd = os::getcwd();
     debug!("cwd = %s", cwd.to_str());
-    debug!("Running command: cd %s; RUST_LOG=rustpkg RUST_PATH=%s rustpkg install foo",
-           cwd.to_str(), dir_for_path.to_str());
     let mut prog = run::Process::new("rustpkg",
                                      [~"install", ~"foo"],
-                                     run::ProcessOptions { env: Some(&[(~"RUST_LOG",
-                                                                        ~"rustpkg"),
-                                                                       (~"RUST_PATH",
+                                     run::ProcessOptions { env: Some(&[(~"RUST_PATH",
                                                                        dir_for_path.to_str())]),
                                                           dir: Some(&cwd),
                                                           in_fd: None,
@@ -963,6 +956,7 @@ fn do_rebuild_dep_only_contents_change() {
 }
 
 #[test]
+#[ignore(reason = "list not yet implemented")]
 fn test_versions() {
     let workspace = create_local_package(&PkgId::new("foo#0.1", &os::getcwd()));
     create_local_package(&PkgId::new("foo#0.2", &os::getcwd()));
@@ -1000,35 +994,11 @@ fn test_rustpkg_test() {
 }
 
 #[test]
+#[ignore(reason = "uninstall not yet implemented")]
 fn test_uninstall() {
     let workspace = create_local_package(&PkgId::new("foo", &os::getcwd()));
     let _output = command_line_test([~"info", ~"foo"], &workspace);
     command_line_test([~"uninstall", ~"foo"], &workspace);
     let output = command_line_test([~"list"], &workspace);
     assert!(!str::from_bytes(output.output).contains("foo"));
 }
-
-#[test]
-fn test_non_numeric_tag() {
-    let temp_pkg_id = git_repo_pkg();
-    let repo = init_git_repo(&Path(temp_pkg_id.local_path.to_str()));
-    let repo_subdir = repo.push("mockgithub.com").push("catamorphism").push("test_pkg");
-    writeFile(&repo_subdir.push("foo"), "foo");
-    writeFile(&repo_subdir.push("lib.rs"),
-              "pub fn f() { let _x = (); }");
-    add_git_tag(&repo_subdir, ~"testbranch");
-    writeFile(&repo_subdir.push("testbranch_only"), "hello");
-    add_git_tag(&repo_subdir, ~"another_tag");
-    writeFile(&repo_subdir.push("not_on_testbranch_only"), "bye bye");
-    add_all_and_commit(&repo_subdir);
-
-
-    command_line_test([~"install", fmt!("%s#testbranch", temp_pkg_id.remote_path.to_str())],
-                      &repo);
-    let file1 = repo.push_many(["mockgithub.com", "catamorphism",
-                                "test_pkg", "testbranch_only"]);
-    let file2 = repo.push_many(["mockgithub.com", "catamorphism", "test_pkg",
-                                "master_only"]);
-    assert!(os::path_exists(&file1));'
-    assert!(!os::path_exists(&file2));
-}

branches/auto/src/librustpkg/usage.rs

@@ -63,17 +63,20 @@ List all installed packages.");
 }
 
 pub fn install() {
-    io::println("rustpkg [options..] install [package-ID]
+    io::println("rustpkg [options..] install [url] [target]
 
-Install the given package ID if specified. With no package ID
-argument, install the package in the current directory.
-In that case, the current directory must be a direct child of a
-`src` directory in a workspace.
+Install a package from a URL by Git or cURL (FTP, HTTP, etc.).
+If target is provided, Git will checkout the branch or tag before
+continuing. If the URL is a TAR file (with or without compression),
+extract it before installing. If a URL isn't provided, the package will
+be built and installed from the current directory (which is
+functionally the same as `rustpkg build` and installing the result).
 
 Examples:
     rustpkg install
-    rustpkg install github.com/mozilla/servo
-    rustpkg install github.com/mozilla/servo#0.1.2
+    rustpkg install git://github.com/mozilla/servo.git
+    rustpkg install git://github.com/mozilla/servo.git v0.1.2
+    rustpkg install http://rust-lang.org/servo-0.1.2.tar.gz
 
 Options:
     -c, --cfg      Pass a cfg flag to the package script");

branches/auto/src/librustpkg/version.rs

@@ -22,8 +22,6 @@ use extra::tempfile::mkdtemp;
 pub enum Version {
     ExactRevision(~str), // Should look like a m.n.(...).x
     SemanticVersion(semver::Version),
-    Tagged(~str), // String that can't be parsed as a version.
-                  // Requirements get interpreted exactly
     NoVersion // user didn't specify a version -- prints as 0.1
 }
 
@@ -78,7 +76,7 @@ impl Ord for Version {
 impl ToStr for Version {
     fn to_str(&self) -> ~str {
         match *self {
-            ExactRevision(ref n) | Tagged(ref n) => fmt!("%s", n.to_str()),
+            ExactRevision(ref n) => fmt!("%s", n.to_str()),
             SemanticVersion(ref v) => fmt!("%s", v.to_str()),
             NoVersion => ~"0.1"
         }