Fix 0.6 breakages and depwarns

Author: timholy

REQUIRE

@@ -2,3 +2,4 @@ julia 0.5
 IntervalSets
 Iterators
 RangeArrays
+Compat 0.19

src/AxisArrays.jl

@@ -4,6 +4,7 @@ module AxisArrays
 
 using Base: tail
 using RangeArrays, Iterators, IntervalSets
+using Compat
 
 export AxisArray, Axis, axisnames, axisvalues, axisdim, axes, atindex
 

src/combine.jl

@@ -13,7 +13,7 @@ sizes{T<:AxisArray}(As::T...) = tuple(zip(map(size, As)...)...)
 matchingdims{N,T<:AxisArray}(As::NTuple{N,T}) = all(equalvalued, sizes(As...))
 matchingdimsexcept{N,T<:AxisArray}(As::NTuple{N,T}, n::Int) = all(equalvalued, sizes(As[[1:n-1; n+1:end]]...))
 
-function Base.cat{T<:AxisArray}(n::Integer, As::T...)
+function Base.cat{T}(n::Integer, As::AxisArray{T}...)
     if n <= ndims(As[1])
         matchingdimsexcept(As, n) || error("All non-concatenated axes must be identically-valued")
         newaxis = Axis{axisnames(As[1])[n]}(vcat(map(A -> A.axes[n].val, As)...))

src/core.jl

@@ -8,7 +8,7 @@ else
     using Base: @pure
 end
 
