Auto merge of #432 - servo:data, r=nox

Add data-url crate

This is an implementation of https://fetch.spec.whatwg.org/#data-urls. It is independent of the `url` crate, but it seems within the scope of this repository and I didn’t feel like creating yet another repository :)

<!-- Reviewable:start -->
---
This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/rust-url/432)
<!-- Reviewable:end -->

Author: bors-servo

.travis.yml

@@ -1,19 +1,29 @@
 language: rust
-script: make test
 
 jobs:
   include:
-  - rust: nightly
-  - rust: beta
-  - rust: stable
   - rust: 1.17.0
-  - rust: nightly
-    env:
-    - WASM32=true  # just to show it in travis UI
     install:
-    - rustup target add wasm32-unknown-unknown
-    script:
-    - cargo build --target=wasm32-unknown-unknown
+    # --precise requires Cargo.lock to already exist
+    - cargo update
+    # getopts is only used in tests. Its versions 0.2.16+ don’t build on 1.17.0
+    - cargo update -p getopts --precise 0.2.15
+    # data-url uses pub(crate) which is unstable in 1.17
+    script: cargo test --all-features -p url -p idna -p percent-encoding -p url_serde
+
+  - rust: stable
+    script: cargo test --all-features --all
+
+  - rust: beta
+    script: cargo test --all-features --all
+
+  - rust: nightly
+    script: cargo test --all-features --all
+
+  - rust: nightly
+    env: TARGET=WASM32  # For job list UI
+    install: rustup target add wasm32-unknown-unknown
+    script: cargo build --all --target=wasm32-unknown-unknown
 
 notifications:
   webhooks: http://build.servo.org:54856/travis

Cargo.toml

@@ -18,7 +18,7 @@ travis-ci = { repository = "servo/rust-url" }
 appveyor = { repository = "Manishearth/rust-url" }
 
 [workspace]
-members = [".", "idna", "percent_encoding", "url_serde"]
+members = [".", "idna", "percent_encoding", "url_serde", "data-url"]
 
 [[test]]
 name = "unit"

Makefile

@@ -0,0 +1,22 @@
+[package]
+name = "data-url"
+version = "0.1.0"
+authors = ["Simon Sapin <simon.sapin@exyr.org>"]
+description = "Processing of data: URL according to WHATWG’s Fetch Standard"
+repository = "https://github.com/servo/rust-url"
+license = "MIT OR Apache-2.0"
+
+[dependencies]
+matches = "0.1"
+
+[dev-dependencies]
+rustc-test = "0.3"
+serde = {version = "1.0", features = ["derive"]}
+serde_json = "1.0"
+
+[lib]
+test = false
+
+[[test]]
+name = "wpt"
+harness = false

data-url/Cargo.toml

@@ -0,0 +1 @@
+../LICENSE-APACHE

data-url/LICENSE-APACHE

@@ -0,0 +1 @@
+../LICENSE-MIT

data-url/LICENSE-MIT

