Make percent-encoding no_std-compatible

percent_encoding/Cargo.toml

@@ -9,3 +9,7 @@ license = "MIT/Apache-2.0"
 [lib]
 test = false
 path = "lib.rs"
+
+[features]
+default = ["std"]
+std = []

percent_encoding/lib.rs

@@ -37,10 +37,14 @@
 //! assert_eq!(utf8_percent_encode("foo <bar>", FRAGMENT).to_string(), "foo%20%3Cbar%3E");
 //! ```
 
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(feature="std")]
 use std::borrow::Cow;
-use std::fmt;
-use std::slice;
-use std::str;
+#[cfg(feature="std")]
+use std::{fmt, mem, slice, str};
+#[cfg(not(feature="std"))]
+use core::{fmt, mem, slice, str};
 
 /// Represents a set of characters or bytes in the ASCII range.
 ///
@@ -63,7 +67,7 @@ type Chunk = u32;
 
 const ASCII_RANGE_LEN: usize = 0x80;
 
-const BITS_PER_CHUNK: usize = 8 * std::mem::size_of::<Chunk>();
+const BITS_PER_CHUNK: usize = 8 * mem::size_of::<Chunk>();
 
 impl AsciiSet {
     /// Called with UTF-8 bytes rather than code points.
@@ -109,7 +113,7 @@ macro_rules! static_assert {
     ($( $bool: expr, )+) => {
         fn _static_assert() {
             $(
-                let _ = std::mem::transmute::<[u8; $bool as usize], u8>;
+                let _ = mem::transmute::<[u8; $bool as usize], u8>;
             )+
         }
     }
@@ -287,6 +291,7 @@ impl<'a> fmt::Display for PercentEncode<'a> {
     }
 }
 
+#[cfg(feature="std")]
 impl<'a> From<PercentEncode<'a>> for Cow<'a, str> {
     fn from(mut iter: PercentEncode<'a>) -> Self {
         match iter.next() {
@@ -325,13 +330,15 @@ pub fn percent_decode_str(input: &str) -> PercentDecode {
 /// * Implements `Iterator<Item = u8>` and therefore has a `.collect::<Vec<u8>>()` method,
 /// * Has `decode_utf8()` and `decode_utf8_lossy()` methods.
 ///
-/// # Examples
-///
-/// ```
-/// use percent_encoding::percent_decode;
-///
-/// assert_eq!(percent_decode(b"foo%20bar%3f").decode_utf8().unwrap(), "foo bar?");
-/// ```
+#[cfg_attr(feature = "std", doc = r##"
+# Examples
+
+```
+use percent_encoding::percent_decode;
+
+assert_eq!(percent_decode(b"foo%20bar%3f").decode_utf8().unwrap(), "foo bar?");
+```
+"##)]
 #[inline]
 pub fn percent_decode(input: &[u8]) -> PercentDecode {
     PercentDecode {
@@ -372,6 +379,7 @@ impl<'a> Iterator for PercentDecode<'a> {
     }
 }
 
+#[cfg(feature="std")]
 impl<'a> From<PercentDecode<'a>> for Cow<'a, [u8]> {
     fn from(iter: PercentDecode<'a>) -> Self {
         match iter.if_any() {
@@ -383,6 +391,7 @@ impl<'a> From<PercentDecode<'a>> for Cow<'a, [u8]> {
 
 impl<'a> PercentDecode<'a> {
     /// If the percent-decoding is different from the input, return it as a new bytes vector.
+    #[cfg(feature="std")]
     fn if_any(&self) -> Option<Vec<u8>> {
         let mut bytes_iter = self.bytes.clone();
         while bytes_iter.any(|&b| b == b'%') {
@@ -402,6 +411,7 @@ impl<'a> PercentDecode<'a> {
     /// Decode the result of percent-decoding as UTF-8.
     ///
     /// This is return `Err` when the percent-decoded bytes are not well-formed in UTF-8.
+    #[cfg(feature="std")]
     pub fn decode_utf8(self) -> Result<Cow<'a, str>, str::Utf8Error> {
         match self.clone().into() {
             Cow::Borrowed(bytes) => match str::from_utf8(bytes) {
@@ -419,11 +429,13 @@ impl<'a> PercentDecode<'a> {
     ///
     /// Invalid UTF-8 percent-encoded byte sequences will be replaced � U+FFFD,
     /// the replacement character.
+    #[cfg(feature="std")]
     pub fn decode_utf8_lossy(self) -> Cow<'a, str> {
         decode_utf8_lossy(self.clone().into())
     }
 }
 
+#[cfg(feature="std")]
 fn decode_utf8_lossy(input: Cow<[u8]>) -> Cow<str> {
     match input {
         Cow::Borrowed(bytes) => String::from_utf8_lossy(bytes),