Histograms with dates and missing data

[ericphanson]

Here is some code I've been using to do a "smart" histogram that actually does a barplot if the data is small and discrete, and otherwise does a histogram, and handles missing data and dates. It would be great if some of these features could make it into Makie's histogram!

"""
    countplot!(ax, things_to_count)

Creates a barplot in `ax` to mimic
a histogram of a small discrete set.
"""
function countplot!(ax, things_to_count)
    d = countmap(things_to_count)
    xs = collect(keys(d))
    ys = collect(values(d))
    p = sortperm(xs)
    xs = xs[p]
    ys = ys[p]
    if eltype(xs) isa Number
        m, M = extrema(xs)
        width = minimum(diff(xs))/4
        ax.xticks = (m:M, string.(m:M))
    else # categorical
        ax.xticks = (1:length(xs), string.(xs))
        width = 1/2
        xs = 1:length(xs)
    end
    plt = barplot!(ax, xs, ys; width)
    return plt
end

"""
    unvalue(::Type{T}, i::Int)

Attempts to reconstruct a Dates type by inverting `Dates.value(obj::T)`.
"""
unvalue(::Type{T}, i::Int) where {T} = T(i)
unvalue(::Type{Date}, i::Int) = Date(Dates.UTInstant{Day}(Day(i)))

"""
    treat_as_discrete(things_to_count; max_ints = 25) -> Bool

Heuristically decide if we should treat `things_to_count` as a
discrete set or a continuous set.
"""
function treat_as_discrete(things_to_count; max_ints=25)
    nonmissingtype(eltype(things_to_count)) <: Union{Integer,Symbol,String} || return false
    if nonmissingtype(eltype(things_to_count)) <: Integer
        m, M = extrema(things_to_count)
        M - m <= max_ints || return false
    end
    return true
end

"""
    handle_dates!(ax, values) -> values′

If `values` contains Date types we can handle,
then return integer versions of them and update
the axis formatter to label them correctly.
"""
function handle_dates!(ax, values)
    T = nonmissingtype(eltype(values))
    if T <: Dates.Date || T <: Day
        values = Dates.value.(values)
        ax.xtickformat[] = (s -> string.(unvalue.(T, round.(Int, s))))
    end
    return values
end

"""
    plot_hist(things_to_count, xlabel=nothing, ylabel=nothing; discrete = nothing, showmissing = true)

Plot a "histogram" for vectors that can contain `missing`, and could have dates
or be a discrete set.
"""
plot_hist(args...; kwargs...) = plot_hist!(Figure(), args...; kwargs...)

function plot_hist!(fig, things_to_count, xlabel=nothing, ylabel=nothing; discrete=nothing,
                   title=nothing, showmissing=false, titlemissing=true)
    isempty(things_to_count) && throw(ArgumentError("`things_to_count` must be non-empty"))

    n_missing = count(ismissing, things_to_count)
    n_missing == length(things_to_count) && throw(ArgumentError("`things_to_count` must not be entirely `missing`"))

    # map(identity, ..) seems needed here to remove the `Missing` from the type
    # which otherwise messes up axis ticks (for some reason)
    things_to_count = map(identity, filter(!ismissing, things_to_count))

    if title === nothing && titlemissing
        title = "$(n_missing) missing ($(n_missing + length(things_to_count)) total)"
    end
    ax = fig[1, 1] = title === nothing ? Axis(fig) : Axis(fig; title)

    xlabel !== nothing && (ax.xlabel = xlabel)
    ylabel !== nothing && (ax.ylabel = ylabel)

    things_to_count = handle_dates!(ax, things_to_count)

    discrete === nothing && (discrete = treat_as_discrete(things_to_count))

    discrete ? countplot!(ax, things_to_count) : hist!(ax, things_to_count)

    # some crazy code to try to hack in a `missing` bar at the end
    if showmissing && n_missing > 0
        # getlayout(fig).default_colgap = AbstractPlotting.GridLayoutBase.Fixed(0.0)

        ax.rightspinevisible = false
        ax_missing = fig[1, 2] = Axis(fig)
        ax_missing.leftspinevisible = false
        b = barplot!(ax_missing, [Point2f0(0, n_missing)]; width=[3])

        ax_missing.targetlimits = BBox(-6, 2, 0, 100)

        ax_missing.xticks = ([0], ["missing"])
        ax_missing.width = 100
        hideydecorations!(ax_missing; grid=false)
        linkyaxes!(ax, ax_missing)

        getlayout(fig).colsizes = [AbstractPlotting.GridLayoutBase.Fixed(0.0) for _ = 1:length(getlayout(fig).colsizes)]
    end
    return fig
end

getlayout(fig::Figure) = fig.layout
getlayout(fig::AbstractPlotting.FigurePosition) = fig.gp.layout

[jtrakk]

I'd rather not have an error for empty datasets because sometimes I would build the plot without data and then add data to it.