@@ -0,0 +1,21 @@
+# data-url
+
+![crates.io](https://img.shields.io/crates/v/url.svg)
+![docs.rs](https://docs.rs/data-url/)
+
+Processing of `data:` URLs in Rust according to the Fetch Standard:
+<https://fetch.spec.whatwg.org/#data-urls>
+but starting from a string rather than a parsed URL to avoid extra copies.
+
+```rust
+use data_url::{DataUrl, mime};
+//!
+let url = DataUrl::process("data:,Hello%20World!").unwrap();
+let (body, fragment) = url.decode_to_vec().unwrap();
+//!
+assert_eq!(url.mime_type().type_, "text");
+assert_eq!(url.mime_type().subtype, "plain");
+assert_eq!(url.mime_type().get_parameter("charset"), Some("US-ASCII"));
+assert_eq!(body, b"Hello World!");
+assert!(fragment.is_none());
+```

data-url/README.md

@@ -0,0 +1,168 @@
+//! <https://infra.spec.whatwg.org/#forgiving-base64-decode>
+
+#[derive(Debug)]
+pub struct InvalidBase64(InvalidBase64Details);
+
+#[derive(Debug)]
+enum InvalidBase64Details {
+    UnexpectedSymbol(u8),
+    AlphabetSymbolAfterPadding,
+    LoneAlphabetSymbol,
+    Padding,
+}
+
+#[derive(Debug)]
+pub enum DecodeError<E> {
+    InvalidBase64(InvalidBase64),
+    WriteError(E),
+}
+
+impl<E> From<InvalidBase64Details> for DecodeError<E> {
+    fn from(e: InvalidBase64Details) -> Self {
+        DecodeError::InvalidBase64(InvalidBase64(e))
+    }
+}
+
+pub(crate) enum Impossible {}
+
+impl From<DecodeError<Impossible>> for InvalidBase64 {
+    fn from(e: DecodeError<Impossible>) -> Self {
+        match e {
+            DecodeError::InvalidBase64(e) => e,
+            DecodeError::WriteError(e) => match e {}
+        }
+    }
+}
+
+/// `input` is assumed to be in an ASCII-compatible encoding
+pub fn decode_to_vec(input: &[u8]) -> Result<Vec<u8>, InvalidBase64> {
+    let mut v = Vec::new();
+    {
+        let mut decoder = Decoder::new(|bytes| Ok(v.extend_from_slice(bytes)));
+        decoder.feed(input)?;
+        decoder.finish()?;
+    }
+    Ok(v)
+}
+
+/// <https://infra.spec.whatwg.org/#forgiving-base64-decode>
+pub struct Decoder<F, E> where F: FnMut(&[u8]) -> Result<(), E> {
+    write_bytes: F,
+    bit_buffer: u32,
+    buffer_bit_length: u8,
+    padding_symbols: u8,
+}
+
+impl<F, E> Decoder<F, E> where F: FnMut(&[u8]) -> Result<(), E> {
+    pub fn new(write_bytes: F) -> Self {
+        Self {
+            write_bytes,
+            bit_buffer: 0,
+            buffer_bit_length: 0,
+            padding_symbols: 0,
+        }
+    }
+
+    /// Feed to the decoder partial input in an ASCII-compatible encoding
+    pub fn feed(&mut self, input: &[u8]) -> Result<(), DecodeError<E>> {
+        for &byte in input.iter() {
+            let value = BASE64_DECODE_TABLE[byte as usize];
+            if value < 0 {
+                // A character that’s not part of the alphabet
+
+                // Remove ASCII whitespace
+                if matches!(byte, b' ' | b'\t' | b'\n' | b'\r' | b'\x0C') {
+                    continue
+                }
+
+                if byte == b'=' {
+                    self.padding_symbols = self.padding_symbols.saturating_add(1);
+                    continue
+                }
+
+                Err(InvalidBase64Details::UnexpectedSymbol(byte))?
+            }
+            if self.padding_symbols > 0 {
+                Err(InvalidBase64Details::AlphabetSymbolAfterPadding)?
+            }
+            self.bit_buffer <<= 6;
+            self.bit_buffer |= value as u32;
+            // 18 before incrementing means we’ve just reached 24
+            if self.buffer_bit_length < 18 {
+                self.buffer_bit_length += 6;
+            } else {
+                // We’ve accumulated four times 6 bits, which equals three times 8 bits.
+                let byte_buffer = [
+                    (self.bit_buffer >> 16) as u8,
+                    (self.bit_buffer >> 8) as u8,
+                    self.bit_buffer as u8,
+                ];
+                (self.write_bytes)(&byte_buffer).map_err(DecodeError::WriteError)?;
+                self.buffer_bit_length = 0;
+                // No need to reset bit_buffer,
+                // since next time we’re only gonna read relevant bits.
+            }
+        }
+        Ok(())
+    }
+
+    /// Call this to signal the end of the input
+    pub fn finish(mut self) -> Result<(), DecodeError<E>> {
+        match (self.buffer_bit_length, self.padding_symbols) {
+            (0, 0) => {
+                // A multiple of four of alphabet symbols, and nothing else.
+            }
+            (12, 2) | (12, 0) => {
+                // A multiple of four of alphabet symbols, followed by two more symbols,
+                // optionally followed by two padding characters (which make a total multiple of four).
+                let byte_buffer = [
+                    (self.bit_buffer >> 4) as u8,
+                ];
+                (self.write_bytes)(&byte_buffer).map_err(DecodeError::WriteError)?;
+            }
+            (18, 1) | (18, 0) => {
+                // A multiple of four of alphabet symbols, followed by three more symbols,
+                // optionally followed by one padding character (which make a total multiple of four).
+                let byte_buffer = [
+                    (self.bit_buffer >> 10) as u8,
+                    (self.bit_buffer >> 2) as u8,
+                ];
+                (self.write_bytes)(&byte_buffer).map_err(DecodeError::WriteError)?;
+            }
+            (6, _) => {
+                Err(InvalidBase64Details::LoneAlphabetSymbol)?
+            }
+            _ => {
+                Err(InvalidBase64Details::Padding)?
+            }
+        }
+        Ok(())
+    }
+}
+
+
+/// Generated by `make_base64_decode_table.py` based on "Table 1: The Base 64 Alphabet"
+/// at <https://tools.ietf.org/html/rfc4648#section-4>
+///
+/// Array indices are the byte value of symbols.
+/// Array values are their positions in the base64 alphabet,
+/// or -1 for symbols not in the alphabet.
+/// The position contributes 6 bits to the decoded bytes.
+const BASE64_DECODE_TABLE: [i8; 256] = [
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63,
+    52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1,
+    -1,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
+    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1,
+    -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+    41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+    -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+];