Merge pull request #7 from JuliaString/spj/makegeneric

Make API more generic

Author: ScottPJones

src/Unicode_Entities.jl

@@ -21,11 +21,11 @@ struct PackedEntities{S,T} <: AbstractPackedTable{String}
 end
 PackedEntities(tab::PackedTable) = PackedEntities(tab.offsetvec, tab.namtab)
 Base.getindex(str::PackedEntities, ind::Integer) =
-    _unpackword(str.namtab[str.offsetvec[ind]+1:str.offsetvec[ind+1]])
+    _unpackword(_tab, str.namtab[str.offsetvec[ind]+1:str.offsetvec[ind+1]])
 
 VER = UInt32(1)
 
-struct Unicode_Table{S,T,V} <: AbstractEntityTable
+struct Unicode_Table{S,T,V}
     ver::UInt32
     tim::String
     inf::String
@@ -40,14 +40,17 @@ struct Unicode_Table{S,T,V} <: AbstractEntityTable
     ind32::Vector{UInt16}
 end
 
-function __init__()
-    global _tab =
-        Unicode_Table(StrTables.load(joinpath(Pkg.dir("Unicode_Entities"), "data", "unicode.dat"))...)
-    global _names = PackedEntities(_tab.nam)
+struct Unicode_Entity <: AbstractEntityTable
+    tab::Unicode_Table
+    nam::PackedEntities
 end
 
-const _empty_str = ""
-const _empty_str_vec = Vector{String}()
+function __init__()
+    tab = Unicode_Table(StrTables.load(joinpath(Pkg.dir("Unicode_Entities"),
+                                                "data", "unicode.dat"))...)
+    nam = PackedEntities(tab.nam)
+    global default = Unicode_Entity(tab, nam)
+end
 
 """
 Internal function to unpack the packed Unicode entity names
@@ -62,7 +65,6 @@ Unicode has a very limited character set for the entity names, 0-9, A-Z, -, (, a
 38-53 represents up to 16*256 words stored in the wrd2 table
 54-255 represent 202 words stored in the wrd1 table
 """
-_unpackword(v::Vector{UInt8}) = _unpackword(v, _tab.wrd1, _tab.wrd2)
 function _unpackword(v::Vector{UInt8}, w1, w2)
     io = IOBuffer()
     pos = 0
@@ -90,39 +92,32 @@ function _unpackword(v::Vector{UInt8}, w1, w2)
             prevw = true
         end
     end
-    @static VERSION < v"0.6-" ? takebuf_string(io) : String(take!(io))
+    String(take!(io))
 end
+_unpackword(tab, v::Vector{UInt8}) = _unpackword(v, tab.wrd1, tab.wrd2)
 
-_get_str(ind) =
-    string(Char(ind <= _tab.base32 ? _tab.val16[ind] : _tab.val32[ind - _tab.base32] + 0x10000))
-    
-function _get_strings(val::T, tab::Vector{T}, ind::Vector{UInt16}) where {T}
-    rng = searchsorted(tab, val)
-    isempty(rng) && return _empty_str_vec
-    _names[ind[rng]]
-end
+## Override methods
 
-function lookupname(str::AbstractString)
-    rng = searchsorted(_names, uppercase(str))
-    isempty(rng) ? _empty_str : _get_str(_tab.ind[rng.start])
+StrTables._get_table(ent::Unicode_Entity) = ent.tab
+StrTables._get_names(ent::Unicode_Entity) = ent.nam
+
+function StrTables._get_str(ent::Unicode_Entity, ind)
+    tab = ent.tab
+    string(Char(ind <= tab.base32 ? tab.val16[ind] : tab.val32[ind - tab.base32] + 0x10000))
 end
 
-matchchar(ch::UInt32) =
-    (ch <= 0x0ffff
-     ? _get_strings(ch%UInt16, _tab.val16, _tab.ind16)
-     : (ch <= 0x1ffff ? _get_strings(ch%UInt16, _tab.val32, _tab.ind32) : _empty_str_vec))
-matchchar(ch::Char) = matchchar(UInt32(ch))
+StrTables.lookupname(tab::Unicode_Entity, str::AbstractString) =
+    rng = searchsorted(tab.nam, uppercase(str))
+    isempty(rng) ? StrTables._empty_str : _get_str(tab.tab, tab.tab.ind[rng.start])
+end
 
-matches(str::AbstractString) = matches(convert(Vector{Char}, str))
-matches(vec::Vector{Char}) = length(vec) == 1 ? matchchar(vec[1]) : _empty_str_vec
+StrTables.matches(ent::Unicode_Entity, vec::Vector{T}) where {T} =
+    length(vec) == 1 ? matchchar(ent, vec[1]) : StrTables._empty_str_vec
 
-longestmatches(str::AbstractString) = longestmatches(convert(Vector{Char},str))
-longestmatches(vec::Vector{Char}) = isempty(vec) ? _empty_str_vec : matchchar(uppercase(vec[1]))
+StrTables.longestmatches(ent::Unicode_Entity, vec::Vector{T}) where {T} =
+    isempty(vec) ? StrTables._empty_str_vec : matchchar(ent, uppercase(vec[1]))
 
