Merge pull request chris-morgan#21 from mozilla-servo/rustup-20140528

Upgrade Rust

Author: SimonSapin

.travis.yml

@@ -2,10 +2,10 @@ env:
   global:
     - secure: SkhFtAUkRRrDYHr6z6YhWtGouw6jsys7dBKLojA+M3M68EM9U1VG9oNHMasCdFUt0a+TdPte9JccufbhvZABnlo7+yU6hQ94jhsyQ9qSL5y7V+2eyWBkQZDqyFt3jgLyrrSV2Nkk22xI4UAm2iGRKel6lXWi7i0i9hDT+3W0dK4=
 before_install:
-  - yes | sudo add-apt-repository ppa:hansjorg/rust
-  - sudo apt-get update
+  - wget http://static.rust-lang.org/dist/rust-nightly-x86_64-unknown-linux-gnu.tar.gz
+  - tar xf rust-nightly-x86_64-unknown-linux-gnu.tar.gz
 install:
-  - sudo apt-get install rust-nightly
+  - sudo ./rust-nightly-x86_64-unknown-linux-gnu/install.sh
   - git clone https://github.com/sfackler/rust-openssl.git
   - cd rust-openssl
   - ./configure

README.rst

@@ -158,7 +158,7 @@ In Rust, there is no base of code already following such a convention and so we
 are not tethered by this requirement. My own feeling on such matters is that
 for the static typing world having such things is not beneficial, anyway. Most
 web systems would have something along these lines, working with what is
-effectively a ``Map<StrBuf, StrBuf>``::
+effectively a ``Map<String, String>``::
 
    response.headers["Date"] = format_http_time(now_utc())
 
@@ -170,7 +170,7 @@ thus?
    response.headers.date = now_utc()
 
 To be certain, there may be need for unknown headers; yet even there one
-probably does not wish a ``StrBuf`` value, but a more suitable type implementing
+probably does not wish a ``String`` value, but a more suitable type implementing
 a trait to convert to and from an appropriate string.
 
 Note that with these examples the precise form is not determined.

src/codegen/branchify.rs

@@ -7,7 +7,7 @@ use std::io::IoResult;
 #[deriving(Clone)]
 pub struct ParseBranch {
     matches: Vec<u8>,
-    result: Option<StrBuf>,
+    result: Option<String>,
     children: Vec<ParseBranch>,
 }
 
