File rust140-url-P2-1.6.0.patch of Package seamonkey

Overview Repositories Revisions Requests Users Attributes Meta

File rust140-url-P2-1.6.0.patch of Package seamonkey (Revision 844bb663198e26c71f297d876d363e90)

Currently displaying revision 844bb663198e26c71f297d876d363e90 , Show latest

# Adapted for SeaMonkey-2.53:
# Removed parts of the commit related to third_party/rust/url-1.5.1
#

# HG changeset patch
# User Servo VCS Sync <servo-vcs-sync@mozilla.com>
# Date 1509489594 0
# Node ID 788e64fb4fd49f61a871a9cdad29a79ad347d3e9
# Parent  d480e881831442f22b9f5ba736707f1760bca9e1
No bug - Revendor rust dependencies

diff --git a/third_party/rust/url/.cargo-checksum.json b/third_party/rust/url/.cargo-checksum.json
--- a/third_party/rust/url/.cargo-checksum.json
+++ b/third_party/rust/url/.cargo-checksum.json
@@ -1,1 +1,1 @@
-{"files":{".travis.yml":"890af214187ffcba4732acb2d1af30d7adb9aade0679e9fdb06baae363240b8e","Cargo.toml":"ec586106c4d0625919a3591fe3ae915043e82c8bfdd1c9e747171ba5e21047e1","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"20c7855c364d57ea4c97889a5e8d98470a9952dade37bd9248b9a54431670e5e","Makefile":"bffd75d34654b2955d4f005f1a5e85c821c90becf1a8a52cbe10121972f43148","README.md":"eb3f4694003f408cbe3c7f3e9fbbc71241defb940cc55a816981f0f0f144c8eb","UPGRADING.md":"fbcc2d39bdf17db0745793db6626fcd5c909dddd4ce13b27566cfabece22c368","appveyor.yml":"c78486dbfbe6ebbf3d808afb9a19f7ec18c4704ce451c6305f0716999b70a1a6","docs/.nojekyll":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","docs/404.html":"f61e6271c1ea1aa113b64b356e994595fa548f0433f89948d747503ad22195cd","docs/index.html":"f61e6271c1ea1aa113b64b356e994595fa548f0433f89948d747503ad22195cd","github.png":"b432fd855efe7c430fe6a57ccf83935c1996f03a7cdc8d6e1b34154b8c43f6ec","rust-url-todo":"1192cee7b6cedf2133d97dc6074b593a1d19b0ee13fff6f28d6329855044e575","src/encoding.rs":"f3e109ca8ec5a9130da50cdfb3003530aedb6dd5a440f0790d76b71f6981119c","src/form_urlencoded.rs":"7ccaef7148e4bc2577154c50f8705db3a055b641269e24c22770f06222321e1e","src/host.rs":"281165d732ea87b6f01a98f7c68ffcb284c41f84b3ab6ed674fb8e57022d1019","src/lib.rs":"bd156e8bcfbd44f0cd52c8b394e03ec63fea012c0bf5ca554521352714838605","src/origin.rs":"7071dcc1070ccfae84cdcd43586b84a9706e35a9a099ff4dde128da0909bd0bc","src/parser.rs":"9d30868f0900586fec6f122a0322598a08116ab0b4c4d8caf5c35a720381a73a","src/path_segments.rs":"7bd3142eaa568863ef44e2255c181239141f9eeee337f889b9ffaaeab4ca669d","src/quirks.rs":"1231f965e22bb3632c22993e2a8d4c7470bcb4a8de25d049f31784303f0def03","src/slicing.rs":"4e539886b23945a92094625f3e531a4bff40daa44240b5d19ee8577478c4f7fe","tests/data.rs":"c333766897f6492fb6583ab5c8a511973b7a55f58ca550799432343da64d5ca7","tests/setters_tests.json":"ebcbdb52e9a4b5a565f8806d52ebc610d46a34df883e10b0be080d026468ff73","tests/unit.rs":"c2f206f433be619414d761d358a2a4a5a46cfe8a4fea5339adec5e9937d78de2","tests/urltestdata.json":"430c74aa3a31afaa57a92805544e00825f4dffe2def98c1e3c212c3db80268af"},"package":"eeb819346883532a271eb626deb43c4a1bb4c4dd47c519bd78137c3e72a4fe27"}
\ No newline at end of file
+{"files":{".travis.yml":"890af214187ffcba4732acb2d1af30d7adb9aade0679e9fdb06baae363240b8e","Cargo.toml":"52e8e0a7014d3b0c654491184e9fc82f8c61ba7f51332e2b6a787330be42a301","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"20c7855c364d57ea4c97889a5e8d98470a9952dade37bd9248b9a54431670e5e","Makefile":"bffd75d34654b2955d4f005f1a5e85c821c90becf1a8a52cbe10121972f43148","README.md":"eb3f4694003f408cbe3c7f3e9fbbc71241defb940cc55a816981f0f0f144c8eb","UPGRADING.md":"fbcc2d39bdf17db0745793db6626fcd5c909dddd4ce13b27566cfabece22c368","appveyor.yml":"c78486dbfbe6ebbf3d808afb9a19f7ec18c4704ce451c6305f0716999b70a1a6","docs/.nojekyll":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855","docs/404.html":"f61e6271c1ea1aa113b64b356e994595fa548f0433f89948d747503ad22195cd","docs/index.html":"f61e6271c1ea1aa113b64b356e994595fa548f0433f89948d747503ad22195cd","github.png":"b432fd855efe7c430fe6a57ccf83935c1996f03a7cdc8d6e1b34154b8c43f6ec","rust-url-todo":"1192cee7b6cedf2133d97dc6074b593a1d19b0ee13fff6f28d6329855044e575","src/encoding.rs":"f3e109ca8ec5a9130da50cdfb3003530aedb6dd5a440f0790d76b71f6981119c","src/form_urlencoded.rs":"320418526c4564a4469581d426e7467bcefe504eecd098e1eb90a2663a75fd80","src/host.rs":"4c74946777d76e9b307604f8e24a3485fd0856b664450194e8b429e262cf410d","src/lib.rs":"894cc76c31357fb588292e990a87f4e951043e32ea3d9f38fddc145302d0b318","src/origin.rs":"6e4821eb9600a32ef54d05c8e1a7937f6d9b4dd1e3bda7f36c7988f6a2bef78b","src/parser.rs":"e379c9eb51cff977b9cef368ab64bcff7626e885b859772ab1bc76c9193e9fde","src/path_segments.rs":"7bd3142eaa568863ef44e2255c181239141f9eeee337f889b9ffaaeab4ca669d","src/quirks.rs":"fe6095104cf583053ab35d8a2a093a8581da083641e32d1c5acfe322a26c4bde","src/slicing.rs":"4e539886b23945a92094625f3e531a4bff40daa44240b5d19ee8577478c4f7fe","tests/data.rs":"50a110e475b1717fdaff6524be7d8916cb41a45461e0715f632ff54d0ce28886","tests/setters_tests.json":"ebcbdb52e9a4b5a565f8806d52ebc610d46a34df883e10b0be080d026468ff73","tests/unit.rs":"c0305ca991b2c03815aac2e69ef1c1792b087df92272a6196eb698b27625321f","tests/urltestdata.json":"df87028e1eaea4ef70cf1c1faaed2584e81a46b8b6cd90f50d47b77726ece41c"},"package":"fa35e768d4daf1d85733418a49fb42e10d7f633e394fccab4ab7aba897053fe2"}
\ No newline at end of file
diff --git a/third_party/rust/url/Cargo.toml b/third_party/rust/url/Cargo.toml
--- a/third_party/rust/url/Cargo.toml
+++ b/third_party/rust/url/Cargo.toml
@@ -1,49 +1,74 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g. crates.io) dependencies
+#
+# If you believe there's an error in this file please file an
+# issue against the rust-lang/cargo repository. If you're
+# editing this file be aware that the upstream Cargo.toml
+# will likely look very different (and much more reasonable)
+
 [package]
