Merge pull request chris-morgan#20 from mozilla-servo/rustup_20140515

Rust upgrade

Author: metajack

Makefile.in

@@ -1,12 +1,14 @@
 SSL_LIB ?= %SSL_LIB%
 SSL_CFG ?= %SSL_CFG%
 ifdef SSL_LIB
-	SSL_CFG += -L "$(SSL_LIB)"
+	SSL_CFG_AND_LIB=$(SSL_CFG) -L "$(SSL_LIB)"
+else
+	SSL_CFG_AND_LIB=$(SSL_CFG)
 endif
 RUSTC ?= rustc
 RUSTDOC ?= rustdoc
 RUSTPKG ?= rustpkg
-RUSTFLAGS ?= -O $(SSL_CFG)
+RUSTFLAGS ?= -O $(SSL_CFG_AND_LIB)
 RUST_REPOSITORY ?= ../rust
 RUST_CTAGS ?= $(RUST_REPOSITORY)/src/etc/ctags.rust
 VERSION=0.1-pre
@@ -85,7 +87,7 @@ clean:
 	rm -rf build/
 	rm -rf bin/ .rust/
 
-TAGS:
-	ctags -f TAGS --options=$(RUST_CTAGS) -R src
+TAGS: $(http_files)
+	ctags -f TAGS --options="$(RUST_CTAGS)" -R src/http
 
 .PHONY: all http examples docs clean check quickcheck

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<~str, ~str>``::
+effectively a ``Map<StrBuf, StrBuf>``::
 
    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 ``~str`` value, but a more suitable type implementing
+probably does not wish a ``StrBuf`` 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

@@ -1,33 +1,35 @@
 #![macro_escape]
 
 use std::str::Chars;
+use std::vec::Vec;
 use std::io::IoResult;
 
+#[deriving(Clone)]
 pub struct ParseBranch {
-    matches: ~[u8],
-    result: Option<~str>,
-    children: ~[ParseBranch],
+    matches: Vec<u8>,
+    result: Option<StrBuf>,
+    children: Vec<ParseBranch>,
 }
 
 impl ParseBranch {
     fn new() -> ParseBranch {
         ParseBranch {
-            matches: ~[],
+            matches: Vec::new(),
             result: None,
-            children: ~[],
+            children: Vec::new()
         }
     }
 }
 
-pub fn branchify(options: &[(&str, &str)], case_sensitive: bool) -> ~[ParseBranch] {
+pub fn branchify(options: &[(&str, &str)], case_sensitive: bool) -> Vec<ParseBranch> {
     let mut root = ParseBranch::new();
 
     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() };
                 for next_branch in branch.children.mut_iter() {
-                    if next_branch.matches[0] == first_case {
+                    if *next_branch.matches.get(0) == first_case {
                         go_down_moses(next_branch, chariter, result, case_sensitive);
                         return;
                     }
@@ -41,11 +43,12 @@ pub fn branchify(options: &[(&str, &str)], case_sensitive: bool) -> ~[ParseBranc
                     }
                 }
                 branch.children.push(subbranch);
-                go_down_moses(&mut branch.children[branch.children.len() - 1], chariter, result, case_sensitive);
+                let i = branch.children.len() - 1;
+                go_down_moses(branch.children.get_mut(i), chariter, result, case_sensitive);
             },
             None => {
                 assert!(branch.result.is_none());
-                branch.result = Some(result.to_owned());
+                branch.result = Some(StrBuf::from_str(result));
             },
         }
     };
@@ -62,7 +65,7 @@ macro_rules! branchify(
         ::branchify::branchify([$(($key, stringify!($value))),*], true)
     );
     (case insensitive, $($key:expr => $value:ident),*) => (
-        branchify([$(($key, stringify!($value))),*], false)
+        ::branchify::branchify([$(($key, stringify!($value))),*], false)
     );
 )
 