@@ -27,7 +27,7 @@ pub fn branchify(options: &[(&str, &str)], case_sensitive: bool) -> Vec<ParseBra
     fn go_down_moses(branch: &mut ParseBranch, mut chariter: Chars, result: &str, case_sensitive: bool) {
         match chariter.next() {
             Some(c) => {
-                let first_case = if case_sensitive { c as u8 } else { c.to_ascii().to_upper().to_byte() };
+                let first_case = if case_sensitive { c as u8 } else { c.to_ascii().to_uppercase().to_byte() };
                 for next_branch in branch.children.mut_iter() {
                     if *next_branch.matches.get(0) == first_case {
                         go_down_moses(next_branch, chariter, result, case_sensitive);
@@ -37,7 +37,7 @@ pub fn branchify(options: &[(&str, &str)], case_sensitive: bool) -> Vec<ParseBra
                 let mut subbranch = ParseBranch::new();
                 subbranch.matches.push(first_case);
                 if !case_sensitive {
-                    let second_case = c.to_ascii().to_lower().to_byte();
+                    let second_case = c.to_ascii().to_lowercase().to_byte();
                     if first_case != second_case {
                         subbranch.matches.push(second_case);
                     }
@@ -48,7 +48,7 @@ pub fn branchify(options: &[(&str, &str)], case_sensitive: bool) -> Vec<ParseBra
             },
             None => {
                 assert!(branch.result.is_none());
-                branch.result = Some(StrBuf::from_str(result));
+                branch.result = Some(String::from_str(result));
             },
         }
     };
@@ -78,7 +78,7 @@ macro_rules! branchify(
 /// :param max_len: the maximum length a value may be before giving up and returning ``None``
 /// :param valid: the function call to if a byte ``b`` is valid
 /// :param unknown: the expression to call for an unknown value; in this string, ``{}`` will be
-///         replaced with an expression (literal or non-literal) evaluating to a ``StrBuf`` (it is
+///         replaced with an expression (literal or non-literal) evaluating to a ``String`` (it is
 ///         ``{}`` only, not arbitrary format strings)
 pub fn generate_branchified_method(
         writer: &mut Writer,
@@ -102,13 +102,13 @@ pub fn generate_branchified_method(
             let next_prefix = format!("{}{}", prefix, c as char);
             w!(format!("Ok(b) if b == '{}' as u8 => match {} \\{", c as char, read_call));
             for b in branch.children.iter() {
-                try!(r(writer, b, next_prefix, indent + 1, read_call, end, max_len, valid, unknown));
+                try!(r(writer, b, next_prefix.as_slice(), indent + 1, read_call, end, max_len, valid, unknown));
             }
             match branch.result {
                 Some(ref result) =>
                     w!(format!("    Ok(b) if b == SP => return Ok({}),", *result)),
                 None => w!(format!("    Ok(b) if b == SP => return Ok({}),",
-                                  unknown.replace("{}", format!("StrBuf::from_str(\"{}\")", next_prefix)))),
+                                  unknown.replace("{}", format!("String::from_str(\"{}\")", next_prefix).as_slice()))),
             }
             w!(format!("    Ok(b) if {} => (\"{}\", b),", valid, next_prefix));
             w!("    Ok(_) => return Err(::std::io::IoError { kind: ::std::io::OtherIoError, desc: \"bad value\", detail: None }),");
@@ -133,7 +133,7 @@ pub fn generate_branchified_method(
     w!(       ("    Err(err) => return Err(err),"));
     w!(       ("};"));
     w!(       ("// OK, that didn't pan out. Let's read the rest and see what we get."));
-    w!(       ("let mut s = StrBuf::from_str(s);"));
+    w!(       ("let mut s = String::from_str(s);"));
     w!(       ("s.push_char(next_byte as char);"));
     w!(       ("loop {"));
     w!(format!("    match {} \\{", read_call));

src/codegen/main.rs

@@ -19,9 +19,9 @@ fn main() {
             os::set_exit_status(1);
         },
         3 => {
-            let output_dir = Path::new(args[2].as_slice());
+            let output_dir = Path::new(args.get(2).as_slice());
 
-            match args[1].as_slice() {
+            match args.get(1).as_slice() {
                 "read_method.rs" => read_method::generate(&output_dir).unwrap(),
                 "status.rs" => status::generate(&output_dir).unwrap(),
                 s => {
@@ -31,7 +31,7 @@ fn main() {
             }
         },
         _ => {
-            println!("usage: {} [read_method|status].rs <output-dir>", args[0]);
+            println!("usage: {} [read_method|status].rs <output-dir>", args.get(0));
             os::set_exit_status(1);
         }
     }

src/codegen/status.rs

@@ -34,31 +34,29 @@ fn StatusN(code: uint, reason: &'static str) -> HeadingOrStatus {
 }
 
 impl Status {
-    fn ident(&self) -> StrBuf {
+    fn ident(&self) -> String {
         camel_case(self.reason)
     }
 
-    fn padded_ident(&self) -> StrBuf {
-        let mut result = self.ident();
-        result.push_str(self.reason_padding_spaces());
-        result
+    fn padded_ident(&self) -> String {
+        self.ident().append(self.reason_padding_spaces().as_slice())
     }
 
-    fn reason_padding_spaces(&self) -> ~str {
+    fn reason_padding_spaces(&self) -> String {
         " ".repeat(unsafe { longest_reason } - self.reason.len())
     }
 }
 
 /// >>> camel_case("I'm a Tea-pot")
 /// "ImATeaPot"
-fn camel_case(msg: &str) -> StrBuf {
+fn camel_case(msg: &str) -> String {
     let msg = msg.replace("-", " ").replace("'", "");
-    let mut result = StrBuf::with_capacity(msg.len());
+    let mut result = String::with_capacity(msg.len());
     let mut capitalise = true;
-    for c in msg.chars() {
+    for c in msg.as_slice().chars() {
         let c = match capitalise {
-            true => c.to_ascii().to_upper().to_char(),
-            false => c.to_ascii().to_lower().to_char(),
+            true => c.to_ascii().to_uppercase().to_char(),
+            false => c.to_ascii().to_lowercase().to_char(),
         };
         // For a space, capitalise the next char
         capitalise = c == ' ';
@@ -178,7 +176,7 @@ pub enum Status {
     }
 
     try!(out.write("
-    UnregisteredStatus(u16, StrBuf),
+    UnregisteredStatus(u16, String),
 }
 
 impl Status {
@@ -200,13 +198,13 @@ impl Status {
     }
 
     /// Get the reason phrase
-    pub fn reason(&self) -> StrBuf {
+    pub fn reason(&self) -> String {
         match *self {
 ".as_bytes()));
     for &entry in entries.iter() {
         match entry {
             Heading(heading) => try!(write!(out, "\n            // {}\n", heading)),
-            Status(status) => try!(write!(out, "            {} => StrBuf::from_str(\"{}\"),\n",
+            Status(status) => try!(write!(out, "            {} => String::from_str(\"{}\"),\n",
                                                 status.padded_ident(), status.reason))
         }
     }
@@ -216,7 +214,7 @@ impl Status {
     }
 
     /// Get a status from the code and reason
-    pub fn from_code_and_reason(status: u16, reason: StrBuf) -> Status {
+    pub fn from_code_and_reason(status: u16, reason: String) -> Status {
         let reason_lower = reason.as_slice().to_ascii_lower();
         match (status, reason_lower.as_slice()) {
 ".as_bytes()));
@@ -238,7 +236,7 @@ impl Status {
 
 impl fmt::Show for Status {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f.buf, \"{} {}\", self.code(), self.reason())
+        write!(f, \"{} {}\", self.code(), self.reason())
     }
 }
 

src/examples/client/main.rs

@@ -1,5 +1,6 @@
 #![crate_id = "client"]
 
+extern crate debug;
 extern crate http;
 use http::client::RequestWriter;
 use http::method::Get;
@@ -13,9 +14,9 @@ fn main() {
     let args = os::args();
     match args.len() {
         0 => unreachable!(),
-        2 => make_and_print_request(args[1]),
+        2 => make_and_print_request(args.get(1).as_slice()),
         _ => {
-            println!("Usage: {} URL", args[0]);
+            println!("Usage: {} URL", args.get(0));
             return;
         },
     };

src/examples/server/apache_fake/main.rs

@@ -23,8 +23,8 @@ impl Server for ApacheFakeServer {
 
     fn handle_request(&self, _r: &Request, w: &mut ResponseWriter) {
         w.headers.date = Some(time::now_utc());
-        w.headers.server = Some(StrBuf::from_str("Apache/2.2.22 (Ubuntu)"));
-        //w.headers.last_modified = Some(StrBuf::from_str("Thu, 05 May 2011 11:46:42 GMT"));
+        w.headers.server = Some(String::from_str("Apache/2.2.22 (Ubuntu)"));
+        //w.headers.last_modified = Some(String::from_str("Thu, 05 May 2011 11:46:42 GMT"));
         w.headers.last_modified = Some(time::Tm {
             tm_sec: 42, // seconds after the minute ~[0-60]
             tm_min: 46, // minutes after the hour ~[0-59]
@@ -36,22 +36,21 @@ impl Server for ApacheFakeServer {
             tm_yday: 0, // days since January 1 ~[0-365]
             tm_isdst: 0, // Daylight Savings Time flag
             tm_gmtoff: 0, // offset from UTC in seconds
-            tm_zone: "GMT".to_owned(), // timezone abbreviation
             tm_nsec: 0, // nanoseconds
         });
         w.headers.etag = Some(headers::etag::EntityTag {
                                 weak: false,
-                                opaque_tag: StrBuf::from_str("501b29-b1-4a285ed47404a") });
+                                opaque_tag: String::from_str("501b29-b1-4a285ed47404a") });
         w.headers.accept_ranges = Some(headers::accept_ranges::RangeUnits(
                                             vec!(headers::accept_ranges::Bytes)));
         w.headers.content_length = Some(177);
-        w.headers.vary = Some(StrBuf::from_str("Accept-Encoding"));
+        w.headers.vary = Some(String::from_str("Accept-Encoding"));
         w.headers.content_type = Some(headers::content_type::MediaType {
-            type_: StrBuf::from_str("text"),
-            subtype: StrBuf::from_str("html"),
+            type_: String::from_str("text"),
+            subtype: String::from_str("html"),
             parameters: Vec::new()
         });
-        w.headers.extensions.insert(StrBuf::from_str("X-Pad"), StrBuf::from_str("avoid browser bug"));
+        w.headers.extensions.insert(String::from_str("X-Pad"), String::from_str("avoid browser bug"));
 
         w.write(bytes!("\
             <html><body><h1>It works!</h1>\n\

src/examples/server/hello_world/main.rs

@@ -23,11 +23,11 @@ impl Server for HelloWorldServer {
         w.headers.date = Some(time::now_utc());
         w.headers.content_length = Some(14);
         w.headers.content_type = Some(MediaType {
-            type_: StrBuf::from_str("text"),
-            subtype: StrBuf::from_str("plain"),
-            parameters: vec!((StrBuf::from_str("charset"), StrBuf::from_str("UTF-8")))
+            type_: String::from_str("text"),
+            subtype: String::from_str("plain"),
+            parameters: vec!((String::from_str("charset"), String::from_str("UTF-8")))
         });
-        w.headers.server = Some(StrBuf::from_str("Example"));
+        w.headers.server = Some(String::from_str("Example"));
 
         w.write(bytes!("Hello, World!\n")).unwrap();
     }

src/examples/server/info/main.rs

@@ -4,6 +4,7 @@
 #![crate_id = "info"]
 
 extern crate time;
+extern crate debug;
 extern crate http;
 
 use std::io::net::ip::{SocketAddr, Ipv4Addr};
@@ -24,11 +25,11 @@ impl Server for InfoServer {
     fn handle_request(&self, r: &Request, w: &mut ResponseWriter) {
         w.headers.date = Some(time::now_utc());
         w.headers.content_type = Some(MediaType {
-            type_: StrBuf::from_str("text"),
-            subtype: StrBuf::from_str("html"),
-            parameters: vec!((StrBuf::from_str("charset"), StrBuf::from_str("UTF-8")))
+            type_: String::from_str("text"),
+            subtype: String::from_str("html"),
+            parameters: vec!((String::from_str("charset"), String::from_str("UTF-8")))
         });
-        w.headers.server = Some(StrBuf::from_str("Rust Thingummy/0.0-pre"));
+        w.headers.server = Some(String::from_str("Rust Thingummy/0.0-pre"));
         w.write(bytes!("<!DOCTYPE html><title>Rust HTTP server</title>")).unwrap();
 
         w.write(bytes!("<h1>Request</h1>")).unwrap();

src/examples/server/request_uri/main.rs

@@ -28,7 +28,7 @@ impl Server for RequestUriServer {
 
     fn handle_request(&self, r: &Request, w: &mut ResponseWriter) {
         w.headers.date = Some(time::now_utc());
-        w.headers.server = Some(StrBuf::from_str("Rust Thingummy/0.1-pre"));
+        w.headers.server = Some(String::from_str("Rust Thingummy/0.1-pre"));
 
         match (&r.method, &r.request_uri) {
             (&Connect, _) => {
@@ -59,8 +59,8 @@ impl Server for RequestUriServer {
         }
 
         w.headers.content_type = Some(MediaType {
-            type_: StrBuf::from_str("text"),
-            subtype: StrBuf::from_str("html"),
+            type_: String::from_str("text"),
+            subtype: String::from_str("html"),
             parameters: Vec::new()
         });
 

src/http/client/request.rs

@@ -108,21 +108,21 @@ impl<S: Reader + Writer = super::NetworkStream> RequestWriter<S> {
     pub fn new_request(method: Method, url: Url, use_ssl: bool, auto_detect_ssl: bool) -> IoResult<RequestWriter<S>> {
         let host = match url.port {
             None => Host {
-                name: StrBuf::from_str(url.host),
+                name: url.host.clone(),
                 port: None,
             },
             Some(ref p) => Host {
-                name: StrBuf::from_str(url.host),
-                port: Some(from_str(*p).expect("You didn’t aught to give a bad port!")),
+                name: url.host.clone(),
+                port: Some(from_str(p.as_slice()).expect("You didn’t aught to give a bad port!")),
             },
         };
 
         let remote_addr = try!(url_to_socket_addr(&url));
-        info!("using ip address {} for {}", remote_addr.to_str(), url.host);
+        info!("using ip address {} for {}", remote_addr.to_str(), url.host.as_slice());
 
         fn url_to_socket_addr(url: &Url) -> IoResult<SocketAddr> {
             // Just grab the first IPv4 address
-            let addrs = try!(get_host_addresses(url.host));
+            let addrs = try!(get_host_addresses(url.host.as_slice()));
             let addr = addrs.move_iter().find(|&a| {
                 match a {
                     Ipv4Addr(..) => true,
@@ -135,7 +135,7 @@ impl<S: Reader + Writer = super::NetworkStream> RequestWriter<S> {
 
             // Default to 80, using the port specified or 443 if the protocol is HTTPS.
             let port = match url.port {
-                Some(ref p) => from_str(*p).expect("You didn’t aught to give a bad port!"),
+                Some(ref p) => from_str(p.as_slice()).expect("You didn’t aught to give a bad port!"),
                 // FIXME: case insensitivity?
                 None => if url.scheme.as_slice() == "https" { 443 } else { 80 },
             };
@@ -186,7 +186,7 @@ impl<S: Connecter + Reader + Writer = super::NetworkStream> RequestWriter<S> {
 
         self.stream = match self.remote_addr {
             Some(addr) => {
-                let stream = try!(Connecter::connect(addr, self.url.host, self.use_ssl));
+                let stream = try!(Connecter::connect(addr, self.url.host.as_slice(), self.use_ssl));
                 Some(BufferedStream::new(stream))
             },
             None => fail!("connect() called before remote_addr was set"),

src/http/client/response.rs

@@ -1,5 +1,4 @@
 use std::io::{Stream, IoResult, OtherIoError, IoError};
-use std::strbuf::StrBuf;
 use client::request::RequestWriter;
 use rfc2616::{CR, LF, SP};
 use common::read_http_version;
@@ -66,7 +65,7 @@ impl<S: Stream> ResponseReader<S> {
         }
 
         // Read the status reason
-        let mut reason = StrBuf::new();
+        let mut reason = String::new();
         loop {
             match stream.read_byte() {
                 Ok(b) if b == CR => {

src/http/client/sslclients/none.rs

@@ -24,7 +24,7 @@ impl Connecter for NetworkStream {
                 detail: None,
             })
         } else {
-            let stream = try!(TcpStream::connect(addr));
+            let stream = try!(TcpStream::connect(addr.ip.to_str().as_slice(), addr.port));
             Ok(NormalStream(stream))
         }
     }