nordic-dev.net/rust
nordic-dev.net/rust
2
0
Fork 0
mirror of https://github.com/rust-lang/rust.git synced 2024-10-31 22:41:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

auto merge of #19916 : SimonSapin/rust/ascii-reform, r=sfackler

Browse Source 
Implements [RFC 486](https://github.com/rust-lang/rfcs/pull/486). Fixes #19908.

* Rename `to_ascii_{lower,upper}` to `to_ascii_{lower,upper}case`, per #14401
* Remove the `Ascii` type and associated traits: `AsciiCast`, `OwnedAsciiCast`, `AsciiStr`, `IntoBytes`, and `IntoString`.
* As a replacement, add `.is_ascii()` to `AsciiExt`, and implement `AsciiExt` for `u8` and `char`.

[breaking-change]
This commit is contained in:
bors 2014-12-27 21:51:43 +00:00
commit 070ab63807
13 changed files with 148 additions and 618 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/compiletest/errors.rs
View File

@ -67,7 +67,7 @@ fn parse_expected(last_nonfollow_error: Option<uint>,
re: &Regex) -> Option<(WhichLine, ExpectedError)> {
re.captures(line).and_then(|caps| {
let adjusts = caps.name("adjusts").unwrap_or("").len();
let kind = caps.name("kind").unwrap_or("").to_ascii_lower();
let kind = caps.name("kind").unwrap_or("").to_ascii_lowercase();
let msg = caps.name("msg").unwrap_or("").trim().to_string();
let follow = caps.name("follow").unwrap_or("").len() > 0;

17
src/compiletest/runtest.rs
View File

@ -21,6 +21,8 @@ use util::logv;
#[cfg(target_os = "windows")]
use util;
#[cfg(target_os = "windows")]
use std::ascii::AsciiExt;
use std::io::File;
use std::io::fs::PathExtensions;
use std::io::fs;
@ -985,22 +987,9 @@ fn check_expected_errors(expected_errors: Vec<errors::ExpectedError> ,
format!("{}:{}:", testfile.display(), ee.line)
}).collect::<Vec<String> >();
#[cfg(target_os = "windows")]
fn to_lower( s : &str ) -> String {
let i = s.chars();
let c : Vec<char> = i.map( |c| {
if c.is_ascii() {
c.to_ascii().to_lowercase().as_char()
} else {
c
}
} ).collect();
String::from_chars(c.as_slice())
}
#[cfg(windows)]
fn prefix_matches( line : &str, prefix : &str ) -> bool {
to_lower(line).as_slice().starts_with(to_lower(prefix).as_slice())
line.to_ascii_lowercase().starts_with(prefix.to_ascii_lowercase().as_slice())
}
#[cfg(unix)]

2
src/librustc/lint/mod.rs
View File

@ -68,7 +68,7 @@ pub struct Lint {
impl Lint {
/// Get the lint's name, with ASCII letters converted to lowercase.
pub fn name_lower(&self) -> String {
self.name.to_ascii_lower()
self.name.to_ascii_lowercase()
}
}

2
src/librustdoc/html/markdown.rs
View File

@ -235,7 +235,7 @@ pub fn render(w: &mut fmt::Formatter, s: &str, print_toc: bool) -> fmt::Result {
};
// Transform the contents of the header into a hyphenated string
let id = s.words().map(|s| s.to_ascii_lower())
let id = s.words().map(|s| s.to_ascii_lowercase())
.collect::<Vec<String>>().connect("-");
// This is a terrible hack working around how hoedown gives us rendered

687
src/libstd/ascii.rs
View File

@ -16,422 +16,45 @@
#![allow(deprecated)]
use core::kinds::Sized;
use fmt;
use iter::IteratorExt;
use mem;
use ops::FnMut;
use option::Option;
use option::Option::{Some, None};
use slice::{SliceExt, AsSlice};
use str::{Str, StrExt};
use string::{String, IntoString};
use slice::SliceExt;
use str::StrExt;
use string::String;
use vec::Vec;
/// Datatype to hold one ascii character. It wraps a `u8`, with the highest bit always zero.
#[deriving(Clone, Copy, PartialEq, PartialOrd, Ord, Eq, Hash)]
pub struct Ascii { chr: u8 }
impl Ascii {
/// Converts an ascii character into a `u8`.
#[inline]
#[unstable = "recently renamed"]
pub fn as_byte(&self) -> u8 {
self.chr
}
/// Deprecated: use `as_byte` instead.
#[deprecated = "use as_byte"]
pub fn to_byte(self) -> u8 {
self.as_byte()
}
/// Converts an ascii character into a `char`.
#[inline]
#[unstable = "recently renamed"]
pub fn as_char(&self) -> char {
self.chr as char
}
/// Deprecated: use `as_char` instead.
#[deprecated = "use as_char"]
pub fn to_char(self) -> char {
self.as_char()
}
/// Convert to lowercase.
#[inline]
#[stable]
pub fn to_lowercase(&self) -> Ascii {
Ascii{chr: ASCII_LOWER_MAP[self.chr as uint]}
}
/// Convert to uppercase.
#[inline]
#[stable]
pub fn to_uppercase(&self) -> Ascii {
Ascii{chr: ASCII_UPPER_MAP[self.chr as uint]}
}
/// Compares two ascii characters of equality, ignoring case.
#[inline]
#[deprecated = "normalize with to_lowercase"]
pub fn eq_ignore_case(self, other: Ascii) -> bool {
ASCII_LOWER_MAP[self.chr as uint] == ASCII_LOWER_MAP[other.chr as uint]
}
// the following methods are like ctype, and the implementation is inspired by musl
/// Check if the character is a letter (a-z, A-Z)
#[inline]
#[stable]
pub fn is_alphabetic(&self) -> bool {
(self.chr >= 0x41 && self.chr <= 0x5A) || (self.chr >= 0x61 && self.chr <= 0x7A)
}
/// Check if the character is a number (0-9)
#[inline]
#[unstable = "may be renamed"]
pub fn is_digit(&self) -> bool {
self.chr >= 0x30 && self.chr <= 0x39
}
/// Check if the character is a letter or number
#[inline]
#[stable]
pub fn is_alphanumeric(&self) -> bool {
self.is_alphabetic() || self.is_digit()
}
/// Check if the character is a space or horizontal tab
#[inline]
#[experimental = "likely to be removed"]
pub fn is_blank(&self) -> bool {
self.chr == b' ' || self.chr == b'\t'
}
/// Check if the character is a control character
#[inline]
#[stable]
pub fn is_control(&self) -> bool {
self.chr < 0x20 || self.chr == 0x7F
}
/// Checks if the character is printable (except space)
#[inline]
#[experimental = "unsure about naming, or whether this is needed"]
pub fn is_graph(&self) -> bool {
(self.chr - 0x21) < 0x5E
}
/// Checks if the character is printable (including space)
#[inline]
#[unstable = "unsure about naming"]
pub fn is_print(&self) -> bool {
(self.chr - 0x20) < 0x5F
}
/// Checks if the character is alphabetic and lowercase
#[inline]
#[stable]
pub fn is_lowercase(&self) -> bool {
(self.chr - b'a') < 26
}
/// Checks if the character is alphabetic and uppercase
#[inline]
#[stable]
pub fn is_uppercase(&self) -> bool {
(self.chr - b'A') < 26
}
/// Checks if the character is punctuation
#[inline]
#[stable]
pub fn is_punctuation(&self) -> bool {
self.is_graph() && !self.is_alphanumeric()
}
/// Checks if the character is a valid hex digit
#[inline]
#[stable]
pub fn is_hex(&self) -> bool {
self.is_digit() || ((self.chr | 32u8) - b'a') < 6
}
}
impl<'a> fmt::Show for Ascii {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
(self.chr as char).fmt(f)
}
}
/// Trait for converting into an ascii type.
#[experimental = "may be replaced by generic conversion traits"]
pub trait AsciiCast<T> for Sized? {
/// Convert to an ascii type, panic on non-ASCII input.
#[inline]
fn to_ascii(&self) -> T {
assert!(self.is_ascii());
unsafe {self.to_ascii_nocheck()}
}
/// Convert to an ascii type, return None on non-ASCII input.
#[inline]
fn to_ascii_opt(&self) -> Option<T> {
if self.is_ascii() {
Some(unsafe { self.to_ascii_nocheck() })
} else {
None
}
}
/// Convert to an ascii type, not doing any range asserts
unsafe fn to_ascii_nocheck(&self) -> T;
/// Check if convertible to ascii
fn is_ascii(&self) -> bool;
}
#[experimental = "may be replaced by generic conversion traits"]
impl<'a> AsciiCast<&'a[Ascii]> for [u8] {
#[inline]
unsafe fn to_ascii_nocheck(&self) -> &'a[Ascii] {
mem::transmute(self)
}
#[inline]
fn is_ascii(&self) -> bool {
for b in self.iter() {
if !b.is_ascii() { return false; }
}
true
}
}
#[experimental = "may be replaced by generic conversion traits"]
impl<'a> AsciiCast<&'a [Ascii]> for str {
#[inline]
unsafe fn to_ascii_nocheck(&self) -> &'a [Ascii] {
mem::transmute(self)
}
#[inline]
fn is_ascii(&self) -> bool {
self.bytes().all(|b| b.is_ascii())
}
}
#[experimental = "may be replaced by generic conversion traits"]
impl AsciiCast<Ascii> for u8 {
#[inline]
unsafe fn to_ascii_nocheck(&self) -> Ascii {
Ascii{ chr: *self }
}
#[inline]
fn is_ascii(&self) -> bool {
*self & 128 == 0u8
}
}
#[experimental = "may be replaced by generic conversion traits"]
impl AsciiCast<Ascii> for char {
#[inline]
unsafe fn to_ascii_nocheck(&self) -> Ascii {
Ascii{ chr: *self as u8 }
}
#[inline]
fn is_ascii(&self) -> bool {
*self as u32 - ('\x7F' as u32 & *self as u32) == 0
}
}
/// Trait for copyless casting to an ascii vector.
#[experimental = "may be replaced by generic conversion traits"]
pub trait OwnedAsciiCast {
/// Check if convertible to ascii
fn is_ascii(&self) -> bool;
/// Take ownership and cast to an ascii vector.
/// # Panics
///
/// Panic on non-ASCII input.
#[inline]
fn into_ascii(self) -> Vec<Ascii> {
assert!(self.is_ascii());
unsafe {self.into_ascii_nocheck()}
}
/// Take ownership and cast to an ascii vector. Return None on non-ASCII input.
#[inline]
fn into_ascii_opt(self) -> Option<Vec<Ascii>> {
if self.is_ascii() {
Some(unsafe { self.into_ascii_nocheck() })
} else {
None
}
}
/// Take ownership and cast to an ascii vector.
/// Does not perform validation checks.
unsafe fn into_ascii_nocheck(self) -> Vec<Ascii>;
}
#[experimental = "may be replaced by generic conversion traits"]
impl OwnedAsciiCast for String {
#[inline]
fn is_ascii(&self) -> bool {
self.as_slice().is_ascii()
}
#[inline]
unsafe fn into_ascii_nocheck(self) -> Vec<Ascii> {
self.into_bytes().into_ascii_nocheck()
}
}
#[experimental = "may be replaced by generic conversion traits"]
impl OwnedAsciiCast for Vec<u8> {
#[inline]
fn is_ascii(&self) -> bool {
self.as_slice().is_ascii()
}
#[inline]
unsafe fn into_ascii_nocheck(self) -> Vec<Ascii> {
let v = Vec::from_raw_parts(self.as_ptr() as *mut Ascii,
self.len(),
self.capacity());
// We forget `self` to avoid freeing it at the end of the scope
// Otherwise, the returned `Vec` would point to freed memory
mem::forget(self);
v
}
}
/// Trait for converting an ascii type to a string. Needed to convert
/// `&[Ascii]` to `&str`.
#[experimental = "may be replaced by generic conversion traits"]
pub trait AsciiStr for Sized? {
/// Convert to a string.
fn as_str_ascii<'a>(&'a self) -> &'a str;
/// Deprecated: use `to_lowercase`
#[deprecated="renamed `to_lowercase`"]
fn to_lower(&self) -> Vec<Ascii>;
/// Convert to vector representing a lower cased ascii string.
#[deprecated = "use iterators instead"]
fn to_lowercase(&self) -> Vec<Ascii>;
/// Deprecated: use `to_uppercase`
#[deprecated="renamed `to_uppercase`"]
fn to_upper(&self) -> Vec<Ascii>;
/// Convert to vector representing a upper cased ascii string.
#[deprecated = "use iterators instead"]
fn to_uppercase(&self) -> Vec<Ascii>;
/// Compares two Ascii strings ignoring case.
#[deprecated = "use iterators instead"]
fn eq_ignore_case(&self, other: &[Ascii]) -> bool;
}
#[experimental = "may be replaced by generic conversion traits"]
impl AsciiStr for [Ascii] {
#[inline]
fn as_str_ascii<'a>(&'a self) -> &'a str {
unsafe { mem::transmute(self) }
}
#[inline]
fn to_lower(&self) -> Vec<Ascii> {
self.to_lowercase()
}
#[inline]
fn to_lowercase(&self) -> Vec<Ascii> {
self.iter().map(|a| a.to_lowercase()).collect()
}
#[inline]
fn to_upper(&self) -> Vec<Ascii> {
self.to_uppercase()
}
#[inline]
fn to_uppercase(&self) -> Vec<Ascii> {
self.iter().map(|a| a.to_uppercase()).collect()
}
#[inline]
fn eq_ignore_case(&self, other: &[Ascii]) -> bool {
self.iter().zip(other.iter()).all(|(&a, &b)| a.eq_ignore_case(b))
}
}
impl IntoString for Vec<Ascii> {
#[inline]
fn into_string(self) -> String {
unsafe { String::from_utf8_unchecked(self.into_bytes()) }
}
}
/// Trait to convert to an owned byte vector by consuming self
#[experimental = "may be replaced by generic conversion traits"]
pub trait IntoBytes {
/// Converts to an owned byte vector by consuming self
fn into_bytes(self) -> Vec<u8>;
}
#[experimental = "may be replaced by generic conversion traits"]
impl IntoBytes for Vec<Ascii> {
fn into_bytes(self) -> Vec<u8> {
unsafe {
let v = Vec::from_raw_parts(self.as_ptr() as *mut u8,
self.len(),
self.capacity());
// We forget `self` to avoid freeing it at the end of the scope
// Otherwise, the returned `Vec` would point to freed memory
mem::forget(self);
v
}
}
}
/// Extension methods for ASCII-subset only operations on owned strings
#[experimental = "would prefer to do this in a more general way"]
pub trait OwnedAsciiExt {
/// Convert the string to ASCII upper case:
/// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z',
/// but non-ASCII letters are unchanged.
fn into_ascii_upper(self) -> Self;
fn into_ascii_uppercase(self) -> Self;
/// Convert the string to ASCII lower case:
/// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z',
/// but non-ASCII letters are unchanged.
fn into_ascii_lower(self) -> Self;
fn into_ascii_lowercase(self) -> Self;
}
/// Extension methods for ASCII-subset only operations on string slices
#[experimental = "would prefer to do this in a more general way"]
pub trait AsciiExt<T> for Sized? {
pub trait AsciiExt<T = Self> for Sized? {
/// Check if within the ASCII range.
fn is_ascii(&self) -> bool;
/// Makes a copy of the string in ASCII upper case:
/// ASCII letters 'a' to 'z' are mapped to 'A' to 'Z',
/// but non-ASCII letters are unchanged.
fn to_ascii_upper(&self) -> T;
fn to_ascii_uppercase(&self) -> T;
/// Makes a copy of the string in ASCII lower case:
/// ASCII letters 'A' to 'Z' are mapped to 'a' to 'z',
/// but non-ASCII letters are unchanged.
fn to_ascii_lower(&self) -> T;
fn to_ascii_lowercase(&self) -> T;
/// Check that two strings are an ASCII case-insensitive match.
/// Same as `to_ascii_lower(a) == to_ascii_lower(b)`,
/// Same as `to_ascii_lowercase(a) == to_ascii_lower(b)`,
/// but without allocating and copying temporary strings.
fn eq_ignore_ascii_case(&self, other: &Self) -> bool;
}
@ -439,15 +62,20 @@ pub trait AsciiExt<T> for Sized? {
#[experimental = "would prefer to do this in a more general way"]
impl AsciiExt<String> for str {
#[inline]
fn to_ascii_upper(&self) -> String {
// Vec<u8>::to_ascii_upper() preserves the UTF-8 invariant.
unsafe { String::from_utf8_unchecked(self.as_bytes().to_ascii_upper()) }
fn is_ascii(&self) -> bool {
self.bytes().all(|b| b.is_ascii())
}
#[inline]
fn to_ascii_lower(&self) -> String {
// Vec<u8>::to_ascii_lower() preserves the UTF-8 invariant.
unsafe { String::from_utf8_unchecked(self.as_bytes().to_ascii_lower()) }
fn to_ascii_uppercase(&self) -> String {
// Vec<u8>::to_ascii_uppercase() preserves the UTF-8 invariant.
unsafe { String::from_utf8_unchecked(self.as_bytes().to_ascii_uppercase()) }
}
#[inline]
fn to_ascii_lowercase(&self) -> String {
// Vec<u8>::to_ascii_lowercase() preserves the UTF-8 invariant.
unsafe { String::from_utf8_unchecked(self.as_bytes().to_ascii_lowercase()) }
}
#[inline]
@ -459,60 +87,117 @@ impl AsciiExt<String> for str {
#[experimental = "would prefer to do this in a more general way"]
impl OwnedAsciiExt for String {
#[inline]
fn into_ascii_upper(self) -> String {
// Vec<u8>::into_ascii_upper() preserves the UTF-8 invariant.
unsafe { String::from_utf8_unchecked(self.into_bytes().into_ascii_upper()) }
fn into_ascii_uppercase(self) -> String {
// Vec<u8>::into_ascii_uppercase() preserves the UTF-8 invariant.
unsafe { String::from_utf8_unchecked(self.into_bytes().into_ascii_uppercase()) }
}
#[inline]
fn into_ascii_lower(self) -> String {
// Vec<u8>::into_ascii_lower() preserves the UTF-8 invariant.
unsafe { String::from_utf8_unchecked(self.into_bytes().into_ascii_lower()) }
fn into_ascii_lowercase(self) -> String {
// Vec<u8>::into_ascii_lowercase() preserves the UTF-8 invariant.
unsafe { String::from_utf8_unchecked(self.into_bytes().into_ascii_lowercase()) }
}
}
#[experimental = "would prefer to do this in a more general way"]
impl AsciiExt<Vec<u8>> for [u8] {
#[inline]
fn to_ascii_upper(&self) -> Vec<u8> {
self.iter().map(|&byte| ASCII_UPPER_MAP[byte as uint]).collect()
fn is_ascii(&self) -> bool {
self.iter().all(|b| b.is_ascii())
}
#[inline]
fn to_ascii_lower(&self) -> Vec<u8> {
self.iter().map(|&byte| ASCII_LOWER_MAP[byte as uint]).collect()
fn to_ascii_uppercase(&self) -> Vec<u8> {
self.iter().map(|b| b.to_ascii_uppercase()).collect()
}
#[inline]
fn to_ascii_lowercase(&self) -> Vec<u8> {
self.iter().map(|b| b.to_ascii_lowercase()).collect()
}
#[inline]
fn eq_ignore_ascii_case(&self, other: &[u8]) -> bool {
self.len() == other.len() &&
self.iter().zip(other.iter()).all(
|(byte_self, byte_other)| {
ASCII_LOWER_MAP[*byte_self as uint] ==
ASCII_LOWER_MAP[*byte_other as uint]
})
self.iter().zip(other.iter()).all(|(a, b)| {
a.eq_ignore_ascii_case(b)
})
}
}
#[experimental = "would prefer to do this in a more general way"]
impl OwnedAsciiExt for Vec<u8> {
#[inline]
fn into_ascii_upper(mut self) -> Vec<u8> {
fn into_ascii_uppercase(mut self) -> Vec<u8> {
for byte in self.iter_mut() {
*byte = ASCII_UPPER_MAP[*byte as uint];
*byte = byte.to_ascii_uppercase();
}
self
}
#[inline]
fn into_ascii_lower(mut self) -> Vec<u8> {
fn into_ascii_lowercase(mut self) -> Vec<u8> {
for byte in self.iter_mut() {
*byte = ASCII_LOWER_MAP[*byte as uint];
*byte = byte.to_ascii_lowercase();
}
self
}
}
#[experimental = "would prefer to do this in a more general way"]
impl AsciiExt for u8 {
#[inline]
fn is_ascii(&self) -> bool {
*self & 128 == 0u8
}
#[inline]
fn to_ascii_uppercase(&self) -> u8 {
ASCII_UPPERCASE_MAP[*self as uint]
}
#[inline]
fn to_ascii_lowercase(&self) -> u8 {
ASCII_LOWERCASE_MAP[*self as uint]
}
#[inline]
fn eq_ignore_ascii_case(&self, other: &u8) -> bool {
self.to_ascii_lowercase() == other.to_ascii_lowercase()
}
}
#[experimental = "would prefer to do this in a more general way"]
impl AsciiExt for char {
#[inline]
fn is_ascii(&self) -> bool {
*self as u32 <= 0x7F
}
#[inline]
fn to_ascii_uppercase(&self) -> char {
if self.is_ascii() {
(*self as u8).to_ascii_uppercase() as char
} else {
*self
}
}
#[inline]
fn to_ascii_lowercase(&self) -> char {
if self.is_ascii() {
(*self as u8).to_ascii_lowercase() as char
} else {
*self
}
}
#[inline]
fn eq_ignore_ascii_case(&self, other: &char) -> bool {
self.to_ascii_lowercase() == other.to_ascii_lowercase()
}
}
/// Returns a 'default' ASCII and C++11-like literal escape of a `u8`
///
/// The default is chosen with a bias toward producing literals that are
@ -549,7 +234,7 @@ pub fn escape_default<F>(c: u8, mut f: F) where
}
}
static ASCII_LOWER_MAP: [u8, ..256] = [
static ASCII_LOWERCASE_MAP: [u8, ..256] = [
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
@ -588,7 +273,7 @@ static ASCII_LOWER_MAP: [u8, ..256] = [
0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff,
];
static ASCII_UPPER_MAP: [u8, ..256] = [
static ASCII_UPPERCASE_MAP: [u8, ..256] = [
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
@ -634,65 +319,14 @@ mod tests {
use prelude::*;
use char::from_u32;
macro_rules! v2ascii {
( [$($e:expr),*]) => (&[$(Ascii{chr:$e}),*]);
(&[$($e:expr),*]) => (&[$(Ascii{chr:$e}),*]);
}
macro_rules! vec2ascii {
($($e:expr),*) => ([$(Ascii{chr:$e}),*].to_vec());
}
#[test]
fn test_ascii() {
assert_eq!(65u8.to_ascii().to_byte(), 65u8);
assert_eq!(65u8.to_ascii().to_char(), 'A');
assert_eq!('A'.to_ascii().to_char(), 'A');
assert_eq!('A'.to_ascii().to_byte(), 65u8);
assert_eq!('A'.to_ascii().to_lowercase().to_char(), 'a');
assert_eq!('Z'.to_ascii().to_lowercase().to_char(), 'z');
assert_eq!('a'.to_ascii().to_uppercase().to_char(), 'A');
assert_eq!('z'.to_ascii().to_uppercase().to_char(), 'Z');
assert_eq!('@'.to_ascii().to_lowercase().to_char(), '@');
assert_eq!('['.to_ascii().to_lowercase().to_char(), '[');
assert_eq!('`'.to_ascii().to_uppercase().to_char(), '`');
assert_eq!('{'.to_ascii().to_uppercase().to_char(), '{');
assert!('0'.to_ascii().is_digit());
assert!('9'.to_ascii().is_digit());
assert!(!'/'.to_ascii().is_digit());
assert!(!':'.to_ascii().is_digit());
assert!((0x1fu8).to_ascii().is_control());
assert!(!' '.to_ascii().is_control());
assert!((0x7fu8).to_ascii().is_control());
assert!("banana".chars().all(|c| c.is_ascii()));
assert!(!"ประเทศไทย中华Việt Nam".chars().all(|c| c.is_ascii()));
}
#[test]
fn test_ascii_vec() {
let test = &[40u8, 32u8, 59u8];
let b: &[_] = v2ascii!([40, 32, 59]);
assert_eq!(test.to_ascii(), b);
assert_eq!("( ;".to_ascii(), b);
let v = vec![40u8, 32u8, 59u8];
assert_eq!(v.to_ascii(), b);
assert_eq!("( ;".to_string().to_ascii(), b);
assert_eq!("abCDef&?#".to_ascii().to_lowercase().into_string(), "abcdef&?#");
assert_eq!("abCDef&?#".to_ascii().to_uppercase().into_string(), "ABCDEF&?#");
assert_eq!("".to_ascii().to_lowercase().into_string(), "");
assert_eq!("YMCA".to_ascii().to_lowercase().into_string(), "ymca");
let mixed = "abcDEFxyz:.;".to_ascii();
assert_eq!(mixed.to_uppercase().into_string(), "ABCDEFXYZ:.;");
assert!("aBcDeF&?#".to_ascii().eq_ignore_case("AbCdEf&?#".to_ascii()));
assert!("".is_ascii());
assert!("a".is_ascii());
assert!(!"\u{2009}".is_ascii());
@ -700,139 +334,64 @@ mod tests {
}
#[test]
fn test_ascii_vec_ng() {
assert_eq!("abCDef&?#".to_ascii().to_lowercase().into_string(), "abcdef&?#");
assert_eq!("abCDef&?#".to_ascii().to_uppercase().into_string(), "ABCDEF&?#");
assert_eq!("".to_ascii().to_lowercase().into_string(), "");
assert_eq!("YMCA".to_ascii().to_lowercase().into_string(), "ymca");
let mixed = "abcDEFxyz:.;".to_ascii();
assert_eq!(mixed.to_uppercase().into_string(), "ABCDEFXYZ:.;");
}
#[test]
fn test_owned_ascii_vec() {
assert_eq!(("( ;".to_string()).into_ascii(), vec2ascii![40, 32, 59]);
assert_eq!((vec![40u8, 32u8, 59u8]).into_ascii(), vec2ascii![40, 32, 59]);
}
#[test]
fn test_ascii_as_str() {
let v = v2ascii!([40, 32, 59]);
assert_eq!(v.as_str_ascii(), "( ;");
}
#[test]
fn test_ascii_into_string() {
assert_eq!(vec2ascii![40, 32, 59].into_string(), "( ;");
assert_eq!(vec2ascii!(40, 32, 59).into_string(), "( ;");
}
#[test]
fn test_ascii_to_bytes() {
assert_eq!(vec2ascii![40, 32, 59].into_bytes(), vec![40u8, 32u8, 59u8]);
}
#[test] #[should_fail]
fn test_ascii_vec_panic_u8_slice() { (&[127u8, 128u8, 255u8]).to_ascii(); }
#[test] #[should_fail]
fn test_ascii_vec_panic_str_slice() { "zoä华".to_ascii(); }
#[test] #[should_fail]
fn test_ascii_panic_u8_slice() { 255u8.to_ascii(); }
#[test] #[should_fail]
fn test_ascii_panic_char_slice() { 'λ'.to_ascii(); }
#[test]
fn test_opt() {
assert_eq!(65u8.to_ascii_opt(), Some(Ascii { chr: 65u8 }));
assert_eq!(255u8.to_ascii_opt(), None);
assert_eq!('A'.to_ascii_opt(), Some(Ascii { chr: 65u8 }));
assert_eq!('λ'.to_ascii_opt(), None);
assert_eq!("zoä华".to_ascii_opt(), None);
let test1 = &[127u8, 128u8, 255u8];
assert_eq!((test1).to_ascii_opt(), None);
let v = [40u8, 32u8, 59u8];
let v2: &[_] = v2ascii!(&[40, 32, 59]);
assert_eq!(v.to_ascii_opt(), Some(v2));
let v = [127u8, 128u8, 255u8];
assert_eq!(v.to_ascii_opt(), None);
let v = "( ;";
assert_eq!(v.to_ascii_opt(), Some(v2));
assert_eq!("zoä华".to_ascii_opt(), None);
assert_eq!((vec![40u8, 32u8, 59u8]).into_ascii_opt(), Some(vec2ascii![40, 32, 59]));
assert_eq!((vec![127u8, 128u8, 255u8]).into_ascii_opt(), None);
assert_eq!(("( ;".to_string()).into_ascii_opt(), Some(vec2ascii![40, 32, 59]));
assert_eq!(("zoä华".to_string()).into_ascii_opt(), None);
}
#[test]
fn test_to_ascii_upper() {
assert_eq!("url()URL()uRl()ürl".to_ascii_upper(), "URL()URL()URL()üRL");
assert_eq!("hıKß".to_ascii_upper(), "HıKß");
fn test_to_ascii_uppercase() {
assert_eq!("url()URL()uRl()ürl".to_ascii_uppercase(), "URL()URL()URL()üRL");
assert_eq!("hıKß".to_ascii_uppercase(), "HıKß");
let mut i = 0;
while i <= 500 {
let upper = if 'a' as u32 <= i && i <= 'z' as u32 { i + 'A' as u32 - 'a' as u32 }
else { i };
assert_eq!((from_u32(i).unwrap()).to_string().to_ascii_upper(),
assert_eq!((from_u32(i).unwrap()).to_string().to_ascii_uppercase(),
(from_u32(upper).unwrap()).to_string());
i += 1;
}
}
#[test]
fn test_to_ascii_lower() {
assert_eq!("url()URL()uRl()Ürl".to_ascii_lower(), "url()url()url()Ürl");
fn test_to_ascii_lowercase() {
assert_eq!("url()URL()uRl()Ürl".to_ascii_lowercase(), "url()url()url()Ürl");
// Dotted capital I, Kelvin sign, Sharp S.
assert_eq!("HİKß".to_ascii_lower(), "hİKß");
assert_eq!("HİKß".to_ascii_lowercase(), "hİKß");
let mut i = 0;
while i <= 500 {
let lower = if 'A' as u32 <= i && i <= 'Z' as u32 { i + 'a' as u32 - 'A' as u32 }
else { i };
assert_eq!((from_u32(i).unwrap()).to_string().to_ascii_lower(),
assert_eq!((from_u32(i).unwrap()).to_string().to_ascii_lowercase(),
(from_u32(lower).unwrap()).to_string());
i += 1;
}
}
#[test]
fn test_into_ascii_upper() {
assert_eq!(("url()URL()uRl()ürl".to_string()).into_ascii_upper(),
fn test_into_ascii_uppercase() {
assert_eq!(("url()URL()uRl()ürl".to_string()).into_ascii_uppercase(),
"URL()URL()URL()üRL".to_string());
assert_eq!(("hıKß".to_string()).into_ascii_upper(), "HıKß");
assert_eq!(("hıKß".to_string()).into_ascii_uppercase(), "HıKß");
let mut i = 0;
while i <= 500 {
let upper = if 'a' as u32 <= i && i <= 'z' as u32 { i + 'A' as u32 - 'a' as u32 }
else { i };
assert_eq!((from_u32(i).unwrap()).to_string().into_ascii_upper(),
assert_eq!((from_u32(i).unwrap()).to_string().into_ascii_uppercase(),
(from_u32(upper).unwrap()).to_string());
i += 1;
}
}
#[test]
fn test_into_ascii_lower() {
assert_eq!(("url()URL()uRl()Ürl".to_string()).into_ascii_lower(),
fn test_into_ascii_lowercase() {
assert_eq!(("url()URL()uRl()Ürl".to_string()).into_ascii_lowercase(),
"url()url()url()Ürl");
// Dotted capital I, Kelvin sign, Sharp S.
assert_eq!(("HİKß".to_string()).into_ascii_lower(), "hİKß");
assert_eq!(("HİKß".to_string()).into_ascii_lowercase(), "hİKß");
let mut i = 0;
while i <= 500 {
let lower = if 'A' as u32 <= i && i <= 'Z' as u32 { i + 'a' as u32 - 'A' as u32 }
else { i };
assert_eq!((from_u32(i).unwrap()).to_string().into_ascii_lower(),
assert_eq!((from_u32(i).unwrap()).to_string().into_ascii_lowercase(),
(from_u32(lower).unwrap()).to_string());
i += 1;
}
@ -858,16 +417,4 @@ mod tests {
i += 1;
}
}
#[test]
fn test_to_string() {
let s = Ascii{ chr: b't' }.to_string();
assert_eq!(s, "t");
}
#[test]
fn test_show() {
let c = Ascii { chr: b't' };
assert_eq!(format!("{}", c), "t");
}
}

28
src/libstd/path/windows.rs
View File

@ -14,7 +14,7 @@
use self::PathPrefix::*;
use ascii::AsciiCast;
use ascii::AsciiExt;
use c_str::{CString, ToCStr};
use clone::Clone;
use cmp::{PartialEq, Eq, PartialOrd, Ord, Ordering};
@ -237,10 +237,10 @@ impl GenericPathUnsafe for Path {
let repr = me.repr[];
match me.prefix {
Some(DiskPrefix) => {
repr.as_bytes()[0] == path.as_bytes()[0].to_ascii().to_uppercase().as_byte()
repr.as_bytes()[0] == path.as_bytes()[0].to_ascii_uppercase()
}
Some(VerbatimDiskPrefix) => {
repr.as_bytes()[4] == path.as_bytes()[0].to_ascii().to_uppercase().as_byte()
repr.as_bytes()[4] == path.as_bytes()[0].to_ascii_uppercase()
}
_ => false
}
@ -673,17 +673,17 @@ impl Path {
match (self.prefix, other.prefix) {
(Some(DiskPrefix), Some(VerbatimDiskPrefix)) => {
self.is_absolute() &&
s_repr.as_bytes()[0].to_ascii().to_lowercase() ==
o_repr.as_bytes()[4].to_ascii().to_lowercase()
s_repr.as_bytes()[0].to_ascii_lowercase() ==
o_repr.as_bytes()[4].to_ascii_lowercase()
}
(Some(VerbatimDiskPrefix), Some(DiskPrefix)) => {
other.is_absolute() &&
s_repr.as_bytes()[4].to_ascii().to_lowercase() ==
o_repr.as_bytes()[0].to_ascii().to_lowercase()
s_repr.as_bytes()[4].to_ascii_lowercase() ==
o_repr.as_bytes()[0].to_ascii_lowercase()
}
(Some(VerbatimDiskPrefix), Some(VerbatimDiskPrefix)) => {
s_repr.as_bytes()[4].to_ascii().to_lowercase() ==
o_repr.as_bytes()[4].to_ascii().to_lowercase()
s_repr.as_bytes()[4].to_ascii_lowercase() ==
o_repr.as_bytes()[4].to_ascii_lowercase()
}
(Some(UNCPrefix(_,_)), Some(VerbatimUNCPrefix(_,_))) => {
s_repr[2..self.prefix_len()] == o_repr[8..other.prefix_len()]
@ -750,7 +750,7 @@ impl Path {
let mut s = String::from_str(s[0..len]);
unsafe {
let v = s.as_mut_vec();
v[0] = (*v)[0].to_ascii().to_uppercase().as_byte();
v[0] = (*v)[0].to_ascii_uppercase();
}
if is_abs {
// normalize C:/ to C:\
@ -765,7 +765,7 @@ impl Path {
let mut s = String::from_str(s[0..len]);
unsafe {
let v = s.as_mut_vec();
v[4] = (*v)[4].to_ascii().to_uppercase().as_byte();
v[4] = (*v)[4].to_ascii_uppercase();
}
Some(s)
}
@ -786,14 +786,12 @@ impl Path {
let mut s = String::with_capacity(n);
match prefix {
Some(DiskPrefix) => {
s.push(prefix_.as_bytes()[0].to_ascii()
.to_uppercase().as_char());
s.push(prefix_.as_bytes()[0].to_ascii_uppercase() as char);
s.push(':');
}
Some(VerbatimDiskPrefix) => {
s.push_str(prefix_[0..4]);
s.push(prefix_.as_bytes()[4].to_ascii()
.to_uppercase().as_char());
s.push(prefix_.as_bytes()[4].to_ascii_uppercase() as char);
s.push_str(prefix_[5..]);
}
Some(UNCPrefix(a,b)) => {

2
src/libstd/prelude.rs
View File

@ -56,8 +56,6 @@
// Reexported types and traits
#[doc(no_inline)] pub use ascii::{Ascii, AsciiCast, OwnedAsciiCast, AsciiStr};
#[doc(no_inline)] pub use ascii::IntoBytes;
#[doc(no_inline)] pub use borrow::IntoCow;
#[doc(no_inline)] pub use c_str::ToCStr;
#[doc(no_inline)] pub use char::{Char, UnicodeChar};

1
src/libsyntax/ext/bytes.rs
View File

@ -15,6 +15,7 @@ use codemap::Span;
use ext::base::*;
use ext::base;
use ext::build::AstBuilder;
use std::ascii::AsciiExt;
pub fn expand_syntax_ext<'cx>(cx: &'cx mut ExtCtxt,

2
src/libsyntax/feature_gate.rs
View File

@ -31,6 +31,8 @@ use visit::Visitor;
use parse::token;
use std::slice;
use std::ascii::AsciiExt;
// if you change this list without updating src/doc/reference.md, @cmr will be sad
static KNOWN_FEATURES: &'static [(&'static str, Status)] = &[

6
src/libterm/terminfo/parm.rs
View File

@ -14,6 +14,7 @@ pub use self::Param::*;
use self::States::*;
use self::FormatState::*;
use self::FormatOp::*;
use std::ascii::OwnedAsciiExt;
use std::mem::replace;
#[deriving(Copy, PartialEq)]
@ -530,10 +531,7 @@ fn format(val: Param, op: FormatOp, flags: Flags) -> Result<Vec<u8> ,String> {
}
}
FormatHEX => {
s = s.to_ascii()
.iter()
.map(|b| b.to_uppercase().as_byte())
.collect();
s = s.into_ascii_uppercase();
if flags.alternate {
let s_ = replace(&mut s, vec!(b'0', b'X'));
s.extend(s_.into_iter());

9
src/test/bench/shootout-k-nucleotide-pipes.rs
View File

@ -17,6 +17,7 @@
extern crate collections;
use std::ascii::{AsciiExt, OwnedAsciiExt};
use std::collections::HashMap;
use std::mem::replace;
use std::num::Float;
@ -64,10 +65,8 @@ fn sort_and_fmt(mm: &HashMap<Vec<u8> , uint>, total: uint) -> String {
let mut buffer = String::new();
for &(ref k, v) in pairs_sorted.iter() {
buffer.push_str(format!("{} {:0.3}\n",
k.as_slice()
.to_ascii()
.to_uppercase()
.into_string(), v).as_slice());
k.to_ascii_uppercase(),
v).as_slice());
}
return buffer
@ -75,7 +74,7 @@ fn sort_and_fmt(mm: &HashMap<Vec<u8> , uint>, total: uint) -> String {
// given a map, search for the frequency of a pattern
fn find(mm: &HashMap<Vec<u8> , uint>, key: String) -> uint {
let key = key.into_ascii().as_slice().to_lowercase().into_string();
let key = key.into_ascii_lowercase();
match mm.get(key.as_bytes()) {
option::Option::None => { return 0u; }
option::Option::Some(&num) => { return num; }

6
src/test/bench/shootout-k-nucleotide.rs
View File

@ -42,6 +42,7 @@
#![feature(slicing_syntax)]
use std::ascii::OwnedAsciiExt;
use std::string::String;
use std::slice;
use std::sync::{Arc, Future};
@ -286,10 +287,7 @@ fn get_sequence<R: Buffer>(r: &mut R, key: &str) -> Vec<u8> {
{
res.push_all(l.as_slice().trim().as_bytes());
}
for b in res.iter_mut() {
*b = b.to_ascii().to_uppercase().to_byte();
}
res
res.into_ascii_uppercase()
}
fn main() {

2
src/test/run-pass/issue-10683.rs
View File

@ -13,7 +13,7 @@ use std::ascii::AsciiExt;
static NAME: &'static str = "hello world";
fn main() {
match NAME.to_ascii_lower().as_slice() {
match NAME.to_ascii_lowercase().as_slice() {
"foo" => {}
_ => {}
}