-
 name = "url"
-# When updating version, also modify html_root_url in the lib.rs
-version = "1.5.1"
+version = "1.6.0"
 authors = ["The rust-url developers"]
-
 description = "URL library for Rust, based on the WHATWG URL Standard"
 documentation = "https://docs.rs/url"
-repository = "https://github.com/servo/rust-url"
 readme = "README.md"
 keywords = ["url", "parser"]
 categories = ["parser-implementations", "web-programming", "encoding"]
 license = "MIT/Apache-2.0"
+repository = "https://github.com/servo/rust-url"
 
-[badges]
-travis-ci = { repository = "servo/rust-url" }
-appveyor = { repository = "servo/rust-url" }
-
-[workspace]
-members = [".", "idna", "percent_encoding", "url_serde"]
+[lib]
+test = false
 
 [[test]]
 name = "unit"
 
 [[test]]
 name = "data"
 harness = false
+[dependencies.rustc-serialize]
+version = "0.3"
+optional = true
 
-[lib]
-test = false
+[dependencies.matches]
+version = "0.1"
+
+[dependencies.serde]
+version = ">=0.6.1, <0.9"
+optional = true
+
+[dependencies.percent-encoding]
+version = "1.0.0"
 
-[dev-dependencies]
-rustc-test = "0.1"
-rustc-serialize = "0.3"
-serde_json = ">=0.6.1, <0.9"
+[dependencies.encoding]
+version = "0.2"
+optional = true
+
+[dependencies.idna]
+version = "0.1.0"
+
+[dependencies.heapsize]
+version = ">=0.4.1, <0.5"
+optional = true
+[dev-dependencies.rustc-test]
+version = "0.2"
+
+[dev-dependencies.rustc-serialize]
+version = "0.3"
+
+[dev-dependencies.serde_json]
+version = ">=0.6.1, <0.9"
 
 [features]
