Add deprecation of is_valid_*

ScottPJones · May 14, 2015 · 6a41da2 · 6a41da2
1 parent 32d7ad5
commit 6a41da2
Show file tree

Hide file tree

Showing 9 changed files with 33 additions and 37 deletions.
diff --git a/base/ascii.jl b/base/ascii.jl
@@ -100,7 +100,7 @@ ascii(x) = convert(ASCIIString, x)
 convert(::Type{ASCIIString}, s::ASCIIString) = s
 convert(::Type{ASCIIString}, s::UTF8String) = ascii(s.data)
 convert(::Type{ASCIIString}, a::Vector{UInt8}) = begin
-    is_valid_ascii(a) || throw(ArgumentError("invalid ASCII sequence"))
+    isvalid(ASCIIString,a) || throw(ArgumentError("invalid ASCII sequence"))
     return ASCIIString(a)
 end
 

diff --git a/base/deprecated.jl b/base/deprecated.jl
@@ -440,3 +440,11 @@ export float32_isvalid, float64_isvalid
 @deprecate (&)(x::Char, y::Char)  Char(UInt32(x) & UInt32(y))
 @deprecate (|)(x::Char, y::Char)  Char(UInt32(x) | UInt32(y))
 @deprecate ($)(x::Char, y::Char)  Char(UInt32(x) $ UInt32(y))
+
+# 11241
+
+@deprecate is_valid_char(ch::Union(Unsigned, Integer, Char)) isvalid(Char, ch)
+@deprecate is_valid_ascii(str::Union(Vector{UInt8}, ByteString)) isvalid(ASCIIString, str)
+@deprecate is_valid_utf8(str::Union(Vector{UInt8}, ByteString)) isvalid(UTFString, str)
+@deprecate is_valid_utf16(str::Union(AbstractVector{UInt16}, UTF16String)) isvalid(UTF16String, str)
+@deprecate is_valid_utf32(str::Union(AbstractVector{UInt16}, UTF16String)) isvalid(UTF16String, str)
diff --git a/base/exports.jl b/base/exports.jl
@@ -820,11 +820,6 @@ export
     ind2chr,
     info,
     is_assigned_char,
-    is_valid_ascii,
-    is_valid_char,
-    is_valid_utf8,
-    is_valid_utf16,
-    is_valid_utf32,
     isalnum,
     isalpha,
     isascii,

diff --git a/base/io.jl b/base/io.jl
@@ -246,7 +246,7 @@ end
 
 function readall(s::IO)
     b = readbytes(s)
-    return is_valid_ascii(b) ? ASCIIString(b) : UTF8String(b)
+    return isvalid(ASCIIString, b) ? ASCIIString(b) : UTF8String(b)
 end
 readall(filename::AbstractString) = open(readall, filename)
 

diff --git a/base/utf16.jl b/base/utf16.jl
@@ -95,7 +95,7 @@ sizeof(s::UTF16String) = sizeof(s.data) - sizeof(UInt16)
 unsafe_convert{T<:Union(Int16,UInt16)}(::Type{Ptr{T}}, s::UTF16String) =
     convert(Ptr{T}, pointer(s))
 
-function is_valid_utf16(data::AbstractArray{UInt16})
+function isvalid(::Type{UTF16String}, data::AbstractArray{UInt16})
     i = 1
     n = length(data) # this may include NULL termination; that's okay
     while i < n # check for unpaired surrogates
@@ -110,9 +110,9 @@ function is_valid_utf16(data::AbstractArray{UInt16})
     return i > n || !utf16_is_surrogate(data[i])
 end
 
-is_valid_utf16(s::UTF16String) = is_valid_utf16(s.data)
-isvalid(::Type{UTF16String}, s::AbstractArray{UInt16}) = is_valid_utf16(s)
-isvalid(str::UTF16String) = is_valid_utf16(str.data)
+isvalid(str::UTF16String) = isvalid(UTF16String, str.data)
+is_valid_utf16(str::UTF16String) = isvalid(UTF16String, str.data)
+is_valid_utf16(data::AbstractArray{UInt16}) = isvalid(UTF16String, data)
 
 function convert(::Type{UTF16String}, data::AbstractVector{UInt16})
     !is_valid_utf16(data) && throw(ArgumentError("invalid UTF16 data"))

diff --git a/base/utf32.jl b/base/utf32.jl
@@ -92,16 +92,16 @@ function convert(T::Type{UTF32String}, bytes::AbstractArray{UInt8})
     UTF32String(d)
 end
 
