Merge pull request #30 from alexcrichton/update

Update to rust master

src/form_urlencoded.rs

@@ -84,7 +84,7 @@ pub fn parse_bytes(input: &[u8], encoding_override: Option<EncodingRef>,
             encoding::DecodeReplace).unwrap()
     }
 
-    Some(pairs.move_iter().map(
+    Some(pairs.into_iter().map(
         |(name, value)| (decode(name, encoding_override), decode(value, encoding_override))
     ).collect())
 }

src/lib.rs

@@ -195,7 +195,7 @@ pub struct Url {
 #[deriving(PartialEq, Eq, Clone)]
 pub enum SchemeData {
     /// Components for URLs in a *relative* scheme such as HTTP.
-    RelativeSchemeData(RelativeSchemeData),
+    RelativeSchemeData(UrlRelativeSchemeData),
 
     /// No further structure is assumed for *non-relative* schemes such as `data` and `mailto`.
     ///
@@ -207,7 +207,7 @@ pub enum SchemeData {
 
 /// Components for URLs in a *relative* scheme such as HTTP.
 #[deriving(PartialEq, Eq, Clone)]
-pub struct RelativeSchemeData {
+pub struct UrlRelativeSchemeData {
     /// The username of the URL, as a possibly empty, pecent-encoded string.
     ///
     /// Percent encoded strings are within the ASCII range.
@@ -504,7 +504,7 @@ impl Url {
     fn from_path_common(path: Vec<String>) -> Url {
         Url {
             scheme: "file".to_string(),
-            scheme_data: RelativeSchemeData(RelativeSchemeData {
+            scheme_data: RelativeSchemeData(UrlRelativeSchemeData {
                 username: "".to_string(),
                 password: None,
                 port: None,
@@ -575,7 +575,7 @@ impl Url {
 
     /// If the URL is in a *relative scheme*, return the structured scheme data.
     #[inline]
-    pub fn relative_scheme_data<'a>(&'a self) -> Option<&'a RelativeSchemeData> {
+    pub fn relative_scheme_data<'a>(&'a self) -> Option<&'a UrlRelativeSchemeData> {
         match self.scheme_data {
             RelativeSchemeData(ref scheme_data) => Some(scheme_data),
             NonRelativeSchemeData(..) => None,
@@ -585,7 +585,7 @@ impl Url {
     /// If the URL is in a *relative scheme*,
     /// return a mutable reference to the structured scheme data.
     #[inline]
-    pub fn relative_scheme_data_mut<'a>(&'a mut self) -> Option<&'a mut RelativeSchemeData> {
+    pub fn relative_scheme_data_mut<'a>(&'a mut self) -> Option<&'a mut UrlRelativeSchemeData> {
         match self.scheme_data {
             RelativeSchemeData(ref mut scheme_data) => Some(scheme_data),
             NonRelativeSchemeData(..) => None,
@@ -793,7 +793,7 @@ impl Show for SchemeData {
 }
 
 
-impl RelativeSchemeData {
+impl UrlRelativeSchemeData {
     /// Percent-decode the URL’s username.
     ///
     /// This is “lossy”: invalid UTF-8 percent-encoded byte sequences
@@ -888,7 +888,7 @@ impl RelativeSchemeData {
 }
 
 
-impl Show for RelativeSchemeData {
+impl Show for UrlRelativeSchemeData {
     fn fmt(&self, formatter: &mut Formatter) -> Result<(), FormatError> {
         // Write the scheme-trailing double slashes.
         try!(formatter.write(b"//"));

src/parser.rs

@@ -16,6 +16,7 @@ use encoding;
 use super::{
     UrlParser, Url, RelativeSchemeData, NonRelativeSchemeData, Host, Domain,
     SchemeType, FileLikeRelativeScheme, RelativeScheme, NonRelativeScheme,
+    UrlRelativeSchemeData,
 };
 use percent_encoding::{
     utf8_percent_encode_to, percent_encode,
@@ -127,7 +128,7 @@ pub fn parse_url(input: &str, parser: &UrlParser) -> ParseResult<Url> {
                     parse_relative_url(remaining, scheme, scheme_type, base, query, parser)
                 },
                 // FIXME: Should not have to use a made-up base URL.
-                _ => parse_relative_url(remaining, scheme, scheme_type, &RelativeSchemeData {
+                _ => parse_relative_url(remaining, scheme, scheme_type, &UrlRelativeSchemeData {
                     username: String::new(), password: None, host: Domain(String::new()),
                     port: None, default_port: None, path: Vec::new()
                 }, &None, parser)
@@ -187,7 +188,7 @@ fn parse_absolute_url<'a>(scheme: String, scheme_type: SchemeType,
     let (host, port, default_port, remaining) = try!(parse_host(remaining, scheme_type, parser));
     let (path, remaining) = try!(parse_path_start(
         remaining, UrlParserContext, scheme_type, parser));
-    let scheme_data = RelativeSchemeData(RelativeSchemeData {
+    let scheme_data = RelativeSchemeData(UrlRelativeSchemeData {
         username: username, password: password,
         host: host, port: port, default_port: default_port,
         path: path });
@@ -197,7 +198,7 @@ fn parse_absolute_url<'a>(scheme: String, scheme_type: SchemeType,
 
 
 fn parse_relative_url<'a>(input: &'a str, scheme: String, scheme_type: SchemeType,
-                          base: &RelativeSchemeData, base_query: &Option<String>,
+                          base: &UrlRelativeSchemeData, base_query: &Option<String>,
                           parser: &UrlParser)
                           -> ParseResult<Url> {
     if input.is_empty() {
@@ -226,7 +227,7 @@ fn parse_relative_url<'a>(input: &'a str, scheme: String, scheme_type: SchemeTyp
                     };
                     let (path, remaining) = try!(parse_path_start(
                         remaining, UrlParserContext, scheme_type, parser));
-                    let scheme_data = RelativeSchemeData(RelativeSchemeData {
+                    let scheme_data = RelativeSchemeData(UrlRelativeSchemeData {
                         username: String::new(), password: None,
                         host: host, port: None, default_port: None, path: path
                     });
@@ -241,12 +242,12 @@ fn parse_relative_url<'a>(input: &'a str, scheme: String, scheme_type: SchemeTyp
                 let (path, remaining) = try!(parse_path(
                     [], input.slice_from(1), UrlParserContext, scheme_type, parser));
                 let scheme_data = RelativeSchemeData(if scheme_type == FileLikeRelativeScheme {
-                    RelativeSchemeData {
+                    UrlRelativeSchemeData {
                         username: String::new(), password: None, host:
                         Domain(String::new()), port: None, default_port: None, path: path
                     }
                 } else {
-                    RelativeSchemeData {
+                    UrlRelativeSchemeData {
                         username: base.username.clone(),
                         password: base.password.clone(),
                         host: base.host.clone(),
@@ -282,7 +283,7 @@ fn parse_relative_url<'a>(input: &'a str, scheme: String, scheme_type: SchemeTyp
                 // Windows drive letter quirk
                 let (path, remaining) = try!(parse_path(
                     [], input, UrlParserContext, scheme_type, parser));
-                 (RelativeSchemeData(RelativeSchemeData {
+                 (RelativeSchemeData(UrlRelativeSchemeData {
                     username: String::new(), password: None,
                     host: Domain(String::new()),
                     port: None,
@@ -294,7 +295,7 @@ fn parse_relative_url<'a>(input: &'a str, scheme: String, scheme_type: SchemeTyp
                 // Relative path state
                 let (path, remaining) = try!(parse_path(
                     base_path, input, UrlParserContext, scheme_type, parser));
-                (RelativeSchemeData(RelativeSchemeData {
+                (RelativeSchemeData(UrlRelativeSchemeData {
                     username: base.username.clone(),
                     password: base.password.clone(),
                     host: base.host.clone(),

src/punycode.rs

@@ -216,7 +216,7 @@ fn value_to_digit(value: u32, output: &mut String) {
 #[cfg(test)]
 mod tests {
     use super::{decode, encode_str};
-    use serialize::json::{from_str, List, Object, String};
+    use serialize::json::{from_str, List, JsonObject, Object, String};
 
     fn one_test(description: &str, decoded: &str, encoded: &str) {
         match decode(encoded) {
@@ -239,7 +239,7 @@ mod tests {
         }
     }
 
-    fn get_string<'a>(map: &'a Object, key: &str) -> &'a str {
+    fn get_string<'a>(map: &'a JsonObject, key: &str) -> &'a str {
         match map.find(&key.to_string()) {
             Some(&String(ref s)) => s.as_slice(),
             None => "",

src/tests.rs

@@ -11,11 +11,12 @@ use std::char;
 use std::u32;
 use std::path;
 use super::{UrlParser, Url, RelativeSchemeData, NonRelativeSchemeData, Domain};
+use super::UrlRelativeSchemeData;
 
 
 #[test]
 fn url_parsing() {
-    for test in parse_test_data(include_str!("urltestdata.txt")).move_iter() {
+    for test in parse_test_data(include_str!("urltestdata.txt")).into_iter() {
         let Test {
             input: input,
             base: base,
@@ -69,7 +70,7 @@ fn url_parsing() {
 
         assert_eq!(Some(scheme), expected_scheme);
         match scheme_data {
-            RelativeSchemeData(RelativeSchemeData {
+            RelativeSchemeData(UrlRelativeSchemeData {
                 username, password, host, port, default_port: _, path,
             }) => {
                 assert_eq!(username, expected_username);
@@ -141,7 +142,7 @@ fn parse_test_data(input: &str) -> Vec<Test> {
             fragment: None,
             expected_failure: expected_failure,
         };
-        for piece in pieces.move_iter() {
+        for piece in pieces.into_iter() {
             if piece == "" || piece.starts_with("#") {
                 continue
             }

src/urlutils.rs

@@ -11,6 +11,7 @@
 //! only to help implement the JavaScript URLUtils API: http://url.spec.whatwg.org/#urlutils
 
 use super::{Url, UrlParser, RelativeSchemeData, NonRelativeSchemeData, FileLikeRelativeScheme};
+use super::UrlRelativeSchemeData;
 use parser::{
     ParseResult, InvalidScheme,
     CannotSetFileScheme, CannotSetJavascriptScheme, CannotSetNonRelativeScheme,
@@ -53,7 +54,7 @@ impl<'a> UrlUtils for UrlUtilsWrapper<'a> {
     /// `URLUtils.username` setter
     fn set_username(&mut self, input: &str) -> ParseResult<()> {
         match self.url.scheme_data {
-            RelativeSchemeData(RelativeSchemeData { ref mut username, .. }) => {
+            RelativeSchemeData(UrlRelativeSchemeData { ref mut username, .. }) => {
                 username.truncate(0);
                 utf8_percent_encode_to(input, USERNAME_ENCODE_SET, username);
                 Ok(())
@@ -65,7 +66,7 @@ impl<'a> UrlUtils for UrlUtilsWrapper<'a> {
     /// `URLUtils.password` setter
     fn set_password(&mut self, input: &str) -> ParseResult<()> {
         match self.url.scheme_data {
-            RelativeSchemeData(RelativeSchemeData { ref mut password, .. }) => {
+            RelativeSchemeData(UrlRelativeSchemeData { ref mut password, .. }) => {
                 let mut new_password = String::new();
                 utf8_percent_encode_to(input, PASSWORD_ENCODE_SET, &mut new_password);
                 *password = Some(new_password);
@@ -78,7 +79,7 @@ impl<'a> UrlUtils for UrlUtilsWrapper<'a> {
     /// `URLUtils.host` setter
     fn set_host_and_port(&mut self, input: &str) -> ParseResult<()> {
         match self.url.scheme_data {
-            RelativeSchemeData(RelativeSchemeData {
+            RelativeSchemeData(UrlRelativeSchemeData {
                 ref mut host, ref mut port, ref mut default_port, ..
             }) => {
                 let scheme_type = self.parser.get_scheme_type(self.url.scheme.as_slice());
@@ -96,7 +97,7 @@ impl<'a> UrlUtils for UrlUtilsWrapper<'a> {
     /// `URLUtils.hostname` setter
     fn set_host(&mut self, input: &str) -> ParseResult<()> {
         match self.url.scheme_data {
-            RelativeSchemeData(RelativeSchemeData { ref mut host, .. }) => {
+            RelativeSchemeData(UrlRelativeSchemeData { ref mut host, .. }) => {
                 let (new_host, _) = try!(::parser::parse_hostname(input, self.parser));
                 *host = new_host;
                 Ok(())
@@ -108,7 +109,7 @@ impl<'a> UrlUtils for UrlUtilsWrapper<'a> {
     /// `URLUtils.port` setter
     fn set_port(&mut self, input: &str) -> ParseResult<()> {
         match self.url.scheme_data {
-            RelativeSchemeData(RelativeSchemeData { ref mut port, ref mut default_port, .. }) => {
+            RelativeSchemeData(UrlRelativeSchemeData { ref mut port, ref mut default_port, .. }) => {
                 let scheme_type = self.parser.get_scheme_type(self.url.scheme.as_slice());
                 if scheme_type == FileLikeRelativeScheme {
                     return Err(CannotSetFileScheme("port"));
@@ -126,7 +127,7 @@ impl<'a> UrlUtils for UrlUtilsWrapper<'a> {
     /// `URLUtils.pathname` setter
     fn set_path(&mut self, input: &str) -> ParseResult<()> {
         match self.url.scheme_data {
-            RelativeSchemeData(RelativeSchemeData { ref mut path, .. }) => {
+            RelativeSchemeData(UrlRelativeSchemeData { ref mut path, .. }) => {
                 let scheme_type = self.parser.get_scheme_type(self.url.scheme.as_slice());
                 let (new_path, _) = try!(::parser::parse_path_start(
                     input, ::parser::SetterContext, scheme_type, self.parser));