[idna] Preserve leading dots in host

A retry of servo#171

This diff changes the behavior of ToASCII step to match the spec and
prevent failures on some cases when a domain name starts with leading
dots (FULL STOPs), as requested in
servo#166.

The change in the code results in a few failures for test cases of the
Conformance Testing data provided with UTS servo#46. But, as the header of
the test data file (IdnaTest.txt) says: "If the file does not indicate
an error, then the implementation must either have an error, or must
have a matching result."

Therefore, failing on those test cases does not break conformance with
UTS servo#46, and to some level, anticipated.

As mentioned in servo#166, a feedback
is submitted for this inconsistency and the test logic can be improved
later if the data file addresses the comments.

Until then, we can throw less errors and maintain passing conformance
tests with this diff.

Author: behnam

idna/src/uts46.rs

@@ -12,6 +12,7 @@
 use self::Mapping::*;
 use punycode;
 use std::ascii::AsciiExt;
+use std::slice::Iter;
 use unicode_normalization::UnicodeNormalization;
 use unicode_normalization::char::is_combining_mark;
 use unicode_bidi::{BidiClass, bidi_class};
@@ -237,10 +238,12 @@ fn processing(domain: &str, flags: Flags, errors: &mut Vec<Error>) -> String {
     }
     let normalized: String = mapped.nfc().collect();
     let mut validated = String::new();
+    let mut first = true;
     for label in normalized.split('.') {
-        if validated.len() > 0 {
+        if !first {
             validated.push('.');
         }
+        first = false;
         if label.starts_with("xn--") {
             match punycode::decode_to_string(&label["xn--".len()..]) {
                 Some(decoded_label) => {
@@ -266,13 +269,14 @@ pub struct Flags {
 }
 
 #[derive(PartialEq, Eq, Clone, Copy, Debug)]
-enum Error {
+pub enum Error {
     PunycodeError,
     ValidityCriteria,
     DissallowedByStd3AsciiRules,
     DissallowedMappedInStd3,
     DissallowedCharacter,
     TooLongForDns,
+    TooShortForDns,
 }
 
 /// Errors recorded during UTS #46 processing.
@@ -282,14 +286,22 @@ enum Error {
 #[derive(Debug)]
 pub struct Errors(Vec<Error>);
 
+impl Errors {
+    pub fn iter(&self) -> Iter<Error> {
+        self.0.iter()
+    }
+}
+
 /// http://www.unicode.org/reports/tr46/#ToASCII
 pub fn to_ascii(domain: &str, flags: Flags) -> Result<String, Errors> {
     let mut errors = Vec::new();
     let mut result = String::new();
+    let mut first = true;
     for label in processing(domain, flags, &mut errors).split('.') {
-        if result.len() > 0 {
+        if !first {
             result.push('.');
         }
+        first = false;
         if label.is_ascii() {
             result.push_str(label);
         } else {
@@ -305,8 +317,10 @@ pub fn to_ascii(domain: &str, flags: Flags) -> Result<String, Errors> {
 
     if flags.verify_dns_length {
         let domain = if result.ends_with(".") { &result[..result.len()-1]  } else { &*result };
-        if domain.len() < 1 || domain.len() > 253 ||
-                domain.split('.').any(|label| label.len() < 1 || label.len() > 63) {
+        if domain.len() < 1 || domain.split('.').any(|label| label.len() < 1) {
+            errors.push(Error::TooShortForDns)
+        }
+        if domain.len() > 253 || domain.split('.').any(|label| label.len() > 63) {
             errors.push(Error::TooLongForDns)
         }
     }

idna/tests/uts46.rs

@@ -84,6 +84,16 @@ pub fn collect_tests<F: FnMut(String, TestFn)>(add_test: &mut F) {
                 return;
             }
 
+            if let Err(ref errors) = result {
+                if errors.iter().any(|err| *err == uts46::Error::TooShortForDns) {
+                    // Conformant implementations may produce error where test file has strings.
+                    // Test file drop all leading dots (leading empty labels), in contrast to spec.
+                    // So, we allo TooShortForDns failers on test cases.
+                    // https://github.com/servo/rust-url/issues/166
+                    return;
+                }
+            }
+
             assert!(result.is_ok(), "Couldn't parse {} | original: {} | error: {:?}",
                     source, original, result.err());
             let output = result.ok().unwrap();

tests/unit.rs

@@ -344,6 +344,13 @@ fn test_set_host() {
     assert_eq!(url.as_str(), "foobar:/hello");
 }
 
+#[test]
+// https://github.com/servo/rust-url/issues/166
+fn test_leading_dots() {
+    assert_eq!(Host::parse(".org").unwrap(), Host::Domain(".org".to_owned()));
+    assert_eq!(Url::parse("file://./foo").unwrap().domain(), Some("."));
+}
+
 // This is testing that the macro produces buildable code when invoked
 // inside both a module and a function
 #[test]