-typealias Symbols Tuple{Symbol,Vararg{Symbol}}
+const Symbols = Tuple{Symbol,Vararg{Symbol}}
 
 @doc """
 Type-stable axis-specific indexing and identification with a
@@ -158,17 +158,17 @@ A[ClosedInterval(0.,.3), [:a, :c]]   # select an interval and two columns
 immutable AxisArray{T,N,D,Ax} <: AbstractArray{T,N}
     data::D  # D <:AbstractArray, enforced in constructor to avoid dispatch bugs (https://github.com/JuliaLang/julia/issues/6383)
     axes::Ax # Ax<:NTuple{N, Axis}, but with specialized Axis{...} types
-    AxisArray(data::AbstractArray, axs) = new{T,N,D,Ax}(data, axs)
+    (::Type{AxisArray{T,N,D,Ax}}){T,N,D,Ax}(data::AbstractArray{T,N}, axs::Tuple{Vararg{Axis,N}}) = new{T,N,D,Ax}(data, axs)
 end
 #
 _defaultdimname(i) = i == 1 ? (:row) : i == 2 ? (:col) : i == 3 ? (:page) : Symbol(:dim_, i)
 
 default_axes(A::AbstractArray) = _default_axes(A, indices(A), ())
-_default_axes{T,N}(A::AbstractArray{T,N}, inds, axs::NTuple{N}) = axs
-@inline _default_axes{T,N,M}(A::AbstractArray{T,N}, inds, axs::NTuple{M}) =
+_default_axes{T,N}(A::AbstractArray{T,N}, inds, axs::NTuple{N,Axis}) = axs
+@inline _default_axes{T,N,M}(A::AbstractArray{T,N}, inds, axs::NTuple{M,Axis}) =
     _default_axes(A, inds, (axs..., _nextaxistype(A, axs)(inds[M+1])))
 # Why doesn't @pure work here?
-@generated function _nextaxistype{T,M}(A::AbstractArray{T}, axs::NTuple{M})
+@generated function _nextaxistype{T,M}(A::AbstractArray{T}, axs::NTuple{M,Axis})
     name = _defaultdimname(M+1)
     :(Axis{$(Expr(:quote, name))})
 end
@@ -245,7 +245,6 @@ Base.size{Ax<:Axis}(A::AxisArray, ::Type{Ax}) = size(A.data, axisdim(A, Ax))
 Base.indices(A::AxisArray) = indices(A.data)
 Base.indices(A::AxisArray, Ax::Axis) = indices(A.data, axisdim(A, Ax))
 Base.indices{Ax<:Axis}(A::AxisArray, ::Type{Ax}) = indices(A.data, axisdim(A, Ax))
-Base.linearindexing(A::AxisArray) = Base.linearindexing(A.data)
 Base.convert{T,N}(::Type{Array{T,N}}, A::AxisArray{T,N}) = convert(Array{T,N}, A.data)
 # Similar is tricky. If we're just changing the element type, it can stay as an
 # AxisArray. But if we're changing dimensions, there's no way it can know how
@@ -308,7 +307,7 @@ function permutation(to::Symbols, from::Symbols)
     li = linearindices(from)
     d = Dict(from[i]=>i for i in li)
     covered = similar(dims->falses(length(li)), li)
-    ind = Array(Int, max(n, nf))
+    ind = Array{Int}(max(n, nf))
     for (i,toi) in enumerate(to)
         j = get(d, toi, 0)
         ind[i] = j
@@ -421,7 +420,7 @@ axes(A::AbstractArray) = default_axes(A)
 axes(A::AbstractArray, dim::Int) = default_axes(A)[dim]
 
 ### Axis traits ###
-abstract AxisTrait
+@compat abstract type AxisTrait end
 immutable Dimensional <: AxisTrait end
 immutable Categorical <: AxisTrait end
 immutable Unsupported <: AxisTrait end

src/indexing.jl

@@ -1,9 +1,9 @@
-typealias Idx Union{Real,Colon,AbstractArray{Int}}
+const Idx = Union{Real,Colon,AbstractArray{Int}}
 
-using Base: ViewIndex, linearindexing, unsafe_getindex, unsafe_setindex!
+using Base: ViewIndex, unsafe_getindex, unsafe_setindex!
 
-# Defer linearindexing to the wrapped array
-Base.linearindexing{T,N,D}(::AxisArray{T,N,D}) = linearindexing(D)
+# Defer IndexStyle to the wrapped array
+@compat Base.IndexStyle{T,N,D,Ax}(::Type{AxisArray{T,N,D,Ax}}) = IndexStyle(D)
 
 # Simple scalar indexing where we just set or return scalars
 @inline Base.getindex(A::AxisArray, idxs::Int...) = A.data[idxs...]
@@ -26,16 +26,24 @@ Base.setindex!(A::AxisArray, v, idx::Base.IteratorsMD.CartesianIndex) = (A.data[
     end
     names = axisnames(A)
     newaxes = Expr[]
-    for d=1:lastnonscalar-droplastaxis
+    drange = 1:lastnonscalar-droplastaxis
+    for d=drange
         if I[d] <: AxisArray
             # Indexing with an AxisArray joins the axis names
             idxnames = axisnames(I[d])
             for i=1:ndims(I[d])
                 push!(newaxes, :($(Axis{Symbol(names[d], "_", idxnames[i])})(I[$d].axes[$i].val)))
             end
         elseif I[d] <: Real
-        elseif I[d] <: Union{AbstractVector,Colon}
+        elseif I[d] <: AbstractVector
             push!(newaxes, :($(Axis{names[d]})(A.axes[$d].val[Base.to_index(I[$d])])))
+        elseif I[d] <: Colon
+            if d < length(I) || d <= ndims(A)
+                push!(newaxes, :($(Axis{names[d]})(A.axes[$d].val)))
+            else
+                dimname = _defaultdimname(d)
+                push!(newaxes, :($(Axis{dimname})(Base.OneTo(Base.trailingsize(A, $d)))))
+            end
         elseif I[d] <: AbstractArray
             for i=1:ndims(I[d])
                 # When we index with non-vector arrays, we *add* dimensions.
@@ -117,6 +125,12 @@ end
     return :($meta; to_index(A, $(idxs...)))
 end
 
+function Base.reshape{N}(A::AxisArray, ::Type{Val{N}})
+    # axN, _ = Base.IteratorsMD.split(axes(A), Val{N})
+    # AxisArray(reshape(A.data, Val{N}), reaxis(A, Base.fill_to_length(axN, :, Val{N})...))
+    AxisArray(reshape(A.data, Val{N}), reaxis(A, ntuple(d->Colon(), Val{N})...))
+end
+
 ### Indexing along values of the axes ###
 
 # Default axes indexing throws an error

src/intervals.jl

@@ -17,7 +17,7 @@
 # downside is that Intervals are not as useful as they could be; they really
 # could be considered as <: Number themselves. We do this in general for any
 # supported Scalar:
-typealias Scalar Union{Number, Dates.AbstractTime}
+const Scalar = Union{Number, Dates.AbstractTime}
 Base.promote_rule{T<:Scalar}(::Type{ClosedInterval{T}}, ::Type{T}) = ClosedInterval{T}
 Base.promote_rule{T,S<:Scalar}(::Type{ClosedInterval{T}}, ::Type{S}) = ClosedInterval{promote_type(T,S)}
 Base.promote_rule{T,S}(::Type{ClosedInterval{T}}, ::Type{ClosedInterval{S}}) = ClosedInterval{promote_type(T,S)}
@@ -62,7 +62,7 @@ immutable RepeatedInterval{T,S,A} <: AbstractVector{T}
 end
 RepeatedInterval{S,A<:AbstractVector}(window::ClosedInterval{S}, offsets::A) = RepeatedInterval{promote_type(ClosedInterval{S}, eltype(A)), S, A}(window, offsets)
 Base.size(r::RepeatedInterval) = size(r.offsets)
-Base.linearindexing{R<:RepeatedInterval}(::Type{R}) = Base.LinearFast()
+@compat Base.IndexStyle(::Type{<:RepeatedInterval}) = IndexLinear()
 Base.getindex(r::RepeatedInterval, i::Int) = r.window + r.offsets[i]
 +(window::ClosedInterval, offsets::AbstractVector) = RepeatedInterval(window, offsets)
 +(offsets::AbstractVector, window::ClosedInterval) = RepeatedInterval(window, offsets)
@@ -84,5 +84,5 @@ immutable RepeatedIntervalAtIndexes{T,A<:AbstractVector{Int}} <: AbstractVector{
 end
 atindex(window::ClosedInterval, indexes::AbstractVector) = RepeatedIntervalAtIndexes(window, indexes)
 Base.size(r::RepeatedIntervalAtIndexes) = size(r.indexes)
-Base.linearindexing{R<:RepeatedIntervalAtIndexes}(::Type{R}) = Base.LinearFast()
+@compat Base.IndexStyle(::Type{<:RepeatedIntervalAtIndexes}) = IndexLinear()
 Base.getindex(r::RepeatedIntervalAtIndexes, i::Int) = IntervalAtIndex(r.window, r.indexes[i])

src/search.jl

@@ -36,21 +36,30 @@ function Base.searchsorted(a::Range, I::ClosedInterval)
     searchsortedfirst(a, I.left):searchsortedlast(a, I.right)
 end
 
-if VERSION > v"0.5.0-dev+4557"
-    # When running with "--check-bounds=yes" (like on Travis), the bounds-check isn't elided
-    @inline function Base.unsafe_getindex{T}(v::Range{T}, i::Integer)
-        convert(T, first(v) + (i-1)*step(v))
-    end
+# When running with "--check-bounds=yes" (like on Travis), the bounds-check isn't elided
+@inline function Base.unsafe_getindex{T}(v::Range{T}, i::Integer)
+    convert(T, first(v) + (i-1)*step(v))
+end
+@inline function Base.unsafe_getindex{T<:Integer}(r::StepRange, s::Range{T})
+    st = oftype(r.start, r.start + (first(s)-1)*step(r))
+    range(st, step(r)*step(s), length(s))
+end
+if VERSION < v"0.6.0-dev.2390"
+    include_string("""
     @inline function Base.unsafe_getindex{T}(r::FloatRange{T}, i::Integer)
         convert(T, (r.start + (i-1)*r.step)/r.divisor)
     end
