rustpkg: Fail when crate inference fails; inject link attributes

1. Fail when there's no package script and no crates named
main.rs, lib.rs, bench.rs, or test.rs.

2. Inject the crate link_meta "name" and "vers" attributes, so
that the output file gets named correctly in the library case.

3. Normalize '-' to '_' in package names.

Author: catamorphism

src/librustpkg/path_util.rs

@@ -11,7 +11,8 @@
 // rustpkg utilities having to do with paths and directories
 
 use core::path::*;
-use core::os;
+use core::{os, str};
+use core::option::*;
 use util::PkgId;
 
 /// Returns the output directory to use.
@@ -50,6 +51,24 @@ pub fn default_dest_dir(pkg_dir: &Path) -> Path {
     }
 }
 
+/// Replace all occurrences of '-' in the stem part of path with '_'
+/// This is because we treat rust-foo-bar-quux and rust_foo_bar_quux
+/// as the same name
+pub fn normalize(p: ~Path) -> ~Path {
+    match p.filestem() {
+        None => p,
+        Some(st) => {
+            let replaced = str::replace(st, "-", "_");
+            if replaced != st {
+                ~p.with_filestem(replaced)
+            }
+            else {
+                p
+            }
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
     use core::{os, rand};

src/librustpkg/rustpkg.rc

@@ -36,8 +36,9 @@ use rustc::metadata::filesearch;
 use std::net::url;
 use std::{getopts};
 use syntax::{ast, diagnostic};
-use util::{ExitCode, Pkg, PkgId};
-use path_util::dest_dir;
+use util::*;
+use path_util::{dest_dir, normalize};
+use rustc::driver::session::{lib_crate, bin_crate, unknown_crate, crate_type};
 
 mod conditions;
 mod usage;
@@ -117,9 +118,12 @@ impl PkgScript {
             Ok(r) => {
                 let root = r.pop().pop().pop().pop(); // :-\
                 debug!("Root is %s, calling compile_rest", root.to_str());
-                util::compile_crate_from_input(self.input, Some(self.build_dir),
-                                               sess, Some(crate), os::args()[0]);
                 let exe = self.build_dir.push(~"pkg" + util::exe_suffix());
+                util::compile_crate_from_input(self.input, self.id,
+                                               Some(self.build_dir),
+                                               sess, Some(crate),
+                                               exe, os::args()[0],
+                                               driver::cu_everything);
                 debug!("Running program: %s %s %s", exe.to_str(), root.to_str(), what);
                 let status = run::run_program(exe.to_str(), ~[root.to_str(), what]);
                 if status != 0 {
@@ -199,15 +203,15 @@ impl Ctx {
                 // relative to the CWD. In the future, we should search
                 // paths
                 let cwd = os::getcwd().normalize();
-                debug!("Current working directory = %?", cwd);
+                debug!("Current working directory = %s", cwd.to_str());
 
-                // Find crates inside the workspace
+                // Create the package source
                 let mut src = PkgSrc::new(&cwd, &dst_dir, &pkgid);
                 debug!("Package src = %?", src);
-                src.find_crates();
 
                 // Is there custom build logic? If so, use it
                 let pkg_src_dir = cwd.push_rel(&pkgid.path);
+                let mut custom = false;;
                 debug!("Package source directory = %s", pkg_src_dir.to_str());
                 let cfgs = match src.package_script_option(&pkg_src_dir) {
                     Some(package_script_path) => {
@@ -221,6 +225,7 @@ impl Ctx {
                         if hook_result != 0 {
                             fail!(fmt!("Error running custom build command"))
                         }
+                        custom = true;
                         // otherwise, the package script succeeded
                         cfgs
                     }
@@ -229,6 +234,13 @@ impl Ctx {
                         ~[]
                     }
                 };
+
+                // Find crates inside the workspace
+                if !custom {
+                    src.find_crates();
+                }
+
+                // Build it!
                 src.build(&dst_dir, cfgs);
             }
             ~"clean" => {
@@ -728,7 +740,6 @@ condition! {
 
 impl PkgSrc {
 
-
     fn new(src_dir: &Path, dst_dir: &Path,
                   id: &PkgId) -> PkgSrc {
         PkgSrc {
@@ -765,12 +776,6 @@ impl PkgSrc {
         dir
     }
 
-
-    fn has_pkg_file(&self) -> bool {
-        let dir = self.check_dir();
-        dir.push("pkg.rs").exists()
-    }
-
     // If a file named "pkg.rs" in the current directory exists,
     // return the path for it. Otherwise, None
     fn package_script_option(&self, cwd: &Path) -> Option<Path> {
@@ -786,14 +791,16 @@ impl PkgSrc {
     /// True if the given path's stem is self's pkg ID's stem
     /// or if the pkg ID's stem is <rust-foo> and the given path's
     /// stem is foo
+    /// Requires that dashes in p have already been normalized to
+    /// underscores
     fn stem_matches(&self, p: &Path) -> bool {
-        let self_id = self.id.path.filestem();
+        let self_id = normalize(~self.id.path).filestem();
         if self_id == p.filestem() {
             return true;
         }
         else {
             for self_id.each |pth| {
-                if pth.starts_with("rust-")
+                if pth.starts_with("rust_") // because p is already normalized
                     && match p.filestem() {
                            Some(s) => str::eq_slice(s, pth.slice(5, pth.len())),
                            None => false
@@ -814,17 +821,14 @@ impl PkgSrc {
         cs.push(Crate::new(&sub));
     }
 
+    /// Infers crates to build. Called only in the case where there
+    /// is no custom build logic
     fn find_crates(&mut self) {
         use PkgSrc::push_crate;
 
         let dir = self.check_dir();
         let prefix = dir.components.len();
-        // This is ugly, but can go away once we get rid
-        // of .rc files
-        let mut saw_rs = false;
-        let mut saw_rc = false;
-        debug!("Matching against %?",
-               self.id.path.filestem());
+        debug!("Matching against %?", self.id.path.filestem());
         for os::walk_dir(&dir) |pth| {
             match pth.filename() {
                 Some(~"lib.rs") => push_crate(&mut self.libs,
@@ -836,30 +840,10 @@ impl PkgSrc {
                 Some(~"bench.rs") => push_crate(&mut self.benchs,
                                                 prefix, pth),
                 _ => {
-                    // If the file stem is the same as the
-                    // package ID, with an .rs or .rc extension,
-                    // consider it to be a crate
-                    let ext = pth.filetype();
-                    let matches = |p: &Path| {
-                        self.stem_matches(p) && (ext == Some(~".rc")
-                                                  || ext == Some(~".rs"))
-                    };
-                    debug!("Checking %? which %s and ext = %? %? %?", pth.filestem(),
-                           if matches(pth) { "matches" } else { "does not match" },
-                           ext, saw_rs, saw_rc);
-                    if matches(pth) &&
-                        // Avoid pushing foo.rc *and* foo.rs
-                         !((ext == Some(~".rc") && saw_rs) ||
-                           (ext == Some(~".rs") && saw_rc)) {
-                        push_crate(&mut self.libs, // ????
-                                   prefix, pth);
-                        if ext == Some(~".rc") {
-                            saw_rc = true;
-                        }
-                        else if ext == Some(~".rs") {
-                            saw_rs = true;
-                        }
-                    }
+                    util::note(~"Couldn't infer any crates to build.\n\
+                                Try naming a crate `main.rs`, `lib.rs`, \
+                                `test.rs`, or `bench.rs`.");
+                    fail!(~"Failed to infer crates to build");
                 }
             }
         }
@@ -870,22 +854,22 @@ impl PkgSrc {
                self.benchs.len())
     }
 
-    fn build_crates(dst_dir: &Path,
+    fn build_crates(&self, dst_dir: &Path,
                            src_dir: &Path,
                            crates: &[Crate],
                            cfgs: ~[~str],
-                           test: bool) {
+                           test: bool, crate_type: crate_type) {
 
         for crates.each |&crate| {
             let path = &src_dir.push_rel(&crate.file).normalize();
             util::note(fmt!("build_crates: compiling %s", path.to_str()));
             util::note(fmt!("build_crates: destination dir is %s", dst_dir.to_str()));
 
-            let result = util::compile_crate(None, path,
+            let result = util::compile_crate(None, self.id, path,
                                      dst_dir,
                                      crate.flags,
                                      crate.cfgs + cfgs,
-                                     false, test);
+                                     false, test, crate_type);
             if !result {
                 build_err::cond.raise(fmt!("build failure on %s",
                                            path.to_str()));
@@ -898,12 +882,12 @@ impl PkgSrc {
     fn build(&self, dst_dir: &Path, cfgs: ~[~str]) {
         let dir = self.check_dir();
         debug!("Building libs");
-        PkgSrc::build_crates(dst_dir, &dir, self.libs, cfgs, false);
+        self.build_crates(dst_dir, &dir, self.libs, cfgs, false, lib_crate);
         debug!("Building mains");
-        PkgSrc::build_crates(dst_dir, &dir, self.mains, cfgs, false);
+        self.build_crates(dst_dir, &dir, self.mains, cfgs, false, bin_crate);
         debug!("Building tests");
-        PkgSrc::build_crates(dst_dir, &dir, self.tests, cfgs, true);
+        self.build_crates(dst_dir, &dir, self.tests, cfgs, true, bin_crate);
         debug!("Building benches");
-        PkgSrc::build_crates(dst_dir, &dir, self.benchs, cfgs, true);
+        self.build_crates(dst_dir, &dir, self.benchs, cfgs, true, bin_crate);
     }
 }