-function is_valid_utf32(s::Union(Vector{Char}, Vector{UInt32}))
-    for i=1:length(s)
-        @inbounds if !is_valid_char(reinterpret(UInt32, s[i])) ; return false ; end
+function isvalid(::Type{UTF32String}, str::Union(Vector{Char}, Vector{UInt32}))
+    for i=1:length(str)
+        @inbounds if !isvalid(Char, reinterpret(UInt32, str[i])) ; return false ; end
     end
     return true
 end
-is_valid_utf32(s::UTF32String) = is_valid_utf32(s.data)
-isvalid(::Type{UTF32String}, s::Union(Vector{Char}, AbstractArray{UInt32})) = is_valid_utf32(s)
-isvalid(str::UTF32String) = is_valid_utf32(str.data)
-isvalid(str::Vector{Char}) = is_valid_utf32(str)
+isvalid(str::Vector{Char}) = isvalid(UTF32String, str)
+isvalid(str::UTF32String) = isvalid(UTF32String, (str.data))
+is_valid_utf32(str::Union(Vector{Char}, Vector{UInt32})) = isvalid(UTF32String, str)
+is_valid_utf32(str::UTF32String) = isvalid(UTF32String, str.data)
 
 utf32(p::Ptr{Char}, len::Integer) = utf32(pointer_to_array(p, len))
 utf32(p::Union(Ptr{UInt32}, Ptr{Int32}), len::Integer) = utf32(convert(Ptr{Char}, p), len)

diff --git a/base/utf8.jl b/base/utf8.jl
@@ -212,7 +212,7 @@ write(io::IO, s::UTF8String) = write(io, s.data)
 utf8(x) = convert(UTF8String, x)
 convert(::Type{UTF8String}, s::UTF8String) = s
 convert(::Type{UTF8String}, s::ASCIIString) = UTF8String(s.data)
-convert(::Type{UTF8String}, a::Array{UInt8,1}) = is_valid_utf8(a) ? UTF8String(a) : throw(ArgumentError("invalid UTF-8 sequence"))
+convert(::Type{UTF8String}, a::Array{UInt8,1}) = isvalid(UTF8String, a) ? UTF8String(a) : throw(ArgumentError("invalid UTF-8 sequence"))
 function convert(::Type{UTF8String}, a::Array{UInt8,1}, invalids_as::AbstractString)
     l = length(a)
     idx = 1

diff --git a/base/utf8proc.jl b/base/utf8proc.jl
@@ -13,12 +13,15 @@ export normalize_string, graphemes, is_valid_char, is_assigned_char, charwidth,
    iscntrl, ispunct, isspace, isprint, isgraph, isblank
 
 # whether codepoints are valid Unicode scalar values, i.e. 0-0xd7ff, 0xe000-0x10ffff
-is_valid_char(ch::Unsigned) = !Bool((ch-0xd800<0x800)|(ch>0x10ffff))
-is_valid_char(ch::Integer) = is_valid_char(Unsigned(ch))
-is_valid_char(ch::Char) = is_valid_char(UInt32(ch))
+isvalid(::Type{Char}, ch::Unsigned) = !Bool((ch-0xd800<0x800)|(ch>0x10ffff))
+isvalid(::Type{Char}, ch::Integer) = isvalid(Char, Char(Unsigned(ch)))
+isvalid(::Type{Char}, ch::Char) = isvalid(Char, UInt32(ch))
 
-isvalid(::Type{Char},ch::Union(Char,Integer,Unsigned)) = is_valid_char(ch)
-isvalid(ch::Char) = is_valid_char(ch)
+isvalid(ch::Char) = isvalid(Char, ch)
+
+is_valid_char(ch::Unsigned) = isvalid(Char, ch)
+is_valid_char(ch::Integer) = isvalid(Char, Unsigned(ch))
+is_valid_char(ch::Char) = isvalid(Char, UInt32(ch))
 
 # utf8 category constants
 const UTF8PROC_CATEGORY_CN = 0

diff --git a/test/strings.jl b/test/strings.jl
@@ -1280,20 +1280,10 @@ end
 @test isxdigit("a") == true
 @test isxdigit("g") == false
 
-@test is_valid_ascii("is_valid_ascii") == true
-@test is_valid_ascii("Σ_not_valid_ascii") == false
-@test is_valid_char('a') == true
-@test is_valid_char('\x00') == true
-@test is_valid_char('\ud800') == false
-
-@test is_valid_utf16(utf16("a")) == true
-@test is_valid_utf16(utf16("\ud800")) == false
-# TODO is_valid_utf8
-
 # Issue #11140
-@test is_valid_utf32(utf32("a")) == true
-@test is_valid_utf32(utf32("\x00")) == true
-@test is_valid_utf32(UInt32[0xd800,0]) == false
+@test isvalid(utf32("a")) == true
+@test isvalid(utf32("\x00")) == true
+@test isvalid(UTF32String, UInt32[0xd800,0]) == false
 
 # Issue #11241