-    @inline function Base.unsafe_getindex{T<:Integer}(r::StepRange, s::Range{T})
-        st = oftype(r.start, r.start + (first(s)-1)*step(r))
-        range(st, step(r)*step(s), length(s))
-    end
     @inline function Base.unsafe_getindex(r::FloatRange, s::OrdinalRange)
         FloatRange(r.start + (first(s)-1)*r.step, step(s)*r.step, length(s), r.divisor)
     end
+    """)
+else
+    include_string("""
+    @inline function Base.unsafe_getindex(r::StepRangeLen, s::OrdinalRange)
+        vfirst = unsafe_getindex(r, first(s))
+        StepRangeLen(vfirst, r.step*step(s), length(s))
+    end
+    """)
 end
 
 function unsafe_searchsortedlast{T<:Number}(a::Range{T}, x::Number)

test/indexing.jl

@@ -37,8 +37,13 @@ D[1,1,1,1,1] = 10
 
 # Linear indexing across multiple dimensions drops tracking of those dims
 @test A[:].axes[1].val == 1:length(A)
-@test A[1:2,:].axes[1].val == A.axes[1].val[1:2]
-@test A[1:2,:].axes[2].val == 1:Base.trailingsize(A,2)
+B = A[1:2,:]
+@test B.axes[1].val == A.axes[1].val[1:2]
+@test B.axes[2].val == 1:Base.trailingsize(A,2)
+B2 = reshape(A, Val{2})
+B = B2[1:2,:]
+@test B.axes[1].val == A.axes[1].val[1:2]
+@test B.axes[2].val == 1:Base.trailingsize(A,2)
 
 B = AxisArray(reshape(1:15, 5,3), .1:.1:0.5, [:a, :b, :c])
 

test/runtests.jl

@@ -1,7 +1,9 @@
 using AxisArrays
 using Base.Test
 
-@test isempty(detect_ambiguities(AxisArrays, Base, Core))
+if VERSION < v"0.6.0-dev"
+    @test isempty(detect_ambiguities(AxisArrays, Base, Core))
+end
 
 include("core.jl")
 include("intervals.jl")