+heap_size = ["heapsize"]
 query_encoding = ["encoding"]
-heap_size = ["heapsize"]
+[badges.travis-ci]
+repository = "servo/rust-url"
 
-[dependencies]
-encoding = {version = "0.2", optional = true}
-heapsize = {version = ">=0.1.1, <0.5", optional = true}
-idna = { version = "0.1.0", path = "./idna" }
-matches = "0.1"
-percent-encoding = { version = "1.0.0", path = "./percent_encoding" }
-rustc-serialize = {version = "0.3", optional = true}
-serde = {version = ">=0.6.1, <0.9", optional = true}
+[badges.appveyor]
+repository = "Manishearth/rust-url"
diff --git a/third_party/rust/url/src/form_urlencoded.rs b/third_party/rust/url/src/form_urlencoded.rs
--- a/third_party/rust/url/src/form_urlencoded.rs
+++ b/third_party/rust/url/src/form_urlencoded.rs
@@ -11,16 +11,17 @@
 //! as used by HTML forms.
 //!
 //! Converts between a string (such as an URL’s query string)
 //! and a sequence of (name, value) pairs.
 
 use encoding::EncodingOverride;
 use percent_encoding::{percent_encode_byte, percent_decode};
 use std::borrow::{Borrow, Cow};
+use std::fmt;
 use std::str;
 
 
 /// Convert a byte string in the `application/x-www-form-urlencoded` syntax
 /// into a iterator of (name, value) pairs.
 ///
 /// Use `parse(input.as_bytes())` to parse a `&str` string.
 ///
@@ -211,16 +212,25 @@ impl<'a> Iterator for ByteSerialize<'a> 
 
 /// The [`application/x-www-form-urlencoded` serializer](
 /// https://url.spec.whatwg.org/#concept-urlencoded-serializer).
 #[derive(Debug)]
 pub struct Serializer<T: Target> {
     target: Option<T>,
     start_position: usize,
     encoding: EncodingOverride,
+    custom_encoding: Option<SilentDebug<Box<FnMut(&str) -> Cow<[u8]>>>>,
+}
+
+struct SilentDebug<T>(T);
+
+impl<T> fmt::Debug for SilentDebug<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str("…")
+    }
 }
 
 pub trait Target {
     fn as_mut_string(&mut self) -> &mut String;
     fn finish(self) -> Self::Finished;
     type Finished;
 }
 
