Add trait Into(Mut)AsciiStr to replace and AsciiCast<Target=AsciiStr>

Supports converting partially, and
The error type says where and why it wen't wrong, and partial conversion is also possible.
ascii_part() is a bad name, maybe partially_into_ascii()?

Separate trait to follow std convention.

Untested.

Author: tormol

src/ascii_str.rs

@@ -1,5 +1,6 @@
 use std::{fmt, mem};
 use std::ops::{Index, IndexMut, Range, RangeTo, RangeFrom, RangeFull};
+use std::error::Error;
 use std::ascii::AsciiExt;
 
 use AsciiCast;
@@ -77,13 +78,28 @@ impl AsciiStr {
     {
         unsafe {
             if bytes.as_ref().is_ascii() {
-                Ok( mem::transmute(bytes.as_ref()) )
+                Ok( Self::from_bytes_unchecked(bytes) )
             } else {
                 Err(())
             }
         }
     }
 
+    /// Converts anything that can represent a byte slice into an `AsciiStr` without validation.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// # use ascii::AsciiStr;
+    /// let foo = unsafe{ AsciiStr::from_bytes_unchecked("foo") };
+    /// assert_eq!(foo.as_str(), "foo");
+    /// ```
+    pub unsafe fn from_bytes_unchecked<'a, B: ?Sized>(bytes: &'a B) -> &'a AsciiStr
+        where B: AsRef<[u8]>
+    {
+        mem::transmute(bytes.as_ref())
+    }
+
     /// Converts a borrowed string to a borrows ascii string.
     pub fn from_str<'a>(s: &'a str) -> Result<&'a AsciiStr, ()> {
         AsciiStr::from_bytes(s.as_bytes())
@@ -322,10 +338,181 @@ impl<'a> AsciiCast<'a> for str {
     }
 }
 
