Julia 0.7 fixes (JuliaData#113)

* Workarounds for some stdlib moves

* Use uninitialized in Array constructors

* Wrap Nullable definitions in a VERSION check

Author: ararslan

REQUIRE

@@ -1,4 +1,4 @@
 julia 0.6
 Missings
 Reexport
-Compat 0.32.0
+Compat 0.39.0

src/CategoricalArrays.jl

@@ -15,6 +15,10 @@ module CategoricalArrays
     using Reexport
     @reexport using Missings
 
+    if VERSION >= v"0.7.0-DEV.3052"
+        using Printf
+    end
+
     include("typedefs.jl")
 
     include("buildfields.jl")

src/array.jl

@@ -340,7 +340,7 @@ Base.fill!(A::CategoricalArray, v::Any) =
 
 function mergelevels(ordered, levels...)
     T = Base.promote_eltype(levels...)
-    res = Array{T}(0)
+    res = Array{T}(uninitialized, 0)
 
     # Fast path in case all levels are equal
     if all(l -> l == levels[1], levels[2:end])

src/buildfields.jl

@@ -1,5 +1,5 @@
 function buildindex(invindex::Dict{S, R}) where {S, R <: Integer}
-    index = Vector{S}(length(invindex))
+    index = Vector{S}(uninitialized, length(invindex))
     for (v, i) in invindex
         index[i] = v
     end
@@ -37,6 +37,6 @@ function buildorder!(order::Array{R},
 end
 
 function buildorder(invindex::Dict{S, R}, levels::Vector) where {S, R <: Integer}
-    order = Vector{R}(length(invindex))
+    order = Vector{R}(uninitialized, length(invindex))
     return buildorder!(order, invindex, levels)
 end

src/deprecated.jl

@@ -9,3 +9,13 @@
 @deprecate CategoricalVector(::Type{T}, m::Integer; ordered=false) where {T} CategoricalVector{T}(m, ordered=ordered)
 
 @deprecate CategoricalMatrix(::Type{T}, m::Int, n::Int; ordered=false) where {T} CategoricalMatrix{T}(m, n, ordered=ordered)
+
+# Only define methods for Nullables while they're in Base, otherwise we don't care
+if VERSION < v"0.7.0-DEV.3017"
+    Base.convert(::Type{Nullable{S}}, x::CategoricalValue{Nullable}) where {S} =
+        convert(Nullable{S}, get(x))
+    Base.convert(::Type{Nullable}, x::CategoricalValue{S}) where {S} = convert(Nullable{S}, x)
+    Base.convert(::Type{Nullable{CategoricalValue{Nullable{T}}}},
+                 x::CategoricalValue{Nullable{T}}) where {T} =
+        Nullable(x)
+end

src/extras.jl

@@ -76,7 +76,7 @@ function cut(x::AbstractArray{T, N}, breaks::AbstractVector;
         end
     end
 
-    refs = Array{DefaultRefType, N}(size(x))
+    refs = Array{DefaultRefType, N}(uninitialized, size(x))
     try
         fill_refs!(refs, x, breaks, extend, allow_missing)
     catch err
@@ -93,7 +93,7 @@ function cut(x::AbstractArray{T, N}, breaks::AbstractVector;
     if isempty(labels)
         from = map(x -> sprint(showcompact, x), breaks[1:n-1])
         to = map(x -> sprint(showcompact, x), breaks[2:n])
-        levs = Vector{String}(n-1)
+        levs = Vector{String}(uninitialized, n-1)
         for i in 1:n-2
             levs[i] = string("[", from[i], ", ", to[i], ")")
         end

src/recode.jl

@@ -146,7 +146,7 @@ function recode!(dest::CategoricalArray{T}, src::CategoricalArray, default::Any,
 
         # Remove recoded levels as they won't appear in result
         firsts = (p.first for p in pairs)
-        keptlevels = Vector{T}()
+        keptlevels = Vector{T}(uninitialized, 0)
         sizehint!(keptlevels, length(srclevels))
 
         for l in srclevels
@@ -177,7 +177,7 @@ function recode!(dest::CategoricalArray{T}, src::CategoricalArray, default::Any,
     srefs = src.refs
 
     origmap = [get(dest.pool, v, 0) for v in srcindex]
-    indexmap = Vector{DefaultRefType}(length(srcindex)+1)
+    indexmap = Vector{DefaultRefType}(uninitialized, length(srcindex)+1)
     # For missing values (0 if no missing in pairs' keys)
     indexmap[1] = 0
     for p in pairs
@@ -343,7 +343,7 @@ function recode(a::AbstractArray, default::Any, pairs::Pair...)
     elseif T >: Missing || default === missing || (eltype(a) >: Missing && !keytype_hasmissing(pairs...))
         dest = Array{Union{T, Missing}}(size(a))
     else
-        dest = Array{Missings.T(T)}(size(a))
+        dest = Array{Missings.T(T)}(uninitialized, size(a))
     end
     recode!(dest, a, default, pairs...)
 end

src/value.jl

@@ -57,12 +57,6 @@ Base.promote_rule(::Type{C}, ::Type{T}) where {C <: CategoricalString, T <: Abst
     promote_type(leveltype(C), T)
 Base.promote_rule(::Type{C}, ::Type{Missing}) where {C <: CatValue} = Union{C, Missing}
 
-Base.convert(::Type{Nullable{S}}, x::CategoricalValue{Nullable}) where {S} =
-    convert(Nullable{S}, get(x))
-Base.convert(::Type{Nullable}, x::CategoricalValue{S}) where {S} = convert(Nullable{S}, x)
-Base.convert(::Type{Nullable{CategoricalValue{Nullable{T}}}},
-             x::CategoricalValue{Nullable{T}}) where {T} =
-    Nullable(x)
 Base.convert(::Type{Ref}, x::CatValue) = RefValue{leveltype(x)}(x)
 Base.convert(::Type{String}, x::CatValue) = convert(String, get(x))
 Base.convert(::Type{Any}, x::CatValue) = x

test/01_typedef.jl

@@ -1,5 +1,6 @@
 module TestTypeDef
-using Base.Test
+using Compat
+using Compat.Test
 using CategoricalArrays
 using CategoricalArrays: DefaultRefType, level,  reftype, leveltype, catvalue, iscatvalue
 

test/02_buildorder.jl

@@ -1,5 +1,6 @@
 module TestUpdateOrder
-using Base.Test
+using Compat
+using Compat.Test
 using CategoricalArrays
 using CategoricalArrays: DefaultRefType
 
@@ -17,7 +18,7 @@ using CategoricalArrays: DefaultRefType
         )
     )
 
-    order = Vector{DefaultRefType}(length(pool.index))
+    order = Vector{DefaultRefType}(uninitialized, length(pool.index))
 
     CategoricalArrays.buildorder!(order, pool.invindex, ["b", "a", "c"])