Breaking: Extent passthrough for multidimensional lookups

Project.toml

@@ -48,7 +48,7 @@ AlgebraOfGraphics = "0.8, 0.9, 0.10"
 Aqua = "0.8"
 ArrayInterface = "7"
 BenchmarkTools = "1"
-CairoMakie = "0.10, 0.11, 0.12"
+CairoMakie = "0.10, 0.11, 0.12, 0.13"
 CategoricalArrays = "0.10"
 ColorTypes = "0.11"
 Combinatorics = "1"

src/Dimensions/Dimensions.jl

@@ -24,7 +24,7 @@ const LU = Lookups
 const LookupArrays = Lookups
 
 import .Lookups: rebuild, order, span, sampling, locus, val, index, set, _set,
-    metadata, bounds, intervalbounds, units, basetypeof, unwrap, selectindices, hasselection,
+    metadata, bounds, intervalbounds, units, basetypeof, unwrap, selectindices, hasselection, hasmultipledimensions,
     shiftlocus, maybeshiftlocus, ordered_first, ordered_last, ordered_firstindex, ordered_lastindex, 
     promote_first, _remove
 using .Lookups: StandardIndices, SelTuple, CategoricalEltypes,

src/Dimensions/coord.jl

@@ -4,6 +4,7 @@ struct CoordLookup{T,A<:AbstractVector{T},D,Me} <: MultiDimensionalLookup{T}
     metadata::Me
 end
 CoordLookup(data, dims; metadata=NoMetadata()) = CoordLookup(data, dims, metadata)
+hasmultipledimensions(::CoordLookup) = true
 
 dims(m::CoordLookup) = m.dims
 order(m::CoordLookup) = Unordered()

src/Dimensions/dimension.jl

@@ -303,22 +303,25 @@ Base.size(dims::DimTuple) = map(length, dims)
 Base.CartesianIndices(dims::DimTuple) = CartesianIndices(map(d -> axes(d, 1), dims))
 
 # Extents.jl
+#=
 function Extents.extent(ds::DimTuple, args...)
     extent_dims = _astuple(dims(ds, args...))
     extent_bounds = bounds(extent_dims)
     return Extents.Extent{name(extent_dims)}(extent_bounds)
 end
+=#
 
-function _experimental_extent(ds::DimTuple)
-    regulardims = dims(ds, x -> !(lookup(x) isa MultiDimensionalLookup))    
-    regular_bounds = bounds.(regulardims)
+function Extents.extent(ids::DimTuple, args...)
+    ds = _astuple(dims(ids, args...))
+    regulardims = dims(ds, x -> !hasmultipledimensions(lookup(x)))    
+    regular_bounds = map(bounds, regulardims)
     regular_bounds_nt = NamedTuple{map(name, regulardims)}(regular_bounds)
 
     multidims = otherdims(ds, regulardims)
-    multidim_raw_bounds = bounds.(multidims) # we trust that bounds will give us a tuple of bounds one for each enclosed dimension
+    multidim_raw_bounds = map(bounds, multidims) # we trust that bounds will give us a tuple of bounds one for each enclosed dimension
     multidim_dims = combinedims(map(dims, multidims)...; length = false)
     multidim_bounds = map(multidim_dims) do outdim
-        foldl(zip(multidims, multidim_raw_bounds); init = (nothing, nothing)) do (minval, maxval), (dim, bounds)
+        foldl(map(tuple, multidims, multidim_raw_bounds); init = (nothing, nothing)) do (minval, maxval), (dim, bounds)
             if hasdim(dim, outdim)
                 if isnothing(minval) && isnothing(maxval)
                     bounds[dimnum(dim, outdim)]
@@ -332,7 +335,7 @@ function _experimental_extent(ds::DimTuple)
         end
     end
     multidim_bounds_nt = NamedTuple{map(name, multidim_dims)}(multidim_bounds)
-    return merge(regular_bounds_nt, multidim_bounds_nt)
+    return Extents.Extent(merge(regular_bounds_nt, multidim_bounds_nt))
 end
 
 dims(extent::Extents.Extent{K}) where K = map(rebuild, name2dim(K), values(extent))

src/Dimensions/indexing.jl

@@ -47,7 +47,7 @@ Convert a `Dimension` or `Selector` `I` to indices of `Int`, `AbstractArray` or
 @inline function dims2indices(dims::DimTuple, I::DimTuple)
     extradims = otherdims(I, dims) # extra dims in the query, I
     # Extract "multi dimensional" lookups like MergedLookup or Rasters' GeometryLookup
-    multidims = Dimensions.dims(otherdims(dims, I), x -> lookup(x) isa MultiDimensionalLookup && !isempty(Dimensions.dims(x, I)))
+    multidims = Dimensions.dims(otherdims(dims, I), x -> hasmultipledimensions(lookup(x)) && !isempty(Dimensions.dims(x, I)))
     # Warn if any dims from I were not picked up by multidims
     actuallyextradims = otherdims(extradims, x -> any(y -> hasdim(y, x), multidims)) # one way setdiff(extradims, multidims) essentially
     length(actuallyextradims) > 0 && _extradimswarn(actuallyextradims)

src/Dimensions/merged.jl

@@ -1,4 +1,5 @@
 abstract type MultiDimensionalLookup{T} <: Lookup{T,1} end
+hasmultipledimensions(::MultiDimensionalLookup) = true
 
 """
     MergedLookup <: MultiDimensionalLookup <: Lookup
@@ -63,6 +64,7 @@ struct MergedLookup{T,A<:AbstractVector{T},D,Me} <: MultiDimensionalLookup{T}
 end
 MergedLookup(data, dims; metadata=NoMetadata()) = MergedLookup(data, dims, metadata)
 
+hasmultipledimensions(::MergedLookup) = true
 order(m::MergedLookup) = Unordered()
 dims(m::MergedLookup) = m.dims
 dims(d::Dimension{<:MergedLookup}) = dims(val(d))

src/Lookups/Lookups.jl

@@ -36,7 +36,7 @@ export reducelookup, shiftlocus, maybeshiftlocus, promote_first
 export index
 
 export issampled, iscategorical, iscyclic, isnolookup, isintervals, ispoints, isregular,
-    isexplicit, isstart, iscenter, isend, isordered, isforward, isreverse
+    isexplicit, isstart, iscenter, isend, isordered, isforward, isreverse, hasmultipledimensions
 
 export Selector
 export At, Between, Touches, Contains, Near, Where, All

src/Lookups/predicates.jl

@@ -29,6 +29,7 @@ isintervals(::Intervals) = true
 isintervals(::Points) = false
 ispoints(::Points) = true
 ispoints(::Intervals) = false
+hasmultipledimensions(::Lookup) = false
 
 # Forward them from lookups
 for f in (:isregular, :isexplicit)