+
+/// Error returned by IntoAsciiStr
+#[derive(PartialEq)]// allows assert_eq!
+pub struct IntoAsciiStrError {
+    index: usize,
+    /// If less than 128, it was a byte >= 128
+    not_ascii: char,
+}
+
+impl fmt::Debug for IntoAsciiStrError {
+    fn fmt(&self,  fmtr: &mut fmt::Formatter) -> fmt::Result {
+        if (self.not_ascii as u32) < 128 {
+            write!(fmtr, "b'\\x{:x}' at index {}", self.not_ascii as u8 + 128, self.index)
+        } else {
+            write!(fmtr, "'{}' at index {}", self.not_ascii, self.index)
+        }
+    }
+}
+impl fmt::Display for IntoAsciiStrError {
+    fn fmt(&self,  fmtr: &mut fmt::Formatter) -> fmt::Result {
+        if (self.not_ascii as u32) < 128 {
+            write!(fmtr, "the byte \\x{:x} at index {} is not ASCII", self.not_ascii as u8 + 128, self.index)
+        } else {
+            write!(fmtr, "the character {} at index {} is not ASCII", self.not_ascii, self.index)
+        }
+    }
+}
+impl Error for IntoAsciiStrError {
+    fn description(&self) -> &'static str {
+        "one or more bytes (or chars if str) are not ASCII"
+    }
+}
+
+
+/// Trait for converting various slices into `AsciiStr`.
+pub trait IntoAsciiStr : AsciiExt {
+    /// Convert to `AsciiStr`, not doing any range asserts.
+    unsafe fn into_ascii_unchecked(&self) -> &AsciiStr;
+    /// Convert the portion from start of self that is valid ASCII to `AsciiStr`.
+    fn ascii_part(&self) -> &AsciiStr;
+    /// Convert to `AsciiStr`.
+    fn into_ascii(&self) -> Result<&AsciiStr,IntoAsciiStrError>;
+}
+/// Trait for converting various slices into `AsciiStr`.
+pub trait IntoMutAsciiStr : AsciiExt {
+    /// Convert to `AsciiStr`, not doing any range asserts.
+    unsafe fn into_ascii_mut_unchecked(&mut self) -> &mut AsciiStr;
+    /// Convert the portion from start of self that is valid ASCII to `AsciiStr`.
+    fn ascii_part_mut(&mut self) -> &mut AsciiStr;
+    /// Convert to `AsciiStr`.
+    fn into_ascii_mut(&mut self) -> Result<&mut AsciiStr,IntoAsciiStrError>;
+}
+
+#[cfg(feature = "unstable")]
+impl IntoAsciiStr for AsciiStr {
+    fn into_ascii(&self) -> Result<&AsciiStr,IntoAsciiStrError> {
+        Ok(self)
+    }
+    fn ascii_part(&self) -> &AsciiStr {
+        self
+    }
+    unsafe fn into_ascii_unchecked(&self) -> &AsciiStr {
+        self
+    }
+}
+#[cfg(feature = "unstable")]
+impl IntoMutAsciiStr for AsciiStr {
+    fn into_ascii_mut(&mut self) -> Result<&mut AsciiStr,IntoAsciiStrError> {
+        Ok(self)
+    }
+    fn ascii_part_mut(&mut self) -> &mut AsciiStr {
+        self
+    }
+    unsafe fn into_ascii_mut_unchecked(&mut self) -> &mut AsciiStr {
+        self
+    }
+}
+
+impl IntoAsciiStr for [u8] {
+    fn into_ascii(&self) -> Result<&AsciiStr,IntoAsciiStrError> {
+        match self.iter().enumerate().find(|&(_,b)| *b > 127 ) {
+            Some((index, &byte)) => Err(IntoAsciiStrError{
+                                            index: index,
+                                            not_ascii: (byte - 128) as char,
+                                        }),
+            None => unsafe{ Ok(self.into_ascii_unchecked()) },
+        }
+    }
+    fn ascii_part(&self) -> &AsciiStr {
+        let ascii = self.iter().position(|b| *b > 127 )
+                               .map(|l| &self[..l] )
+                               .unwrap_or(self);
+        unsafe{ ascii.into_ascii_unchecked() }
+    }
+    unsafe fn into_ascii_unchecked(&self) -> &AsciiStr {
+        AsciiStr::from_bytes_unchecked(self)
+    }
+}
+impl IntoMutAsciiStr for [u8] {
+    fn into_ascii_mut(&mut self) -> Result<&mut AsciiStr,IntoAsciiStrError> {
+        match self.iter().enumerate().find(|&(_,b)| *b > 127 ) {
+            Some((index, &byte)) => Err(IntoAsciiStrError{
+                                            index: index,
+                                            not_ascii: (byte - 128) as char,
+                                        }),
+            None => unsafe{ Ok(self.into_ascii_mut_unchecked()) },
+        }
+    }
+    fn ascii_part_mut(&mut self) -> &mut AsciiStr {
+        let ascii = match self.iter_mut().position(|b| *b > 127 ) {
+            Some(l) => &mut self[..l],
+            None    => self,
+        };
+        unsafe{ ascii.into_ascii_mut_unchecked() }
+    }
+    unsafe fn into_ascii_mut_unchecked(&mut self) -> &mut AsciiStr {
+        mem::transmute(self)
+    }
+}
+
+impl IntoAsciiStr for str {
+    fn into_ascii(&self) -> Result<&AsciiStr,IntoAsciiStrError> {
+        let s = self.ascii_part();
+        if s.len() == self.len() {
+            Ok(s)
+        } else {
+            Err(IntoAsciiStrError{
+                index: s.len(),
+                not_ascii: self[s.len()..].chars().next().unwrap(),
+            })
+        }
+    }
+    fn ascii_part(&self) -> &AsciiStr {
+        self.as_bytes().ascii_part()
+    }
+    unsafe fn into_ascii_unchecked(&self) -> &AsciiStr {
+        mem::transmute(self)
+    }
+}
+impl IntoMutAsciiStr for str {
+    fn into_ascii_mut(&mut self) -> Result<&mut AsciiStr,IntoAsciiStrError> {
+        match self.bytes().enumerate().find(|&(_,b)| b > 127 ) {
+            Some((index, byte)) => Err(IntoAsciiStrError{
+                                            index: index,
+                                            not_ascii: (byte - 128) as char,
+                                        }),
+            None => unsafe{ Ok(self.into_ascii_mut_unchecked()) },
+        }
+    }
+    fn ascii_part_mut(&mut self) -> &mut AsciiStr {
+        unsafe{ match self.bytes().position(|b| b > 127 ) {
+            Some(index) => self.slice_mut_unchecked(0, index).into_ascii_mut_unchecked(),
+            None => self.into_ascii_mut_unchecked(),
+        }}
+    }
+    unsafe fn into_ascii_mut_unchecked(&mut self) -> &mut AsciiStr {
+        mem::transmute(self)
+    }
+}
+
+
+
 #[cfg(test)]
 mod tests {
-    use AsciiCast;
-    use super::AsciiStr;
+    use {AsciiCast,Ascii};
+    use super::{AsciiStr,IntoAsciiStr,IntoAsciiStrError};
+
+    #[test]
+    fn into_ascii() {
+        fn generic<C:IntoAsciiStr+?Sized>(c: &C) -> Result<&AsciiStr,IntoAsciiStrError> {
+            c.into_ascii()
+        }
+        assert_eq!(generic("A"), Ok([Ascii::A].as_ref().into()));
+        assert_eq!(generic(&b"A"[..]), Ok([Ascii::A].as_ref().into()));
+    }
 
     #[test]
     fn as_str() {

src/lib.rs

@@ -23,7 +23,7 @@ use std::ascii::AsciiExt;
 
 pub use ascii::{Ascii, IntoAscii, IntoAsciiError};
 pub use ascii_string::{AsciiString, IntoAsciiString};
-pub use ascii_str::AsciiStr;
+pub use ascii_str::{AsciiStr, IntoAsciiStr, IntoMutAsciiStr, IntoAsciiStrError};
 
 /// Trait for converting into an ascii type.
 pub trait AsciiCast<'a>: AsciiExt {