@@ -267,16 +277,17 @@ impl<T: Target> Serializer<T> {
     /// If that suffix is non-empty,
     /// its content is assumed to already be in `application/x-www-form-urlencoded` syntax.
     pub fn for_suffix(mut target: T, start_position: usize) -> Self {
         &target.as_mut_string()[start_position..];  // Panic if out of bounds
         Serializer {
             target: Some(target),
             start_position: start_position,
             encoding: EncodingOverride::utf8(),
+            custom_encoding: None,
         }
     }
 
     /// Remove any existing name/value pair.
     ///
     /// Panics if called after `.finish()`.
     pub fn clear(&mut self) -> &mut Self {
         string(&mut self.target).truncate(self.start_position);
@@ -285,50 +296,62 @@ impl<T: Target> Serializer<T> {
 
     /// Set the character encoding to be used for names and values before percent-encoding.
     #[cfg(feature = "query_encoding")]
     pub fn encoding_override(&mut self, new: Option<::encoding::EncodingRef>) -> &mut Self {
         self.encoding = EncodingOverride::from_opt_encoding(new).to_output_encoding();
         self
     }
 
+    /// Set the character encoding to be used for names and values before percent-encoding.
+    pub fn custom_encoding_override<F>(&mut self, encode: F) -> &mut Self
+        where F: FnMut(&str) -> Cow<[u8]> + 'static
+    {
+        self.custom_encoding = Some(SilentDebug(Box::new(encode)));
+        self
+    }
+
     /// Serialize and append a name/value pair.
     ///
     /// Panics if called after `.finish()`.
     pub fn append_pair(&mut self, name: &str, value: &str) -> &mut Self {
-        append_pair(string(&mut self.target), self.start_position, self.encoding, name, value);
+        append_pair(string(&mut self.target), self.start_position, self.encoding,
+                    &mut self.custom_encoding, name, value);
         self
     }
 
     /// Serialize and append a number of name/value pairs.
     ///
     /// This simply calls `append_pair` repeatedly.
     /// This can be more convenient, so the user doesn’t need to introduce a block
     /// to limit the scope of `Serializer`’s borrow of its string.
     ///
     /// Panics if called after `.finish()`.
     pub fn extend_pairs<I, K, V>(&mut self, iter: I) -> &mut Self
     where I: IntoIterator, I::Item: Borrow<(K, V)>, K: AsRef<str>, V: AsRef<str> {
         {
             let string = string(&mut self.target);
             for pair in iter {
                 let &(ref k, ref v) = pair.borrow();
-                append_pair(string, self.start_position, self.encoding, k.as_ref(), v.as_ref());
+                append_pair(string, self.start_position, self.encoding,
+                            &mut self.custom_encoding, k.as_ref(), v.as_ref());
             }
         }
         self
     }
 
     /// Add a name/value pair whose name is `_charset_`
     /// and whose value is the character encoding’s name.
     /// (See the `encoding_override()` method.)
     ///
     /// Panics if called after `.finish()`.
     #[cfg(feature = "query_encoding")]
     pub fn append_charset(&mut self) -> &mut Self {
+        assert!(self.custom_encoding.is_none(),
+                "Cannot use both custom_encoding_override() and append_charset()");
         {
             let string = string(&mut self.target);
             append_separator_if_needed(string, self.start_position);
             string.push_str("_charset_=");
             string.push_str(self.encoding.name());
         }
         self
     }
@@ -356,14 +379,25 @@ fn append_separator_if_needed(string: &m
     }
 }
 
 fn string<T: Target>(target: &mut Option<T>) -> &mut String {
     target.as_mut().expect("url::form_urlencoded::Serializer finished").as_mut_string()
 }
 
 fn append_pair(string: &mut String, start_position: usize, encoding: EncodingOverride,
+               custom_encoding: &mut Option<SilentDebug<Box<FnMut(&str) -> Cow<[u8]>>>>,
                name: &str, value: &str) {
     append_separator_if_needed(string, start_position);
-    string.extend(byte_serialize(&encoding.encode(name.into())));
+    append_encoded(name, string, encoding, custom_encoding);
     string.push('=');
-    string.extend(byte_serialize(&encoding.encode(value.into())));
+    append_encoded(value, string, encoding, custom_encoding);
 }
+
+fn append_encoded(s: &str, string: &mut String, encoding: EncodingOverride,
+               custom_encoding: &mut Option<SilentDebug<Box<FnMut(&str) -> Cow<[u8]>>>>) {
+    let bytes = if let Some(SilentDebug(ref mut custom)) = *custom_encoding {
+        custom(s)
+    } else {
+        encoding.encode(s.into())
+    };
+    string.extend(byte_serialize(&bytes));
+}
diff --git a/third_party/rust/url/src/host.rs b/third_party/rust/url/src/host.rs
--- a/third_party/rust/url/src/host.rs
+++ b/third_party/rust/url/src/host.rs
@@ -132,17 +132,17 @@ impl<'a> Host<&'a str> {
             Host::Ipv6(address) => Host::Ipv6(address),
         }
     }
 }
 
 impl Host<String> {
     /// Parse a host: either an IPv6 address in [] square brackets, or a domain.
     ///
-    /// https://url.spec.whatwg.org/#host-parsing
+    /// <https://url.spec.whatwg.org/#host-parsing>
     pub fn parse(input: &str) -> Result<Self, ParseError> {
         if input.starts_with('[') {
             if !input.ends_with(']') {
                 return Err(ParseError::InvalidIpv6Address)
             }
             return parse_ipv6addr(&input[1..input.len() - 1]).map(Host::Ipv6)
         }
         let domain = percent_decode(input.as_bytes()).decode_utf8_lossy();
@@ -304,17 +304,17 @@ fn longest_zero_sequence(pieces: &[u16; 
     // step 3: ignore lone zeroes
     if longest_length < 2 {
         (-1, -2)
     } else {
         (longest, longest + longest_length)
     }
 }
 
-/// https://url.spec.whatwg.org/#ipv4-number-parser
+/// <https://url.spec.whatwg.org/#ipv4-number-parser>
 fn parse_ipv4number(mut input: &str) -> Result<u32, ()> {
     let mut r = 10;
     if input.starts_with("0x") || input.starts_with("0X") {
         input = &input[2..];
         r = 16;
     } else if input.len() >= 2 && input.starts_with('0') {
         input = &input[1..];
         r = 8;
@@ -326,17 +326,17 @@ fn parse_ipv4number(mut input: &str) -> 
         return Err(())
     }
     match u32::from_str_radix(input, r) {
         Ok(number) => Ok(number),
         Err(_) => Err(()),
     }
 }
 
-/// https://url.spec.whatwg.org/#concept-ipv4-parser
+/// <https://url.spec.whatwg.org/#concept-ipv4-parser>
 fn parse_ipv4addr(input: &str) -> ParseResult<Option<Ipv4Addr>> {
     if input.is_empty() {
         return Ok(None)
     }
     let mut parts: Vec<&str> = input.split('.').collect();
     if parts.last() == Some(&"") {
         parts.pop();
     }
@@ -363,17 +363,17 @@ fn parse_ipv4addr(input: &str) -> ParseR
         return Err(ParseError::InvalidIpv4Address);
     }
     for (counter, n) in numbers.iter().enumerate() {
         ipv4 += n << (8 * (3 - counter as u32))
     }
     Ok(Some(Ipv4Addr::from(ipv4)))
 }
 
-/// https://url.spec.whatwg.org/#concept-ipv6-parser
+/// <https://url.spec.whatwg.org/#concept-ipv6-parser>
 fn parse_ipv6addr(input: &str) -> ParseResult<Ipv6Addr> {
     let input = input.as_bytes();
     let len = input.len();
     let mut is_ip_v4 = false;
     let mut pieces = [0, 0, 0, 0, 0, 0, 0, 0];
     let mut piece_pointer = 0;
     let mut compress_pointer = None;
     let mut i = 0;
@@ -418,16 +418,19 @@ fn parse_ipv6addr(input: &str) -> ParseR
         }
         if i < len {
             match input[i] {
                 b'.' => {
                     if i == start {
                         return Err(ParseError::InvalidIpv6Address)
                     }
                     i = start;
+                    if piece_pointer > 6 {
+                        return Err(ParseError::InvalidIpv6Address)
+                    }
                     is_ip_v4 = true;
                 },
                 b':' => {
                     i += 1;
                     if i == len {
                         return Err(ParseError::InvalidIpv6Address)
                     }
                 },
@@ -440,54 +443,66 @@ fn parse_ipv6addr(input: &str) -> ParseR
         pieces[piece_pointer] = value;
         piece_pointer += 1;
     }
 
     if is_ip_v4 {
         if piece_pointer > 6 {
             return Err(ParseError::InvalidIpv6Address)
         }
-        let mut dots_seen = 0;
+        let mut numbers_seen = 0;
         while i < len {
-            let mut value = None;
+            if numbers_seen > 0 {
+                if numbers_seen < 4 && (i < len && input[i] == b'.') {
+                    i += 1
+                } else {
+                    return Err(ParseError::InvalidIpv6Address)
+                }
+            }
+
+            let mut ipv4_piece = None;
             while i < len {
                 let digit = match input[i] {
                     c @ b'0' ... b'9' => c - b'0',
                     _ => break
                 };
-                match value {
-                    None => value = Some(digit as u16),
+                match ipv4_piece {
+                    None => ipv4_piece = Some(digit as u16),
                     Some(0) => return Err(ParseError::InvalidIpv6Address),  // No leading zero
                     Some(ref mut v) => {
                         *v = *v * 10 + digit as u16;
                         if *v > 255 {
                             return Err(ParseError::InvalidIpv6Address)
                         }
                     }
                 }
                 i += 1;
             }
-            if dots_seen < 3 && !(i < len && input[i] == b'.') {
-                return Err(ParseError::InvalidIpv6Address)
-            }
-            pieces[piece_pointer] = if let Some(v) = value {
+
+            pieces[piece_pointer] = if let Some(v) = ipv4_piece {
                 pieces[piece_pointer] * 0x100 + v
             } else {
                 return Err(ParseError::InvalidIpv6Address)
             };
-            if dots_seen == 1 || dots_seen == 3 {
+            numbers_seen += 1;
+
+            if numbers_seen == 2 || numbers_seen == 4 {
                 piece_pointer += 1;
             }
-            i += 1;
-            if dots_seen == 3 && i < len {
-                return Err(ParseError::InvalidIpv6Address)
-            }
-            dots_seen += 1;
+        }
+
+        if numbers_seen != 4 {
+            return Err(ParseError::InvalidIpv6Address)
         }
     }
+
+    if i < len {
+        return Err(ParseError::InvalidIpv6Address)
+    }
+
     match compress_pointer {
         Some(compress_pointer) => {
             let mut swaps = piece_pointer - compress_pointer;
             piece_pointer = 7;
             while swaps > 0 {
                 pieces.swap(piece_pointer, compress_pointer + swaps - 1);
                 swaps -= 1;
                 piece_pointer -= 1;
diff --git a/third_party/rust/url/src/lib.rs b/third_party/rust/url/src/lib.rs
--- a/third_party/rust/url/src/lib.rs
+++ b/third_party/rust/url/src/lib.rs
@@ -99,17 +99,17 @@ use url::Url;
 let this_document = Url::parse("http://servo.github.io/rust-url/url/index.html")?;
 let css_url = this_document.join("../main.css")?;
 assert_eq!(css_url.as_str(), "http://servo.github.io/rust-url/main.css");
 # Ok(())
 # }
 # run().unwrap();
 */
 
-#![doc(html_root_url = "https://docs.rs/url/1.5.1")]
+#![doc(html_root_url = "https://docs.rs/url/1.6.0")]
 
 #[cfg(feature="rustc-serialize")] extern crate rustc_serialize;
 #[macro_use] extern crate matches;
 #[cfg(feature="serde")] extern crate serde;
 #[cfg(feature="heapsize")] #[macro_use] extern crate heapsize;
 
 pub extern crate idna;
 pub extern crate percent_encoding;
@@ -247,16 +247,23 @@ impl Url {
     /// # use url::ParseError;
     ///
     /// # fn run() -> Result<(), ParseError> {
     /// let url = Url::parse("https://example.net")?;
     /// # Ok(())
     /// # }
     /// # run().unwrap();
     /// ```
+    /// 
+    /// # Errors
+    ///
+    /// If the function can not parse an absolute URL from the given string,
+    /// a [`ParseError`] variant will be returned.
+    ///
+    /// [`ParseError`]: enum.ParseError.html
     #[inline]
     pub fn parse(input: &str) -> Result<Url, ::ParseError> {
         Url::options().parse(input)
     }
 
     /// Parse an absolute URL from a string and add params to its query string.
     ///
     /// Existing params are not removed.
@@ -269,16 +276,23 @@ impl Url {
     ///
     /// # fn run() -> Result<(), ParseError> {
     /// let url = Url::parse_with_params("https://example.net?dont=clobberme",
     ///                                  &[("lang", "rust"), ("browser", "servo")])?;
     /// # Ok(())
     /// # }
     /// # run().unwrap();
     /// ```
+    ///
+    /// # Errors
+    ///
+    /// If the function can not parse an absolute URL from the given string,
+    /// a [`ParseError`] variant will be returned.
+    ///
+    /// [`ParseError`]: enum.ParseError.html
     #[inline]
     pub fn parse_with_params<I, K, V>(input: &str, iter: I) -> Result<Url, ::ParseError>
         where I: IntoIterator,
               I::Item: Borrow<(K, V)>,
               K: AsRef<str>,
               V: AsRef<str>
     {
         let mut url = Url::options().parse(input);
@@ -309,16 +323,23 @@ impl Url {
     ///
     /// let base = Url::parse("https://example.net/a/b/")?;
     /// let url = base.join("c.png")?;
     /// assert_eq!(url.as_str(), "https://example.net/a/b/c.png");
     /// # Ok(())
     /// # }
     /// # run().unwrap();
     /// ```
+    ///
+    /// # Errors
+    ///
+    /// If the function can not parse an URL from the given string 
+    /// with this URL as the base URL, a [`ParseError`] variant will be returned.
+    ///
+    /// [`ParseError`]: enum.ParseError.html
     #[inline]
     pub fn join(&self, input: &str) -> Result<Url, ::ParseError> {
         Url::options().base_url(Some(self)).parse(input)
     }
 
     /// Return a default `ParseOptions` that can fully configure the URL parser.
     ///
     /// # Examples
@@ -495,17 +516,17 @@ impl Url {
                 (self.host_str(), other.host_str()) == (None, Some("")));
         assert_eq!(self.port, other.port);
         assert_eq!(self.path_start, other.path_start);
         assert_eq!(self.query_start, other.query_start);
         assert_eq!(self.fragment_start, other.fragment_start);
         Ok(())
     }
 
-    /// Return the origin of this URL (https://url.spec.whatwg.org/#origin)
+    /// Return the origin of this URL (<https://url.spec.whatwg.org/#origin>)
     ///
     /// Note: this returns an opaque origin for `file:` URLs, which causes
     /// `url.origin() != url.origin()`.
     ///
     /// # Examples
     ///
     /// URL with `ftp` scheme:
     ///
@@ -1443,19 +1464,16 @@ impl Url {
                 self.serialization.push_str(&path_and_after);
             }
         }
         self.port = port;
     }
 
     /// Change this URL’s host.
     ///
-    /// If this URL is cannot-be-a-base or there is an error parsing the given `host`,
-    /// do nothing and return `Err`.
-    ///
     /// Removing the host (calling this with `None`)
     /// will also remove any username, password, and port number.
     ///
     /// # Examples
     ///
     /// Change host:
     ///
     /// ```
@@ -1519,16 +1537,23 @@ impl Url {
     ///
     /// let result = url.set_host(None);
     /// assert!(result.is_err());
     /// assert_eq!(url.as_str(), "mailto:rms@example.net");
     /// # Ok(())
     /// # }
     /// # run().unwrap();
     /// ```
+    ///
+    /// # Errors
+    ///
+    /// If this URL is cannot-be-a-base or there is an error parsing the given `host`,
+    /// a [`ParseError`] variant will be returned.
+    ///
+    /// [`ParseError`]: enum.ParseError.html
     pub fn set_host(&mut self, host: Option<&str>) -> Result<(), ParseError> {
         if self.cannot_be_a_base() {
             return Err(ParseError::SetHostOnCannotBeABaseUrl)
         }
 
         if let Some(host) = host {
             if host == "" && SchemeType::from(self.scheme()).is_special() {
                 return Err(ParseError::EmptyHost);
@@ -1727,25 +1752,26 @@ impl Url {
     /// assert_eq!(url.as_str(), "mailto:rmz@example.com");
     /// assert!(result.is_err());
     /// # Ok(())
     /// # }
     /// # run().unwrap();
     /// ```
     ///
     /// Setup username to user1
+    ///
     /// ```rust
     /// use url::{Url, ParseError};
     ///
     /// # fn run() -> Result<(), ParseError> {
-    /// let mut url = Url::parse("ftp://:secre1@example.com")?;
+    /// let mut url = Url::parse("ftp://:secre1@example.com/")?;
     /// let result = url.set_username("user1");
     /// assert!(result.is_ok());
     /// assert_eq!(url.username(), "user1");
-    /// assert_eq!(url.as_str(), "ftp://user1:secre1@example.com");
+    /// assert_eq!(url.as_str(), "ftp://user1:secre1@example.com/");
     /// # Ok(())
     /// # }
     /// # run().unwrap();
     /// ```
     pub fn set_username(&mut self, username: &str) -> Result<(), ()> {
         if !self.has_host() {
             return Err(())
         }
diff --git a/third_party/rust/url/src/origin.rs b/third_party/rust/url/src/origin.rs
--- a/third_party/rust/url/src/origin.rs
+++ b/third_party/rust/url/src/origin.rs
@@ -44,17 +44,17 @@ pub fn url_origin(url: &Url) -> Origin {
 /// - If the scheme is "blob" the origin is the origin of the
 ///   URL contained in the path component. If parsing fails,
 ///   it is an opaque origin.
 /// - If the scheme is "ftp", "gopher", "http", "https", "ws", or "wss",
 ///   then the origin is a tuple of the scheme, host, and port.
 /// - If the scheme is anything else, the origin is opaque, meaning
 ///   the URL does not have the same origin as any other URL.
 ///
-/// For more information see https://url.spec.whatwg.org/#origin
+/// For more information see <https://url.spec.whatwg.org/#origin>
 #[derive(PartialEq, Eq, Hash, Clone, Debug)]
 pub enum Origin {
     /// A globally unique identifier
     Opaque(OpaqueOrigin),
 
     /// Consists of the URL's scheme, host and port
     Tuple(String, Host<String>, u16)
 }
@@ -81,31 +81,31 @@ impl Origin {
     }
 
     /// Return whether this origin is a (scheme, host, port) tuple
     /// (as opposed to an opaque origin).
     pub fn is_tuple(&self) -> bool {
         matches!(*self, Origin::Tuple(..))
     }
 
-    /// https://html.spec.whatwg.org/multipage/#ascii-serialisation-of-an-origin
+    /// <https://html.spec.whatwg.org/multipage/#ascii-serialisation-of-an-origin>
     pub fn ascii_serialization(&self) -> String {
         match *self {
             Origin::Opaque(_) => "null".to_owned(),
             Origin::Tuple(ref scheme, ref host, port) => {
                 if default_port(scheme) == Some(port) {
                     format!("{}://{}", scheme, host)
                 } else {
                     format!("{}://{}:{}", scheme, host, port)
                 }
             }
         }
     }
 
-    /// https://html.spec.whatwg.org/multipage/#unicode-serialisation-of-an-origin
+    /// <https://html.spec.whatwg.org/multipage/#unicode-serialisation-of-an-origin>
     pub fn unicode_serialization(&self) -> String {
         match *self {
             Origin::Opaque(_) => "null".to_owned(),
             Origin::Tuple(ref scheme, ref host, port) => {
                 let host = match *host {
                     Host::Domain(ref domain) => {
                         let (domain, _errors) = domain_to_unicode(domain);
                         Host::Domain(domain)
diff --git a/third_party/rust/url/src/parser.rs b/third_party/rust/url/src/parser.rs
--- a/third_party/rust/url/src/parser.rs
+++ b/third_party/rust/url/src/parser.rs
@@ -678,17 +678,17 @@ impl<'a> Parser<'a> {
         let mut char_count = 0;
         while let Some(c) = remaining.next() {
             match c {
                 '@' => {
                     if last_at.is_some() {
                         self.syntax_violation("unencoded @ sign in username or password")
                     } else {
                         self.syntax_violation(
-                            "embedding authentification information (username or password) \
+                            "embedding authentication information (username or password) \
                             in an URL is not recommended")
                     }
                     last_at = Some((char_count, remaining.clone()))
                 },
                 '/' | '?' | '#' => break,
                 '\\' if scheme_type.is_special() => break,
                 _ => (),
             }
diff --git a/third_party/rust/url/src/quirks.rs b/third_party/rust/url/src/quirks.rs
--- a/third_party/rust/url/src/quirks.rs
+++ b/third_party/rust/url/src/quirks.rs
@@ -41,17 +41,17 @@ pub fn href(url: &Url) -> &str {
 /// Setter for https://url.spec.whatwg.org/#dom-url-href
 pub fn set_href(url: &mut Url, value: &str) -> Result<(), ParseError> {
     *url = Url::parse(value)?;
     Ok(())
 }
 
 /// Getter for https://url.spec.whatwg.org/#dom-url-origin
 pub fn origin(url: &Url) -> String {
-    url.origin().unicode_serialization()
+    url.origin().ascii_serialization()
 }
 
 /// Getter for https://url.spec.whatwg.org/#dom-url-protocol
 #[inline]
 pub fn protocol(url: &Url) -> &str {
     &url.as_str()[..url.scheme().len() + ":".len()]
 }
 
diff --git a/third_party/rust/url/tests/data.rs b/third_party/rust/url/tests/data.rs
--- a/third_party/rust/url/tests/data.rs
+++ b/third_party/rust/url/tests/data.rs
@@ -183,21 +183,17 @@ fn collect_setters<F>(add_test: &mut F) 
     setter!("hash", set_hash);
 }
 
 fn main() {
     let mut tests = Vec::new();
     {
         let mut add_one = |name: String, run: test::TestFn| {
             tests.push(test::TestDescAndFn {
-                desc: test::TestDesc {
-                    name: test::DynTestName(name),
-                    ignore: false,
-                    should_panic: test::ShouldPanic::No,
-                },
+                desc: test::TestDesc::new(test::DynTestName(name)),
                 testfn: run,
             })
         };
         collect_parsing(&mut add_one);
         collect_setters(&mut add_one);
     }
     test::test_main(&std::env::args().collect::<Vec<_>>(), tests)
 }
diff --git a/third_party/rust/url/tests/unit.rs b/third_party/rust/url/tests/unit.rs
--- a/third_party/rust/url/tests/unit.rs
+++ b/third_party/rust/url/tests/unit.rs
@@ -6,16 +6,17 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
 //! Unit tests
 
 #[macro_use]
 extern crate url;
 
+use std::ascii::AsciiExt;
 use std::borrow::Cow;
 use std::net::{Ipv4Addr, Ipv6Addr};
 use std::path::{Path, PathBuf};
 use url::{Host, HostAndPort, Url, form_urlencoded};
 
 #[test]
 fn size() {
     use std::mem::size_of;
@@ -251,16 +252,25 @@ fn test_form_serialize() {
         .append_pair("foo", "é&")
         .append_pair("bar", "")
         .append_pair("foo", "#")
         .finish();
     assert_eq!(encoded, "foo=%C3%A9%26&bar=&foo=%23");
 }
 
 #[test]
+fn form_urlencoded_custom_encoding_override() {
+    let encoded = form_urlencoded::Serializer::new(String::new())
+        .custom_encoding_override(|s| s.as_bytes().to_ascii_uppercase().into())
+        .append_pair("foo", "bar")
+        .finish();
+    assert_eq!(encoded, "FOO=BAR");
+}
+
+#[test]
 fn host_and_port_display() {
     assert_eq!(
         format!(
             "{}",
             HostAndPort{ host: Host::Domain("www.mozilla.org"), port: 80}
         ),
         "www.mozilla.org:80"
     );
diff --git a/third_party/rust/url/tests/urltestdata.json b/third_party/rust/url/tests/urltestdata.json
--- a/third_party/rust/url/tests/urltestdata.json
+++ b/third_party/rust/url/tests/urltestdata.json
@@ -3531,17 +3531,17 @@
     "base": "http://other.com/",
     "failure": true
   },
   "Basic IDN support, UTF-8 and UTF-16 input should be converted to IDN",
   {
     "input": "http://你好你好",
     "base": "http://other.com/",
     "href": "http://xn--6qqa088eba/",
-    "origin": "http://你好你好",
+    "origin": "http://xn--6qqa088eba",
     "protocol": "http:",
     "username": "",
     "password": "",
     "host": "xn--6qqa088eba",
     "hostname": "xn--6qqa088eba",
     "port": "",
     "pathname": "/",
     "search": "",
@@ -3629,16 +3629,36 @@
     "hash": ""
   },
   "Broken IPv6",
   {
     "input": "http://[google.com]",
     "base": "http://other.com/",
     "failure": true
   },
+  {
+    "input": "http://[::1.2.3.4x]",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  {
+    "input": "http://[::1.2.3.]",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  {
+    "input": "http://[::1.2.]",
+    "base": "http://other.com/",
+    "failure": true
+  },
+  {
+    "input": "http://[::1.]",
+    "base": "http://other.com/",
+    "failure": true
+  },
   "Misc Unicode",
   {
     "input": "http://foo:💩@example.com/bar",
     "base": "http://other.com/",
     "href": "http://foo:%F0%9F%92%A9@example.com/bar",
     "origin": "http://example.com",
     "protocol": "http:",
     "username": "foo",

Places

File rust140-url-P2-1.6.0.patch of Package seamonkey (Revision 844bb663198e26c71f297d876d363e90)

Places