Update to rust master

Author: alexcrichton

Cargo.lock

@@ -75,7 +75,7 @@ pub trait RequestApp<'a> {
     fn app(self) -> &'a Arc<App>;
 }
 
-impl<'a> RequestApp<'a> for &'a Request + 'a {
+impl<'a> RequestApp<'a> for &'a (Request + 'a) {
     fn app(self) -> &'a Arc<App> {
         self.extensions().find::<Arc<App>>()
             .expect("Missing app")

src/app.rs

@@ -33,9 +33,9 @@ fn main() {
 
     let heroku = os::getenv("HEROKU").is_some();
     let cargo_env = if heroku {
-        cargo_registry::Production
+        cargo_registry::Env::Production
     } else {
-        cargo_registry::Development
+        cargo_registry::Env::Development
     };
     let config = cargo_registry::Config {
         s3_bucket: env("S3_BUCKET"),

src/bin/server.rs

@@ -80,7 +80,7 @@ impl Transaction {
         Ok(&**self.slot.borrow().unwrap())
     }
 
-    fn tx<'a>(&'a self) -> CargoResult<&'a Connection + 'a> {
+    fn tx<'a>(&'a self) -> CargoResult<&'a (Connection + 'a)> {
         // Similar to above, the transaction for this request is actually tied
         // to the connection in the request itself, not 'static. We transmute it
         // to static as its paired with the inner connection to achieve the
@@ -137,22 +137,22 @@ pub trait RequestTransaction<'a> {
     ///
     /// The transaction will live for the duration of the request, and it will
     /// only be set to commit() if a successful response code of 200 is seen.
-    fn tx(self) -> CargoResult<&'a Connection + 'a>;
+    fn tx(self) -> CargoResult<&'a (Connection + 'a)>;
 
     /// Flag the transaction to not be committed
     fn rollback(self);
     /// Flag this transaction to be committed
     fn commit(self);
 }
 
-impl<'a> RequestTransaction<'a> for &'a Request + 'a {
+impl<'a> RequestTransaction<'a> for &'a (Request + 'a) {
     fn db_conn(self) -> CargoResult<&'a pg::Connection> {
         self.extensions().find::<Transaction>()
             .expect("Transaction not present in request")
             .conn()
     }
 
-    fn tx(self) -> CargoResult<&'a Connection + 'a> {
+    fn tx(self) -> CargoResult<&'a (Connection + 'a)> {
         self.extensions().find::<Transaction>()
             .expect("Transaction not present in request")
             .tx()

src/db.rs

@@ -235,7 +235,7 @@ fn commit_and_push(repo: &git2::Repository,
         try!(origin.fetch(None, None));
         let head = try!(repo.head()).target().unwrap();
         let obj = try!(repo.find_object(head, None));
-        try!(repo.reset(&obj, git2::Hard, None, None));
+        try!(repo.reset(&obj, git2::ResetType::Hard, None, None));
     }
 
     Err(internal("Too many rebase failures"))

src/git.rs

@@ -78,7 +78,7 @@ impl Bucket {
                              headers = "",
                              resource = format!("/{}/{}", self.name, path));
         let signature = {
-            let mut hmac = hmac::HMAC(hash::SHA1, self.secret_key.as_bytes());
+            let mut hmac = hmac::HMAC(hash::HashType::SHA1, self.secret_key.as_bytes());
             hmac.update(string.as_bytes());
             hmac.finalize().as_slice().to_base64(STANDARD)
         };

src/s3/lib.rs

@@ -17,7 +17,7 @@ use std::io::Command;
 use std::io::process::InheritFd;
 use std::os;
 use std::sync::{Once, ONCE_INIT, Arc};
-use serialize::json;
+use serialize::json::{mod, Json};
 
 use conduit::Request;
 use conduit_test::MockRequest;
@@ -81,7 +81,7 @@ fn app() -> (record::Bomb, Arc<App>, conduit_middleware::MiddlewareBuilder) {
         gh_client_id: "".to_string(),
         gh_client_secret: "".to_string(),
         db_url: env("TEST_DATABASE_URL"),
-        env: cargo_registry::Test,
+        env: cargo_registry::Env::Test,
         max_upload_size: 1000,
     };
     unsafe { INIT.doit(|| db_setup(config.db_url.as_slice())); }
@@ -150,10 +150,10 @@ fn json<T>(r: &mut conduit::Response) -> T
     };
 
 
-    fn fixup(json: json::Json) -> json::Json {
+    fn fixup(json: Json) -> Json {
         match json {
-            json::Object(object) => {
-                json::Object(object.into_iter().map(|(k, v)| {
+            Json::Object(object) => {
+                Json::Object(object.into_iter().map(|(k, v)| {
                     let k = if k.as_slice() == "crate" {
                         "krate".to_string()
                     } else {
@@ -162,8 +162,8 @@ fn json<T>(r: &mut conduit::Response) -> T
                     (k, fixup(v))
                 }).collect())
             }
-            json::Array(list) => {
-                json::Array(list.into_iter().map(fixup).collect())
+            Json::Array(list) => {
+                Json::Array(list.into_iter().map(fixup).collect())
             }
             j => j,
         }

src/tests/all.rs

@@ -1,6 +1,6 @@
 use serialize::Decoder;
 
-use conduit::{mod, Handler, Request};
+use conduit::{Handler, Request, Method};
 use conduit_test::MockRequest;
 
 use cargo_registry::db::{RequestTransaction, Connection};
@@ -16,7 +16,7 @@ struct GoodKeyword { keyword: EncodableKeyword }
 #[test]
 fn index() {
     let (_b, app, middle) = ::app();
-    let mut req = ::req(app, conduit::Get, "/api/v1/keywords");
+    let mut req = ::req(app, Method::Get, "/api/v1/keywords");
     let mut response = ok_resp!(middle.call(&mut req));
     let json: KeywordList = ::json(&mut response);
     assert_eq!(json.keywords.len(), 0);
@@ -33,7 +33,7 @@ fn index() {
 #[test]
 fn show() {
     let (_b, app, middle) = ::app();
-    let mut req = ::req(app, conduit::Get, "/api/v1/keywords/foo");
+    let mut req = ::req(app, Method::Get, "/api/v1/keywords/foo");
     let response = t_resp!(middle.call(&mut req));
     assert_eq!(response.status.val0(), 404);
 
@@ -48,7 +48,7 @@ fn tx(req: &Request) -> &Connection { req.tx().unwrap() }
 #[test]
 fn update_crate() {
     let (_b, app, middle) = ::app();
-    let mut req = ::req(app, conduit::Get, "/api/v1/keywords/foo");
+    let mut req = ::req(app, Method::Get, "/api/v1/keywords/foo");
     let cnt = |req: &mut MockRequest, kw: &str| {
         req.with_path(format!("/api/v1/keywords/{}", kw).as_slice());
         let mut response = ok_resp!(middle.call(req));