-completions(str::AbstractString) = completions(String(str))
-function completions(str::String)
-    str = uppercase(str)
-    [nam for nam in _names if startswith(nam, str)]
-end
+StrTables.completions(ent::Unicode_Entity, str) =
+     [nam for nam in ent.nam if startswith(nam, str)]
 
 end # module Unicode_Entities

test/runtests.jl

@@ -7,6 +7,12 @@ using Unicode_Entities
 
 UE = Unicode_Entities
 
+ue_matchchar(ch)       = UE.matchchar(UE.default, ch)
+ue_lookupname(nam)     = UE.lookupname(UE.default, nam)
+ue_longestmatches(str) = UE.longestmatches(UE.default, str)
+ue_matches(str)        = UE.matches(UE.default, str)
+ue_completions(str)    = UE.completions(UE.default, str)
+
 const datapath = joinpath(Pkg.dir(), "Unicode_Entities", "data")
 const dpath = "ftp://ftp.unicode.org/Public/UNIDATA/"
 const fname = "UnicodeData.txt"
@@ -51,67 +57,65 @@ function load_unicode_data()
 end
 
 load_unicode_data()
-uln = UE.lookupname
-umc = UE.matchchar
 
 @testset "Unicode_Entities" begin
 
     @testset "matches data file" begin
         for (i, ch) in enumerate(symval)
-            list = umc(ch)
+            list = ue_matchchar(ch)
             if !isempty(list)
                 @test symnam[i] in list
             end
         end
         for (i, nam) in enumerate(symnam)
-            str = uln(nam)
+            str = ue_lookupname(nam)
             if str != ""
                 @test symval[i] == str[1]
             end
         end
     end
 
 @testset "lookupname" begin
-    @test UE.lookupname("foobar")   == ""
-    @test UE.lookupname(SubString("My name is Spock", 12)) == ""
-    @test UE.lookupname("end of text") == "\x03" # \3
-    @test UE.lookupname("TIBETAN LETTER -A") == "\u0f60"
-    @test UE.lookupname("LESS-THAN OR SLANTED EQUAL TO") == "\u2a7d"
-    @test UE.lookupname("REVERSED HAND WITH MIDDLE FINGER EXTENDED") == "\U1f595"
+    @test ue_lookupname("foobar")   == ""
+    @test ue_lookupname(SubString("My name is Spock", 12)) == ""
+    @test ue_lookupname("end of text") == "\x03" # \3
+    @test ue_lookupname("TIBETAN LETTER -A") == "\u0f60"
+    @test ue_lookupname("LESS-THAN OR SLANTED EQUAL TO") == "\u2a7d"
+    @test ue_lookupname("REVERSED HAND WITH MIDDLE FINGER EXTENDED") == "\U1f595"
 end
 
 @testset "matches" begin
-    @test isempty(UE.matches(""))
-    @test isempty(UE.matches("\uf900"))
-    @test isempty(UE.matches(SubString("This is \uf900", 9)))
+    @test isempty(ue_matches(""))
+    @test isempty(ue_matches("\uf900"))
+    @test isempty(ue_matches(SubString("This is \uf900", 9)))
     for (chrs, exp) in (("\U1f596", ["RAISED HAND WITH PART BETWEEN MIDDLE AND RING FINGERS"]),
                         ("\u0f4a", ["TIBETAN LETTER REVERSED TA"]),
                         (".", ["FULL STOP", "PERIOD"]))
-        res = UE.matches(chrs)
+        res = ue_matches(chrs)
         @test length(res) >= length(exp)
         @test intersect(res, exp) == exp
     end
 end
 
 @testset "longestmatches" begin
-    @test isempty(UE.longestmatches("\uf900 abcd"))
-    @test isempty(UE.longestmatches(SubString("This is \uf900 abcd", 9)))
+    @test isempty(ue_longestmatches("\uf900 abcd"))
+    @test isempty(ue_longestmatches(SubString("This is \uf900 abcd", 9)))
     for (chrs, exp) in (("\U1f596 abcd", ["RAISED HAND WITH PART BETWEEN MIDDLE AND RING FINGERS"]),
                         (".abcd", ["FULL STOP", "PERIOD"]),
                         ("\u0f4a#123", ["TIBETAN LETTER REVERSED TA", "TIBETAN LETTER TTA"]))
-        res = UE.longestmatches(chrs)
+        res = ue_longestmatches(chrs)
         @test length(res) >= length(exp)
         @test intersect(res, exp) == exp
     end
 end
 
 @testset "completions" begin
-    @test isempty(UE.completions("ScottPaulJones"))
-    @test isempty(UE.completions(SubString("My name is Scott", 12)))
+    @test isempty(ue_completions("ScottPaulJones"))
+    @test isempty(ue_completions(SubString("My name is Scott", 12)))
     for (chrs, exp) in (("ZERO", ["ZERO WIDTH JOINER", "ZERO WIDTH NO-BREAK SPACE",
                                   "ZERO WIDTH NON-JOINER", "ZERO WIDTH SPACE"]),
                         ("BACK OF", ["BACK OF ENVELOPE"]))
-        res = UE.completions(chrs)
+        res = ue_completions(chrs)
         @test length(res) >= length(exp)
         @test intersect(res, exp) == exp
     end