@@ -75,11 +78,11 @@ 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 ``~str`` (it is
+///         replaced with an expression (literal or non-literal) evaluating to a ``StrBuf`` (it is
 ///         ``{}`` only, not arbitrary format strings)
 pub fn generate_branchified_method(
         writer: &mut Writer,
-        branches: &[ParseBranch],
+        branches: Vec<ParseBranch>,
         indent: uint,
         read_call: &str,
         end: &str,
@@ -105,7 +108,7 @@ pub fn generate_branchified_method(
                 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!("~\"{}\"", next_prefix)))),
+                                  unknown.replace("{}", format!("StrBuf::from_str(\"{}\")", next_prefix)))),
             }
             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 }),");
@@ -130,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 = s.to_owned();"));
+    w!(       ("let mut s = StrBuf::from_str(s);"));
     w!(       ("s.push_char(next_byte as char);"));
     w!(       ("loop {"));
     w!(format!("    match {} \\{", read_call));

src/codegen/main.rs

@@ -37,11 +37,11 @@ fn main() {
     }
 }
 
-pub fn get_writer(output_dir: &Path, filename: &str) -> ~Writer {
+pub fn get_writer(output_dir: &Path, filename: &str) -> Box<Writer> {
     let mut output_file = output_dir.clone();
     output_file.push(filename);
     match File::open_mode(&output_file, Truncate, Write) {
-        Ok(writer) => ~writer as ~Writer,
+        Ok(writer) => box writer as Box<Writer>,
         Err(e) => fail!("Unable to write file: {}", e.desc),
     }
 }

src/codegen/status.rs

@@ -9,7 +9,6 @@
 
 use collections::hashmap::HashSet;
 use std::ascii::StrAsciiExt;
-use std::slice;
 use std::io::IoResult;
 use super::get_writer;
 
@@ -35,12 +34,14 @@ fn StatusN(code: uint, reason: &'static str) -> HeadingOrStatus {
 }
 
 impl Status {
-    fn ident(&self) -> ~str {
+    fn ident(&self) -> StrBuf {
         camel_case(self.reason)
     }
 
-    fn padded_ident(&self) -> ~str {
-        self.ident() + " ".repeat(unsafe { longest_ident } - self.ident().len())
+    fn padded_ident(&self) -> StrBuf {
+        let mut result = self.ident();
+        result.push_str(self.reason_padding_spaces());
+        result
     }
 
     fn reason_padding_spaces(&self) -> ~str {
@@ -50,22 +51,22 @@ impl Status {
 
 /// >>> camel_case("I'm a Tea-pot")
 /// "ImATeaPot"
-fn camel_case(msg: &str) -> ~str {
+fn camel_case(msg: &str) -> StrBuf {
     let msg = msg.replace("-", " ").replace("'", "");
-    let mut result: ~[Ascii] = slice::with_capacity(msg.len());
+    let mut result = StrBuf::with_capacity(msg.len());
     let mut capitalise = true;
     for c in msg.chars() {
         let c = match capitalise {
-            true => c.to_ascii().to_upper(),
-            false => c.to_ascii().to_lower(),
+            true => c.to_ascii().to_upper().to_char(),
+            false => c.to_ascii().to_lower().to_char(),
         };
         // For a space, capitalise the next char
-        capitalise = c.to_byte() == (' ' as u8);
+        capitalise = c == ' ';
         if !capitalise {  // And also, for a space, don't keep it
-            result.push(c);
+            result.push_char(c);
         }
     }
-    result.into_str()
+    result
 }
 
 static mut longest_ident: uint = 0;
@@ -177,7 +178,7 @@ pub enum Status {
     }
 
     try!(out.write("
-    UnregisteredStatus(u16, ~str),
+    UnregisteredStatus(u16, StrBuf),
 }
 
 impl Status {
@@ -199,13 +200,13 @@ impl Status {
     }
 
     /// Get the reason phrase
-    pub fn reason(&self) -> ~str {
+    pub fn reason(&self) -> StrBuf {
         match *self {
 ".as_bytes()));
     for &entry in entries.iter() {
         match entry {
             Heading(heading) => try!(write!(out, "\n            // {}\n", heading)),
-            Status(status) => try!(write!(out, "            {} => ~\"{}\",\n",
+            Status(status) => try!(write!(out, "            {} => StrBuf::from_str(\"{}\"),\n",
                                                 status.padded_ident(), status.reason))
         }
     }
@@ -215,8 +216,8 @@ impl Status {
     }
 
     /// Get a status from the code and reason
-    pub fn from_code_and_reason(status: u16, reason: ~str) -> Status {
-        let reason_lower = reason.to_ascii_lower();
+    pub fn from_code_and_reason(status: u16, reason: StrBuf) -> Status {
+        let reason_lower = reason.as_slice().to_ascii_lower();
         match (status, reason_lower.as_slice()) {
 ".as_bytes()));
     for &entry in entries.iter() {

src/examples/client/main.rs

@@ -21,7 +21,7 @@ fn main() {
     };
 }
 
-fn make_and_print_request(url: ~str) {
+fn make_and_print_request(url: &str) {
     let request: RequestWriter = RequestWriter::new(Get, from_str(url).expect("Invalid URL :-("))
                                               .unwrap();
 

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(~"Apache/2.2.22 (Ubuntu)");
-        //w.headers.last_modified = Some(~"Thu, 05 May 2011 11:46:42 GMT");
+        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.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,22 @@ 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", // timezone abbreviation
+            tm_zone: "GMT".to_owned(), // timezone abbreviation
             tm_nsec: 0, // nanoseconds
         });
         w.headers.etag = Some(headers::etag::EntityTag {
                                 weak: false,
-                                opaque_tag: ~"501b29-b1-4a285ed47404a" });
+                                opaque_tag: StrBuf::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(~"Accept-Encoding");
+        w.headers.vary = Some(StrBuf::from_str("Accept-Encoding"));
         w.headers.content_type = Some(headers::content_type::MediaType {
-            type_: ~"text",
-            subtype: ~"html",
+            type_: StrBuf::from_str("text"),
+            subtype: StrBuf::from_str("html"),
             parameters: Vec::new()
         });
-        w.headers.extensions.insert(~"X-Pad", ~"avoid browser bug");
+        w.headers.extensions.insert(StrBuf::from_str("X-Pad"), StrBuf::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_: ~"text",
-            subtype: ~"plain",
-            parameters: vec!((~"charset", ~"UTF-8"))
+            type_: StrBuf::from_str("text"),
+            subtype: StrBuf::from_str("plain"),
+            parameters: vec!((StrBuf::from_str("charset"), StrBuf::from_str("UTF-8")))
         });
-        w.headers.server = Some(~"Example");
+        w.headers.server = Some(StrBuf::from_str("Example"));
 
         w.write(bytes!("Hello, World!\n")).unwrap();
     }

src/examples/server/info/main.rs

@@ -24,11 +24,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_: ~"text",
-            subtype: ~"html",
-            parameters: vec!((~"charset", ~"UTF-8"))
+            type_: StrBuf::from_str("text"),
+            subtype: StrBuf::from_str("html"),
+            parameters: vec!((StrBuf::from_str("charset"), StrBuf::from_str("UTF-8")))
         });
-        w.headers.server = Some(~"Rust Thingummy/0.0-pre");
+        w.headers.server = Some(StrBuf::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(~"Rust Thingummy/0.1-pre");
+        w.headers.server = Some(StrBuf::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_: ~"text",
-            subtype: ~"html",
+            type_: StrBuf::from_str("text"),
+            subtype: StrBuf::from_str("html"),
             parameters: Vec::new()
         });
 
@@ -72,11 +72,11 @@ impl Server for RequestUriServer {
                 // Actually, valid for the CONNECT method.
             },
             AbsoluteUri(ref url) => {
-                println!("absoluteURI, {}", url.to_str());
+                println!("absoluteURI, {}", url);
                 //path =
             },
             AbsolutePath(ref url) => {
-                println!("absolute path, {}", url.to_owned());
+                println!("absolute path, {}", url);
                 //w.status = a
             },
         }