1.22.2 [skip ci]

Fix type inference failure in get_clims (#3838 )
* For Shape type, cut off process * Remove fillcolor for now * NaN * Address type inference failure instead
2021-09-22 21:21:13 +02:00 · 2021-09-22 19:18:57 +02:00 · 2021-09-22 17:12:11 +02:00 · 2021-09-21 00:28:51 +02:00 · 2021-09-20 16:10:29 +02:00 · 2021-09-18 14:13:37 +02:00
15 changed files with 378 additions and 190 deletions
@@ -20,10 +20,11 @@ Backend      | yes | no  | untested
 -------------|-----|-----|---------
 gr (default) |     |     |
 pyplot       |     |     |
-plotly       |     |     |
 plotlyjs     |     |     |
 pgfplotsx    |     |     |
+unicodeplots |     |     |
 inspectdr    |     |     |
+gaston       |     |     |

 ### Versions

@@ -1,7 +1,7 @@
 name = "Plots"
 uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
 author = ["Tom Breloff (@tbreloff)"]
-version = "1.22.0"
+version = "1.22.2"

 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
@@ -68,6 +68,10 @@ function _precompile_()
    ccall(:jl_generating_output, Cint, ()) == 1 || return nothing
    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:label, :blank), Tuple{Symbol, Bool}},Type{EmptyLayout}})
    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:label, :width, :height), Tuple{Symbol, Symbol, Length{:pct, Float64}}},Type{EmptyLayout}})
+    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{GridLayout}},Type{Subplot},GRBackend})
+    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{GridLayout}},Type{Subplot},PlotlyBackend})
+    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{Subplot{GRBackend}}},Type{Subplot},GRBackend})
+    Base.precompile(Tuple{Core.kwftype(typeof(Type)),NamedTuple{(:parent,), Tuple{Subplot{PlotlyBackend}}},Type{Subplot},PlotlyBackend})
    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}, Vector{Float64}},Int64})
    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}, Vector{Float64}},Tuple{Int64, Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
@@ -85,7 +89,7 @@ function _precompile_()
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims, :flip, :ticks, :guide), Tuple{Tuple{Int64, Int64}, Bool, StepRange{Int64, Int64}, String}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Int64, Float64}}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:minorgrid, :scale, :guide), Tuple{Bool, Symbol, String}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,), Tuple{UnitRange{Int64}}},typeof(attr!),Axis})
+    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:rotation,), Tuple{Int64}},typeof(attr!),Axis})
    Base.precompile(Tuple{Core.kwftype(typeof(default)),NamedTuple{(:shape,), Tuple{Symbol}},typeof(default)})
    Base.precompile(Tuple{Core.kwftype(typeof(default)),NamedTuple{(:titlefont, :legendfontsize, :guidefont, :tickfont, :guide, :framestyle, :yminorgrid), Tuple{Tuple{Int64, String}, Int64, Tuple{Int64, Symbol}, Tuple{Int64, Symbol}, String, Symbol, Bool}},typeof(default)})
    Base.precompile(Tuple{Core.kwftype(typeof(font)),NamedTuple{(:family, :pointsize, :halign, :valign, :rotation, :color), Tuple{String, Int64, Symbol, Symbol, Float64, RGBA{Float64}}},typeof(font)})
@@ -117,9 +121,15 @@ function _precompile_()
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Plot{GRBackend},Vector{Int64},Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Plot{PlotlyBackend},Vector{Int64},Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype, :inset), Tuple{Symbol, Tuple{Int64, BoundingBox{Tuple{Length{:w, Float64}, Length{:h, Float64}}, Tuple{Length{:w, Float64}, Length{:h, Float64}}}}}},typeof(plot!),Vector{Int64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot!),Plot{GRBackend},Vector{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:seriestype,), Tuple{Symbol}},typeof(plot!),Vector{Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!),Plot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!),Plot{PlotlyBackend}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:title,), Tuple{String}},typeof(plot!)})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:w,), Tuple{Int64}},typeof(plot!),Plot{GRBackend},Vector{Float64},Vector{Float64},Vararg{Any, N} where N})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:xgrid,), Tuple{Tuple{Symbol, Symbol, Int64, Symbol, Float64}}},typeof(plot!),Plot{GRBackend}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis, :minorgrid), Tuple{Tuple{String, Symbol}, Bool}},typeof(plot!),Plot{GRBackend}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:yaxis, :minorgrid), Tuple{Tuple{String, Symbol}, Bool}},typeof(plot!)})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype), Tuple{Vector{Float64}, Tuple{Symbol, Float64, Stroke}, Vector{Float64}, String, Symbol}},typeof(plot!),Plot{GRBackend},Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:zcolor, :m, :ms, :lab, :seriestype), Tuple{Vector{Float64}, Tuple{Symbol, Float64, Stroke}, Vector{Float64}, String, Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{Float64}})
@@ -169,7 +179,7 @@ function _precompile_()
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:projection, :seriestype), Tuple{Symbol, Symbol}},typeof(plot),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},UnitRange{Int64},Matrix{Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:quiver, :seriestype), Tuple{Tuple{Vector{Float64}, Vector{Float64}, Vector{Float64}}, Symbol}},typeof(plot),Vector{Float64},Vector{Float64},Vector{Float64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:reg, :fill), Tuple{Bool, Tuple{Int64, Symbol}}},typeof(plot),Vector{Float64}})
-    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{Int64}},typeof(plot),UnitRange{Int64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}}},typeof(plot),UnitRange{Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{Tuple{LinRange{Float64}, LinRange{Float64}}}},typeof(plot),UnitRange{Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:ribbon,), Tuple{typeof(sqrt)}},typeof(plot),UnitRange{Int64}})
    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:seriestype, :markershape, :markersize, :color), Tuple{Matrix{Symbol}, Vector{Symbol}, Int64, Vector{Symbol}}},typeof(plot),Matrix{Float64}})
@@ -190,6 +200,7 @@ function _precompile_()
    Base.precompile(Tuple{Core.kwftype(typeof(scatter!)),Any,typeof(scatter!),Any})
    Base.precompile(Tuple{Core.kwftype(typeof(test_examples)),NamedTuple{(:skip, :disp), Tuple{Vector{Int64}, Bool}},typeof(test_examples),Symbol})
    Base.precompile(Tuple{Core.kwftype(typeof(test_examples)),NamedTuple{(:skip,), Tuple{Vector{Int64}}},typeof(test_examples),Symbol})
+    Base.precompile(Tuple{Type{GridLayout},Int64,Vararg{Int64, N} where N})
    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},AbstractVector{OHLC}})
    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},PortfolioComposition})
    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:barhist}},Any,Any,Any})
@@ -222,6 +233,7 @@ function _precompile_()
    Base.precompile(Tuple{typeof(_cbar_unique),Vector{PlotUtils.ContinuousColorGradient},String})
    Base.precompile(Tuple{typeof(_cbar_unique),Vector{StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}},String})
    Base.precompile(Tuple{typeof(_cbar_unique),Vector{Symbol},String})
+    Base.precompile(Tuple{typeof(_cycle),Vector{Float64},UnitRange{Int64}})
    Base.precompile(Tuple{typeof(_do_plot_show),Plot{GRBackend},Bool})
    Base.precompile(Tuple{typeof(_do_plot_show),Plot{PlotlyBackend},Bool})
    Base.precompile(Tuple{typeof(_heatmap_edges),Vector{Float64},Bool,Bool})
@@ -241,12 +253,15 @@ function _precompile_()
    Base.precompile(Tuple{typeof(build_layout),GridLayout,Int64,Vector{Plot}})
    Base.precompile(Tuple{typeof(convert_to_polar),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64},Tuple{Int64, Float64}})
    Base.precompile(Tuple{typeof(create_grid),Expr})
-    Base.precompile(Tuple{typeof(discrete_value!),Axis,Vector{String}})
+    Base.precompile(Tuple{typeof(default),Symbol,String})
+    Base.precompile(Tuple{typeof(error_coords),Vector{Float64},Vector{Float64},Vector{Float64},Vararg{Vector{Float64}, N} where N})
    Base.precompile(Tuple{typeof(error_coords),Vector{Float64},Vector{Float64},Vector{Float64}})
    Base.precompile(Tuple{typeof(error_zipit),Tuple{Vector{Float64}, Vector{Float64}, Vector{Float64}}})
+    Base.precompile(Tuple{typeof(expand_extrema!),Axis,UnitRange{Int64}})
    Base.precompile(Tuple{typeof(fakedata),Int64,Int64})
    Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Vector{Float64}, Vector{String}}})
    Base.precompile(Tuple{typeof(get_minor_ticks),Subplot{GRBackend},Axis,Tuple{Vector{Int64}, Vector{String}}})
+    Base.precompile(Tuple{typeof(get_series_color),PlotUtils.ContinuousColorGradient,Subplot{GRBackend},Int64,Symbol})
    Base.precompile(Tuple{typeof(get_ticks),StepRange{Int64, Int64},Vector{Float64},Vector{Any},Tuple{Int64, Int64},Vararg{Any, N} where N})
    Base.precompile(Tuple{typeof(get_ticks),Symbol,Vector{Float64},Vector{Any},Tuple{Float64, Float64},Vararg{Any, N} where N})
    Base.precompile(Tuple{typeof(get_ticks),Symbol,Vector{Float64},Vector{Any},Tuple{Int64, Float64},Vararg{Any, N} where N})
@@ -272,7 +287,6 @@ function _precompile_()
    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_segments),Series,StepRange{Int64, Int64},Vector{Float64},Int64,Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_segments),Series,Vector{Float64},Vector{Float64},Int64,Tuple{Float64, Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_segments_3d),Series,Vector{Float64},Vector{Float64},Vector{Float64},Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_shapes),Series,Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_surface),Series,Vector{Float64},Vector{Float64},Matrix{Float64},Tuple{Float64, Float64}})
    Base.precompile(Tuple{typeof(gr_draw_surface),Series,Vector{Float64},Vector{Float64},Vector{Float64},Tuple{Float64, Float64}})
@@ -292,6 +306,8 @@ function _precompile_()
    Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol,UnitRange{Int64},Symbol,Tuple{Int64, Int64},Bool})
    Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol,Vector{Float64},Symbol,Tuple{Int64, Int64},Bool})
    Base.precompile(Tuple{typeof(heatmap_edges),Vector{Float64},Symbol})
+    Base.precompile(Tuple{typeof(ignorenan_minimum),Vector{Int64}})
+    Base.precompile(Tuple{typeof(intersection_point),Float64,Float64,Float64,Float64,Float64,Float64})
    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Float64, Float64},Symbol,Function})
    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Float64, Float64},Symbol,Symbol})
    Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Int64, Float64},Symbol,Symbol})
@@ -321,11 +337,11 @@ function _precompile_()
    Base.precompile(Tuple{typeof(process_annotation),Subplot{PlotlyBackend},Int64,Float64,Tuple{String, Symbol, Int64, String}})
    Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},StepRange{Int64, Int64},Symbol})
    Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},Symbol,Symbol})
+    Base.precompile(Tuple{typeof(process_axis_arg!),Dict{Symbol, Any},Tuple{Int64, Int64},Symbol})
    Base.precompile(Tuple{typeof(push!),Plot{GRBackend},Float64,Vector{Float64}})
    Base.precompile(Tuple{typeof(resetfontsizes)})
    Base.precompile(Tuple{typeof(scalefontsizes),Float64})
    Base.precompile(Tuple{typeof(series_annotations),Vector{Any}})
-    Base.precompile(Tuple{typeof(slice_arg),Matrix{String},Int64})
    Base.precompile(Tuple{typeof(spy),Any})
    Base.precompile(Tuple{typeof(straightline_data),Tuple{Float64, Float64},Tuple{Float64, Float64},Vector{Float64},Vector{Float64},Int64})
    Base.precompile(Tuple{typeof(stroke),Int64,Vararg{Any, N} where N})
@@ -370,9 +386,9 @@ function _precompile_()
            precompile(fbody, (Any,typeof(title!),AbstractString,))
        end
    end
-    let fbody = try __lookup_kwbody__(which(wireframe, (Any,Vararg{Any, N} where N,))) catch missing end
+    let fbody = try __lookup_kwbody__(which(vline!, (Any,))) catch missing end
        if !ismissing(fbody)
-            precompile(fbody, (Any,typeof(wireframe),Any,Vararg{Any, N} where N,))
+            precompile(fbody, (Any,typeof(vline!),Any,))
        end
    end
 end
@@ -24,8 +24,9 @@ function add_aliases(sym::Symbol, aliases::Symbol...)
    return nothing
 end

-function add_axes_aliases(sym::Symbol, aliases::Symbol...)
+function add_axes_aliases(sym::Symbol, aliases::Symbol...; generic::Bool = true)
    sym in keys(_axis_defaults) || throw(ArgumentError("Invalid `$sym`"))
+    generic && add_aliases(sym, aliases...)
    for letter in (:x, :y, :z)
        add_aliases(Symbol(letter, sym), (Symbol(letter, a) for a in aliases)...)
    end
@@ -841,13 +842,20 @@ add_aliases(:markerstrokealpha, :msa, :msalpha, :msα, :markerstrokeopacity, :ms
 add_aliases(:fillalpha, :fa, :falpha, :fα, :fillopacity, :fopacity)

 # axes attributes
-add_axes_aliases(:guide, :label, :lab, :l)
+add_axes_aliases(:guide, :label, :lab, :l; generic = false)
 add_axes_aliases(:lims, :lim, :limit, :limits, :range)
 add_axes_aliases(:ticks, :tick)
 add_axes_aliases(:rotation, :rot, :r)
 add_axes_aliases(:guidefontsize, :labelfontsize)
 add_axes_aliases(:gridalpha, :ga, :galpha, :gα, :gridopacity, :gopacity)
-add_axes_aliases(:gridstyle, :grid_style, :gridlinestyle, :grid_linestyle, :grid_ls, :gridls)
+add_axes_aliases(
+    :gridstyle,
+    :grid_style,
+    :gridlinestyle,
+    :grid_linestyle,
+    :grid_ls,
+    :gridls,
+)
 add_axes_aliases(
    :foreground_color_grid,
    :fg_grid,
@@ -872,7 +880,14 @@ add_axes_aliases(
    :fg_colour_minor_grid,
    :minorgridcolor,
 )
-add_axes_aliases(:gridlinewidth, :gridwidth, :grid_linewidth, :grid_width, :gridlw, :grid_lw)
+add_axes_aliases(
+    :gridlinewidth,
+    :gridwidth,
+    :grid_linewidth,
+    :grid_width,
+    :gridlw,
+    :grid_lw,
+)
 add_axes_aliases(
    :minorgridstyle,
    :minorgrid_style,
@@ -1570,7 +1585,7 @@ function warn_on_unsupported_args(pkg::AbstractBackend, plotattributes)
    end

    if !isempty(_to_warn) &&
-       !get(plotattributes, :warn_on_unsupported, _plot_defaults[:warn_on_unsupported])
+       get(plotattributes, :warn_on_unsupported, _plot_defaults[:warn_on_unsupported])
        for k in sort(collect(_to_warn))
            push!(already_warned, k)
            @warn(
@@ -402,6 +402,7 @@ const _gr_attr = merge_with_base_supported([
    :tick_direction,
    :camera,
    :contour_labels,
+    :connections,
 ])
 const _gr_seriestype = [
    :path,
@@ -521,6 +522,7 @@ const _plotly_attr = merge_with_base_supported([
    :tick_direction,
    :camera,
    :contour_labels,
+    :connections,
 ])

 const _plotly_seriestype = [
@@ -777,6 +779,7 @@ const _pyplot_attr = merge_with_base_supported([
    :tick_direction,
    :camera,
    :contour_labels,
+    :connections,
 ])
 const _pyplot_seriestype = [
    :path,
@@ -793,6 +796,7 @@ const _pyplot_seriestype = [
    :contour3d,
    :path3d,
    :scatter3d,
+    :mesh3d,
    :surface,
    :wireframe,
 ]
@@ -860,6 +864,7 @@ const _gaston_attr = merge_with_base_supported([
    # :framestyle,
    # :camera,
    # :contour_labels,
+    :connections,
 ])

 const _gaston_seriestype = [
@@ -911,16 +916,21 @@ const _gaston_scale = [:identity, :ln, :log2, :log10]

 const _unicodeplots_attr = merge_with_base_supported([
    :annotations,
+    :bins,
+    :guide,
+    # :grid,
    :label,
+    :layout,
    :legend,
-    :seriescolor,
-    :seriesalpha,
+    :lims,
+    :linealpha,
+    :linecolor,
    :linestyle,
    :markershape,
-    :bins,
+    :seriesalpha,
+    :seriescolor,
+    :scale,
    :title,
-    :guide,
-    :lims,
 ])
 const _unicodeplots_seriestype = [
    :path,
@@ -1235,6 +1245,7 @@ const _pgfplotsx_attr = merge_with_base_supported([
    :tick_direction,
    :camera,
    :contour_labels,
+    :connections,
 ])
 const _pgfplotsx_seriestype = [
    :path,
@@ -512,10 +512,26 @@ function pgfx_add_series!(::Val{:heatmap}, axis, series_opt, series, series_func
 end

 function pgfx_add_series!(::Val{:mesh3d}, axis, series_opt, series, series_func, opt)
-    ptable = join(
-        [string(i, " ", j, " ", k, "\\\\") for (i, j, k) in zip(opt[:connections]...)],
-        "\n        ",
-    )
+    if opt[:connections] isa Tuple{Array,Array,Array}
+        # 0-based indexing
+        ptable = join(
+            [string(i, " ", j, " ", k, "\\\\") for (i, j, k) in zip(opt[:connections]...)],
+            "\n        ",
+        )
+    elseif typeof(opt[:connections]) <: AbstractVector{NTuple{3, Int}}
+        # 1-based indexing
+        ptable = join(
+            [string(i-1, " ", j-1, " ", k-1, "\\\\") for (i, j, k) in opt[:connections]],
+            "\n        ",
+        )
+    else
+        throw(
+            ArgumentError(
+                "Argument connections has to be either a tuple of three arrays (0-based indexing)
+                    or an AbstractVector{NTuple{3,Int}} (1-based indexing).",
+            ),
+        )
+    end
    push!(
        series_opt,
        "patch" => nothing,
@@ -678,6 +678,7 @@ function plotly_series(plt::Plot, series::Series)

        if series[:connections] !== nothing
            if typeof(series[:connections]) <: Tuple{Array,Array,Array}
+                # 0-based indexing
                i, j, k = series[:connections]
                if !(length(i) == length(j) == length(k))
                    throw(
@@ -689,10 +690,17 @@ function plotly_series(plt::Plot, series::Series)
                plotattributes_out[:i] = i
                plotattributes_out[:j] = j
                plotattributes_out[:k] = k
+            elseif typeof(series[:connections]) <: AbstractVector{NTuple{3, Int}}
+                # 1-based indexing
+                i, j, k = broadcast(i -> [ inds[i]-1 for inds in series[:connections]], (1, 2, 3))
+                plotattributes_out[:i] = i
+                plotattributes_out[:j] = j
+                plotattributes_out[:k] = k
            else
                throw(
                    ArgumentError(
-                        "Argument connections has to be a tuple of three arrays.",
+                        "Argument connections has to be either a tuple of three arrays (0-based indexing)
+                         or an AbstractVector{NTuple{3,Int}} (1-based indexing).",
                    ),
                )
            end
@@ -26,9 +26,25 @@ pyrcparams = PyPlot.PyDict(PyPlot.matplotlib."rcParams")

 # "support" matplotlib v3.4
 if PyPlot.version < v"3.4"
-    @warn("You are using Matplotlib $(PyPlot.version), which is no longer
+    @warn("""You are using Matplotlib $(PyPlot.version), which is no longer
    officialy supported by the Plots community. To ensure smooth Plots.jl
-    integration update your Matplotlib library to a version >= 3.4.0")
+    integration update your Matplotlib library to a version >= 3.4.0
+
+    If you have used Conda.jl to install PyPlot (default installation),
+    upgrade your matplotlib via Conda.jl and rebuild the PyPlot.
+
+    If you are not sure, here are the default instructions:
+
+    In Julia REPL:
+    ```
+    import Pkg;
+    Pkg.add("Conda")
+    import Conda
+    Conda.update()
+    Pkg.build("PyPlot")
+    ```
+
+    """)
 end

 set_facecolor_sym = if PyPlot.version < v"2"
@@ -682,6 +698,43 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
        end
    end

+    if st == :mesh3d
+        polygons = if series[:connections] isa AbstractVector{<:AbstractVector{Int}}
+            # Combination of any polygon types
+            broadcast(inds -> broadcast(i -> [x[i], y[i], z[i]], inds), series[:connections])
+        elseif series[:connections] isa AbstractVector{NTuple{N, Int}} where N
+            # Only N-gons - connections have to be 1-based (indexing)
+            broadcast(inds -> broadcast(i -> [x[i], y[i], z[i]], inds), series[:connections])
+        elseif series[:connections] isa NTuple{3,<:AbstractVector{Int}}
+            # Only triangles - connections have to be 0-based (indexing)
+            ci, cj, ck = series[:connections] 
+            if !(length(ci) == length(cj) == length(ck))
+                throw(
+                    ArgumentError("Argument connections must consist of equally sized arrays."),
+                )
+            end
+            broadcast(j -> broadcast(i -> [x[i], y[i], z[i]], [ci[j]+1, cj[j]+1, ck[j]+1]), eachindex(ci))
+        else
+            throw(
+                ArgumentError("Unsupported `:connections` type $(typeof(series[:connections])) for seriestype=$st"),
+            )
+        end
+        col = mplot3d.art3d.Poly3DCollection(polygons,
+            linewidths = py_thickness_scale(plt, series[:linewidth]), 
+            edgecolor = py_color(get_linecolor(series)),
+            facecolor = py_color(series[:fillcolor]),
+            alpha = get_fillalpha(series),
+            zorder = series[:series_plotindex]
+        )
+        handle = ax."add_collection3d"(col)
+        # Fix for handle: https://stackoverflow.com/questions/54994600/pyplot-legend-poly3dcollection-object-has-no-attribute-edgecolors2d
+        # It seems there aren't two different alpha values for edge and face
+        handle._facecolors2d = py_color(series[:fillcolor])
+        handle._edgecolors2d = py_color(get_linecolor(series))
+        push!(handles, handle)
+    end
+
+
    if st == :image
        xmin, xmax = ignorenan_extrema(series[:x])
        ymin, ymax = ignorenan_extrema(series[:y])
@@ -1219,7 +1272,7 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
            end

            py_set_scale(ax, sp, axis)
-            axis[:ticks] == :native ? nothing : py_set_lims(ax, sp, axis)
+            py_set_lims(ax, sp, axis)
            if ispolar(sp) && letter == :y
                ax."set_rlabel_position"(90)
            end
@@ -1254,7 +1307,14 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
                )
            end

-            axis[:ticks] == :native ? nothing : py_set_ticks(sp, ax, ticks, letter)
+            py_set_ticks(sp, ax, ticks, letter)
+
+            if axis[:ticks] == :native # It is easier to reset than to account for this
+                py_set_lims(ax, sp, axis)
+                pyaxis.set_major_locator(pyticker.AutoLocator())
+                pyaxis.set_major_formatter(pyticker.ScalarFormatter())
+            end
+
            # Tick marks
            intensity = 0.5  # This value corresponds to scaling of other grid elements
            pyaxis."set_tick_params"(
@@ -1,12 +1,10 @@
-
 # https://github.com/JuliaPlots/UnicodePlots.jl

 # don't warn on unsupported... there's just too many warnings!!
-warn_on_unsupported_args(::UnicodePlotsBackend, plotattributes::KW) = nothing
+warn_on_unsupported_args(::UnicodePlotsBackend, plotattributes) = nothing

-# --------------------------------------------------------------------------------------
-
-_canvas_map() = (
+# ------------------------------------------------------------------------------------------
+const _canvas_map = (
    ascii = UnicodePlots.AsciiCanvas,
    block = UnicodePlots.BlockCanvas,
    braille = UnicodePlots.BrailleCanvas,
@@ -16,22 +14,26 @@ _canvas_map() = (
    lookup = UnicodePlots.LookupCanvas,
 )

-# do all the magic here... build it all at once, since we need to know about all the series at the very beginning
+# do all the magic here... build it all at once,
+# since we need to know about all the series at the very beginning
 function unicodeplots_rebuild(plt::Plot{UnicodePlotsBackend})
    plt.o = UnicodePlots.Plot[]
-    canvas_map = _canvas_map()
+
    for sp in plt.subplots
        xaxis = sp[:xaxis]
        yaxis = sp[:yaxis]
        xlim = collect(axis_limits(sp, :x))
        ylim = collect(axis_limits(sp, :y))

-        # we set x/y to have a single point, since we need to create the plot with some data.
-        # since this point is at the bottom left corner of the plot, it shouldn't actually be shown
+        # we set x/y to have a single point,
+        # since we need to create the plot with some data.
+        # since this point is at the bottom left corner of the plot,
+        # it shouldn't actually be shown
        x = Float64[xlim[1]]
        y = Float64[ylim[1]]

-        # create a plot window with xlim/ylim set, but the X/Y vectors are outside the bounds
+        # create a plot window with xlim/ylim set,
+        # but the X/Y vectors are outside the bounds
        canvas_type = if (ct = _canvas_type[]) == :auto
            isijulia() ? :ascii : :braille
        else
@@ -39,17 +41,18 @@ function unicodeplots_rebuild(plt::Plot{UnicodePlotsBackend})
        end

        kw = (
+            compact = true,
            title = sp[:title],
-            xlim = xlim,
-            ylim = ylim,
-            border = isijulia() ? :ascii : :solid,
            xlabel = xaxis[:guide],
            ylabel = yaxis[:guide],
            xscale = xaxis[:scale],
            yscale = yaxis[:scale],
+            border = isijulia() ? :ascii : :solid,
+            xlim = xlim,
+            ylim = ylim,
        )

-        o = UnicodePlots.Plot(x, y, canvas_map[canvas_type]; kw...)
+        o = UnicodePlots.Plot(x, y, _canvas_map[canvas_type]; kw...)
        for series in series_list(sp)
            o = addUnicodeSeries!(sp, o, kw, series, sp[:legend] != :none)
        end
@@ -57,8 +60,13 @@ function unicodeplots_rebuild(plt::Plot{UnicodePlotsBackend})
        for ann in sp[:annotations]
            x, y, val = locate_annotation(sp, ann...)
            o = UnicodePlots.annotate!(
-                o, x, y, val.str;
-                color = up_color(val.font.color), halign = val.font.halign, valign = val.font.valign
+                o,
+                x,
+                y,
+                val.str;
+                color = up_color(val.font.color),
+                halign = val.font.halign,
+                valign = val.font.valign,
            )
        end

@@ -66,23 +74,18 @@ function unicodeplots_rebuild(plt::Plot{UnicodePlotsBackend})
    end
 end

-function up_color(col)
-    if typeof(col) <: UnicodePlots.UserColorType
-        color = col
-    elseif typeof(col) <: RGBA
-        col = convert(ARGB32, col)
-        color = map(Int, (red(col).i, green(col).i, blue(col).i))
-    else
-        color = :auto
-    end
-    color
-end
+up_color(col::UnicodePlots.UserColorType) = col
+up_color(col::RGBA) =
+    (c = convert(ARGB32, col); map(Int, (red(c).i, green(c).i, blue(c).i)))
+up_color(col) = :auto

 # add a single series
 function addUnicodeSeries!(
    sp::Subplot{UnicodePlotsBackend},
    up::UnicodePlots.Plot,
-    kw, series, addlegend::Bool,
+    kw,
+    series,
+    addlegend::Bool,
 )
    st = series[:seriestype]

@@ -106,7 +109,7 @@ function addUnicodeSeries!(
            series[:z].surf;
            zlabel = sp[:colorbar_title],
            colormap = cmap,
-            kw...
+            kw...,
        )
    elseif st == :spy
        return UnicodePlots.spy(series[:z].surf; kw...)
@@ -131,17 +134,23 @@ function addUnicodeSeries!(

    for (xi, yi, str, fnt) in EachAnn(series[:series_annotations], x, y)
        up = UnicodePlots.annotate!(
-            up, xi, yi, str;
-            color = up_color(fnt.color), halign = fnt.halign, valign = fnt.valign
+            up,
+            xi,
+            yi,
+            str;
+            color = up_color(fnt.color),
+            halign = fnt.halign,
+            valign = fnt.valign,
        )
    end

    return up
 end

-# -------------------------------
+# ------------------------------------------------------------------------------------------

-# since this is such a hack, it's only callable using `png`... should error during normal `show`
+# since this is such a hack, it's only callable using `png`...
+# should error during normal `show`
 function png(plt::Plot{UnicodePlotsBackend}, fn::AbstractString)
    fn = addExtension(fn, "png")

@@ -149,17 +158,10 @@ function png(plt::Plot{UnicodePlotsBackend}, fn::AbstractString)
        # make some whitespace and show the plot
        println("\n\n\n\n\n\n")
        gui(plt)
-
-        # BEGIN HACK
-
-        # wait while the plot gets drawn
        sleep(0.5)
-
-        # use osx screen capture when my terminal is maximized and cursor starts at the bottom (I know, right?)
-        # TODO: compute size of plot to adjust these numbers (or maybe implement something good??)
+        # use osx screen capture when my terminal is maximized
+        # and cursor starts at the bottom (I know, right?)
        run(`screencapture -R50,600,700,420 $fn`)
-
-        # END HACK (phew)
        return
    elseif Sys.islinux()
        run(`clear`)
@@ -169,12 +171,14 @@ function png(plt::Plot{UnicodePlotsBackend}, fn::AbstractString)
    end

    error(
-        "Can only savepng on MacOS or Linux with UnicodePlots (though even then I wouldn't do it)",
+        "Can only savepng on MacOS or Linux with UnicodePlots " *
+        "(though even then I wouldn't do it)",
    )
 end

-# -------------------------------
-Base.show(plt::Plot{UnicodePlotsBackend}) = _show(stdout, MIME("text/plain"), plt)
+# ------------------------------------------------------------------------------------------
+Base.show(plt::Plot{UnicodePlotsBackend}) = show(stdout, plt)
+Base.show(io::IO, plt::Plot{UnicodePlotsBackend}) = _show(io, MIME("text/plain"), plt)

 function _show(io::IO, ::MIME"text/plain", plt::Plot{UnicodePlotsBackend})
    unicodeplots_rebuild(plt)
@@ -182,9 +186,11 @@ function _show(io::IO, ::MIME"text/plain", plt::Plot{UnicodePlotsBackend})
    lines_colored = Array{Union{Nothing,Vector{String}}}(undef, nr, nc)
    lines_uncolored = copy(lines_colored)
    l_max = zeros(Int, nr)
+    w_max = zeros(Int, nc)
    buf = IOBuffer()
    cbuf = IOContext(buf, :color => true)
-    sps = wmax = 0
+    re_col = r"\x1B\[[0-9;]*[a-zA-Z]"
+    sps = 0
    for r in 1:nr
        lmax = 0
        for c in 1:nc
@@ -198,27 +204,27 @@ function _show(io::IO, ::MIME"text/plain", plt::Plot{UnicodePlotsBackend})
                    sp = plt.o[sps += 1]
                    show(cbuf, sp)
                    colored = String(take!(buf))
-                    uncolored = replace(colored, r"\x1B\[[0-9;]*[a-zA-Z]" => "")
+                    uncolored = replace(colored, re_col => "")
                    lines_colored[r, c] = lc = split(colored, "\n")
                    lines_uncolored[r, c] = lu = split(uncolored, "\n")
                    lmax = max(length(lc), lmax)
-                    wmax = max(maximum(length.(lu)), wmax)
+                    w_max[c] = max(maximum(length.(lu)), w_max[c])
                end
            end
        end
        l_max[r] = lmax
    end
-    empty = ' '^wmax
+    empty = String[' '^w for w in w_max]
    for r in 1:nr
        for n in 1:l_max[r]
            for c in 1:nc
                pre = c == 1 ? '\0' : ' '
                lc = lines_colored[r, c]
                if lc === nothing || length(lc) < n
-                    print(io, pre, empty)
+                    print(io, pre, empty[c])
                else
                    lu = lines_uncolored[r, c]
-                    print(io, pre, lc[n], ' '^(wmax - length(lu[n])))
+                    print(io, pre, lc[n], ' '^(w_max[c] - length(lu[n])))
                end
            end
            println(io)
@@ -5,7 +5,7 @@ process_clims(s::Union{Symbol,Nothing,Missing}) = ignorenan_extrema
 # don't specialize on ::Function otherwise python functions won't work
 process_clims(f) = f

-function get_clims(sp::Subplot, op = process_clims(sp[:clims]))
+function get_clims(sp::Subplot, op = process_clims(sp[:clims]))::Tuple{Float64, Float64}
    zmin, zmax = Inf, -Inf
    for series in series_list(sp)
        if series[:colorbar_entry]
@@ -15,7 +15,7 @@ function get_clims(sp::Subplot, op = process_clims(sp[:clims]))
    return zmin <= zmax ? (zmin, zmax) : (NaN, NaN)
 end

-function get_clims(sp::Subplot, series::Series, op = process_clims(sp[:clims]))
+function get_clims(sp::Subplot, series::Series, op = process_clims(sp[:clims]))::Tuple{Float64, Float64}
    zmin, zmax = if series[:colorbar_entry]
        get_clims(sp, op)
    else
@@ -31,7 +31,7 @@ Finds the limits for the colorbar by taking the "z-values" for the series and pa
 which must return the tuple `(zmin, zmax)`. The default op is the extrema of the finite
 values of the input.
 """
-function get_clims(series::Series, op = ignorenan_extrema)
+function get_clims(series::Series, op = ignorenan_extrema)::Tuple{Float64, Float64}
    zmin, zmax = Inf, -Inf
    z_colored_series = (:contour, :contour3d, :heatmap, :histogram2d, :surface, :hexbin)
    for vals in (
@@ -962,8 +962,10 @@ const _examples = PlotExample[
        """
        Allows to plot arbitrary 3d meshes. If only x,y,z are given the mesh is generated automatically.
        You can also specify the connections using the connections keyword.
-        The connections are specified using a tuple of vectors. Each vector contains the 0-based indices of one point of a triangle,
-        such that elements at the same position of these vectors form a triangle.
+        The connections can be specified in two ways: Either as a tuple of vectors where each vector 
+        contains the 0-based indices of one point of a triangle, such that elements at the same 
+        position of these vectors form a triangle. Or as a vector of NTuple{3,Ints} where each element 
+        contains the 1-based indices of the three points of a triangle.
        """,
        [
            :(
@@ -979,13 +981,14 @@ const _examples = PlotExample[
                    i = [0, 0, 0, 1]
                    j = [1, 2, 3, 2]
                    k = [2, 3, 1, 3]
+                    # Or: cns = [(1, 2, 3), (1, 3, 4), (1, 4, 2), (2, 3, 4)] (1-based indexing)

                    # the four triangles gives above give a tetrahedron
                    mesh3d(
                        x,
                        y,
                        z;
-                        connections = (i, j, k),
+                        connections = (i, j, k), # connections = cns
                        title = "triangles",
                        xlabel = "x",
                        ylabel = "y",
@@ -1235,7 +1238,7 @@ const _examples = PlotExample[
 _animation_examples = [2, 31]
 _backend_skips = Dict(
    :gr => [25, 30],
-    :pyplot => [2, 25, 30, 31, 47, 49, 55],
+    :pyplot => [2, 25, 30, 31, 49, 55],
    :plotlyjs => [2, 21, 24, 25, 30, 31, 49, 51, 55],
    :plotly => [2, 21, 24, 25, 30, 31, 49, 50, 51, 55],
    :pgfplotsx => [
@@ -7,10 +7,9 @@ ismultiversion = false
@static if !should_precompile
    # nothing
 elseif !ismultios && !ismultiversion
-    @static if isfile(joinpath(
-        @__DIR__,
-        "../deps/SnoopCompile/precompile/precompile_Plots.jl",
-    ))
+    @static if isfile(
+        joinpath(@__DIR__, "../deps/SnoopCompile/precompile/precompile_Plots.jl"),
+    )
        include("../deps/SnoopCompile/precompile/precompile_Plots.jl")
        _precompile_()
    end
@@ -205,13 +205,14 @@ maketuple(x::Tuple{T,S}) where {T,S} = x
 for i in 2:4
    @eval begin
        RecipesPipeline.unzip(
-            v::Union{AVec{<:NTuple{$i,T} where T},AVec{<:GeometryBasics.Point{$i}}},
+            v::Union{AVec{<:NTuple{$i,T} where {T}},AVec{<:GeometryBasics.Point{$i}}},
        ) = $(Expr(:tuple, (:([t[$j] for t in v]) for j in 1:i)...))
    end
 end

-RecipesPipeline.unzip(::Union{AVec{<:GeometryBasics.Point{N}},AVec{<:NTuple{N,T} where T}}) where {N} = 
-    error("$N-dimensional unzip not implemented.")
+RecipesPipeline.unzip(
+    ::Union{AVec{<:GeometryBasics.Point{N}},AVec{<:NTuple{N,T} where {T}}},
+) where {N} = error("$N-dimensional unzip not implemented.")

 RecipesPipeline.unzip(::Union{AVec{<:GeometryBasics.Point},AVec{<:Tuple}}) =
    error("Can't unzip points of different dimensions.")
@@ -1180,16 +1181,12 @@ end
 _document_argument(S::AbstractString) =
    _fmt_paragraph("`$S`: " * _arg_desc[Symbol(S)], leadingspaces = 6 + length(S))

-function mesh3d_triangles(x, y, z, cns)
-    if typeof(cns) <: Tuple{Array,Array,Array}
-        ci, cj, ck = cns
-        if !(length(ci) == length(cj) == length(ck))
-            throw(
-                ArgumentError("Argument connections must consist of equally sized arrays."),
-            )
-        end
-    else
-        throw(ArgumentError("Argument connections has to be a tuple of three arrays."))
+function mesh3d_triangles(x, y, z, cns::Tuple{Array,Array,Array})
+    ci, cj, ck = cns
+    if !(length(ci) == length(cj) == length(ck))
+        throw(
+            ArgumentError("Argument connections must consist of equally sized arrays."),
+        )
    end
    X = zeros(eltype(x), 4length(ci))
    Y = zeros(eltype(y), 4length(cj))
@@ -1214,6 +1211,30 @@ function mesh3d_triangles(x, y, z, cns)
    end
    return X, Y, Z
 end
+function mesh3d_triangles(x, y, z, cns::AbstractVector{NTuple{3, Int}})
+    X = zeros(eltype(x), 4length(cns))
+    Y = zeros(eltype(y), 4length(cns))
+    Z = zeros(eltype(z), 4length(cns))
+    @inbounds for I in 1:length(cns)
+        i = cns[I][1]  # connections are 1-based
+        j = cns[I][2]
+        k = cns[I][3]
+        m = 4(I - 1) + 1
+        n = m + 1
+        o = m + 2
+        p = m + 3
+        X[m] = X[p] = x[i]
+        Y[m] = Y[p] = y[i]
+        Z[m] = Z[p] = z[i]
+        X[n] = x[j]
+        Y[n] = y[j]
+        Z[n] = z[j]
+        X[o] = x[k]
+        Y[o] = y[k]
+        Z[o] = z[k]
+    end
+    return X, Y, Z
+end

 # cache joined symbols so they can be looked up instead of constructed each time
 const _attrsymbolcache = Dict{Symbol,Dict{Symbol,Symbol}}()
@@ -1,18 +1,20 @@
 using Plots: guidefont, series_annotations, PLOTS_SEED
-import ImageMagick
+
 using VisualRegressionTests
-using Plots
-using Random
-using StableRNGs
-using Test
-using TestImages
-using FileIO
-using Gtk
-using LibGit2
-import GeometryBasics
-using Dates
 using RecipesBase
+using StableRNGs
+using TestImages
+using LibGit2
+using Random
+using FileIO
+using Plots
+using Dates
 using JSON
+using Test
+using Gtk
+
+import GeometryBasics
+import ImageMagick

@testset "Infrastructure" begin
    @test_nowarn JSON.Parser.parse(
@@ -33,7 +35,7 @@ end
    end
    Plots.plotly_local_file_path[] = nothing
    Plots.use_local_dependencies[] = temp
-end # testset
+end

 include("test_defaults.jl")
 include("test_pipeline.jl")
@@ -55,7 +57,6 @@ function reference_file(backend, i, version)
    refdir = reference_dir("Plots", string(backend))
    fn = "ref$i.png"
    versions = sort(VersionNumber.(readdir(refdir)), rev = true)
-
    reffn = joinpath(refdir, string(version), fn)
    for v in versions
        tmpfn = joinpath(refdir, string(v), fn)
@@ -64,7 +65,6 @@ function reference_file(backend, i, version)
            break
        end
    end
-
    return reffn
 end

@@ -79,9 +79,10 @@ if !isdir(reference_dir())
 end

 include("imgcomp.jl")
-# don't actually show the plots
 Random.seed!(PLOTS_SEED)
-default(show = false, reuse = true)
+
+default(show = false, reuse = true)  # don't actually show the plots
+
 is_ci() = get(ENV, "CI", "false") == "true"
 const PLOTS_IMG_TOL = parse(Float64, get(ENV, "PLOTS_IMG_TOL", is_ci() ? "1e-4" : "1e-5"))

@@ -106,66 +107,8 @@ const PLOTS_IMG_TOL = parse(Float64, get(ENV, "PLOTS_IMG_TOL", is_ci() ? "1e-4"
 #     image_comparison_facts(:pgfplotsx, tol=PLOTS_IMG_TOL, skip = Plots._backend_skips[:pgfplotsx])
 # end

-# 10 Histogram2D
-
 ##

-@testset "Backends" begin
-    @testset "GR" begin
-        ENV["PLOTS_TEST"] = "true"
-        ENV["GKSwstype"] = "100"
-        @test gr() == Plots.GRBackend()
-        @test backend() == Plots.GRBackend()
-
-        @static if haskey(ENV, "APPVEYOR")
-            @info "Skipping GR image comparison tests on AppVeyor"
-        else
-            image_comparison_facts(
-                :gr,
-                tol = PLOTS_IMG_TOL,
-                skip = Plots._backend_skips[:gr],
-            )
-        end
-    end
-
-    @testset "UnicodePlots" begin
-        @test unicodeplots() == Plots.UnicodePlotsBackend()
-        @test backend() == Plots.UnicodePlotsBackend()
-
-        # lets just make sure it runs without error
-        p = plot(rand(10))
-        @test isa(p, Plots.Plot) == true
-        @test isa(display(p), Nothing) == true
-        p = bar(randn(10))
-        @test isa(p, Plots.Plot) == true
-        @test isa(display(p), Nothing) == true
-        p = plot([1, 2], [3, 4])
-        annotate!(p, [(1.5, 3.2, Plots.text("Test", :red, :center))])
-        hline!(p, [3.1])
-        @test isa(p, Plots.Plot) == true
-        @test isa(display(p), Nothing) == true
-        p = plot([Dates.Date(2019, 1, 1), Dates.Date(2019, 2, 1)], [3, 4])
-        hline!(p, [3.1])
-        annotate!(p, [(Dates.Date(2019, 1, 15), 3.2, Plots.text("Test", :red, :center))])
-        @test isa(p, Plots.Plot) == true
-        @test isa(display(p), Nothing) == true
-        p = plot([Dates.Date(2019, 1, 1), Dates.Date(2019, 2, 1)], [3, 4])
-        annotate!(p, [(Dates.Date(2019, 1, 15), 3.2, :auto)])
-        hline!(p, [3.1])
-        @test isa(p, Plots.Plot) == true
-        @test isa(display(p), Nothing) == true
-    end
-
-    @testset "PlotlyJS" begin
-        @test plotlyjs() == Plots.PlotlyJSBackend()
-        @test backend() == Plots.PlotlyJSBackend()
-
-        p = plot(rand(10))
-        @test isa(p, Plots.Plot) == true
-        @test_broken isa(display(p), Nothing) == true
-    end
-end
-
@testset "Axes" begin
    p = plot()
    axis = p.subplots[1][:xaxis]
@@ -181,10 +124,12 @@ end
 end

@testset "NoFail" begin
-    #ensure backend with tested display
+    # ensure backend with tested display
    @test unicodeplots() == Plots.UnicodePlotsBackend()
    @test backend() == Plots.UnicodePlotsBackend()

+    dsp = TextDisplay(IOContext(IOBuffer(), :color => true))
+
    @testset "Plot" begin
        plots = [
            histogram([1, 0, 0, 0, 0, 0]),
@@ -197,15 +142,15 @@ end
            plot(["a" "b"; missing "d"], [1 2; 3 4]),
        ]
        for plt in plots
-            display(plt)
+            display(dsp, plt)
        end
        @test_nowarn plot(x -> x^2, 0, 2)
    end

    @testset "Bar" begin
        p = bar([3, 2, 1], [1, 2, 3])
-        @test isa(p, Plots.Plot)
-        @test isa(display(p), Nothing) == true
+        @test p isa Plots.Plot
+        @test display(dsp, p) isa Nothing
    end
 end

@@ -255,3 +200,61 @@ end
          Plots.process_clims(missing) ==
          Plots.process_clims(:auto)
 end
+
+@testset "Backends" begin
+    @testset "UnicodePlots" begin
+        @test unicodeplots() == Plots.UnicodePlotsBackend()
+        @test backend() == Plots.UnicodePlotsBackend()
+
+        io = IOContext(IOBuffer(), :color => true)
+
+        # lets just make sure it runs without error
+        p = plot(rand(10))
+        @test p isa Plots.Plot
+        @test show(io, p) isa Nothing
+        p = bar(randn(10))
+        @test p isa Plots.Plot
+        @test show(io, p) isa Nothing
+        p = plot([1, 2], [3, 4])
+        annotate!(p, [(1.5, 3.2, Plots.text("Test", :red, :center))])
+        hline!(p, [3.1])
+        @test p isa Plots.Plot
+        @test show(io, p) isa Nothing
+        p = plot([Dates.Date(2019, 1, 1), Dates.Date(2019, 2, 1)], [3, 4])
+        hline!(p, [3.1])
+        annotate!(p, [(Dates.Date(2019, 1, 15), 3.2, Plots.text("Test", :red, :center))])
+        @test p isa Plots.Plot
+        @test show(io, p) isa Nothing
+        p = plot([Dates.Date(2019, 1, 1), Dates.Date(2019, 2, 1)], [3, 4])
+        annotate!(p, [(Dates.Date(2019, 1, 15), 3.2, :auto)])
+        hline!(p, [3.1])
+        @test p isa Plots.Plot
+        @test show(io, p) isa Nothing
+    end
+
+    @testset "PlotlyJS" begin
+        @test plotlyjs() == Plots.PlotlyJSBackend()
+        @test backend() == Plots.PlotlyJSBackend()
+
+        p = plot(rand(10))
+        @test p isa Plots.Plot
+        @test_broken display(p) isa Nothing
+    end
+
+    @testset "GR" begin
+        ENV["PLOTS_TEST"] = "true"
+        ENV["GKSwstype"] = "100"
+        @test gr() == Plots.GRBackend()
+        @test backend() == Plots.GRBackend()
+
+        @static if haskey(ENV, "APPVEYOR")
+            @info "Skipping GR image comparison tests on AppVeyor"
+        else
+            image_comparison_facts(
+                :gr,
+                tol = PLOTS_IMG_TOL,
+                skip = Plots._backend_skips[:gr],
+            )
+        end
+    end
+end
@@ -64,7 +64,7 @@ end
    @test twpl[:bottom_margin] == 2Plots.cm
 end

-@testset "aliases" begin
+@testset "axis-aliases" begin
    p = plot(1:2, xl = "x label")
    @test p[1][:xaxis][:guide] === "x label"
    p = plot(1:2, xrange = (0, 3))
@@ -73,18 +73,47 @@ end
    @test p[1][:xaxis][:ticks] == [1.25, 1.5, 1.75]
    p = plot(1:2, xlabelfontsize = 4)
    @test p[1][:xaxis][:guidefontsize] == 4
-    p = plot(1:2, xgα = .07)
-    @test p[1][:xaxis][:gridalpha] ≈ .07
+    p = plot(1:2, xgα = 0.07)
+    @test p[1][:xaxis][:gridalpha] ≈ 0.07
    p = plot(1:2, xgridls = :dashdot)
    @test p[1][:xaxis][:gridstyle] === :dashdot
    p = plot(1:2, xgridcolor = :red)
-    @test p[1][:xaxis][:foreground_color_grid] === RGBA{Float64}(1.,0.,0.,1.)
+    @test p[1][:xaxis][:foreground_color_grid] === RGBA{Float64}(1.0, 0.0, 0.0, 1.0)
    p = plot(1:2, xminorgridcolor = :red)
-    @test p[1][:xaxis][:foreground_color_minor_grid] === RGBA{Float64}(1.,0.,0.,1.)
-    p = plot(1:2, xgrid_lw = .01)
-    @test p[1][:xaxis][:gridlinewidth] ≈ .01
-    p = plot(1:2, xminorgrid_lw = .01)
-    @test p[1][:xaxis][:minorgridlinewidth] ≈ .01
+    @test p[1][:xaxis][:foreground_color_minor_grid] === RGBA{Float64}(1.0, 0.0, 0.0, 1.0)
+    p = plot(1:2, xgrid_lw = 0.01)
+    @test p[1][:xaxis][:gridlinewidth] ≈ 0.01
+    p = plot(1:2, xminorgrid_lw = 0.01)
+    @test p[1][:xaxis][:minorgridlinewidth] ≈ 0.01
    p = plot(1:2, xtickor = :out)
    @test p[1][:xaxis][:tick_direction] === :out
 end
+
+@testset "aliases" begin
+    compare(p::Plots.Plot, s::Symbol, val, op) =
+        op(p[1][:xaxis][s], val) && op(p[1][:yaxis][s], val) && op(p[1][:zaxis][s], val)
+    p = plot(1:2, guide = "all labels")
+    @test compare(p, :guide, "all labels", ===)
+    p = plot(1:2, label = "test")
+    @test compare(p, :guide, "", ===)
+    p = plot(1:2, lim = (0, 3))
+    @test xlims(p) === ylims(p) === zlims(p) === (0, 3)
+    p = plot(1:2, tick = [1.25, 1.5, 1.75])
+    @test compare(p, :ticks, [1.25, 1.5, 1.75], ==)
+    p = plot(1:2, labelfontsize = 4)
+    @test compare(p, :guidefontsize, 4, ==)
+    p = plot(1:2, gα = 0.07)
+    @test compare(p, :gridalpha, 0.07, ≈)
+    p = plot(1:2, gridls = :dashdot)
+    @test compare(p, :gridstyle, :dashdot, ===)
+    p = plot(1:2, gridcolor = :red)
+    @test compare(p, :foreground_color_grid, RGBA{Float64}(1.0, 0.0, 0.0, 1.0), ===)
+    p = plot(1:2, minorgridcolor = :red)
+    @test compare(p, :foreground_color_minor_grid, RGBA{Float64}(1.0, 0.0, 0.0, 1.0), ===)
+    p = plot(1:2, grid_lw = 0.01)
+    @test compare(p, :gridlinewidth, 0.01, ≈)
+    p = plot(1:2, minorgrid_lw = 0.01)
+    @test compare(p, :minorgridlinewidth, 0.01, ≈)
+    p = plot(1:2, tickor = :out)
+    @test compare(p, :tick_direction, :out, ===)
+end
Author	SHA1	Message	Date
Simon Christ	acca707f34	1.22.2 [skip ci]	2021-09-22 21:21:13 +02:00
Nicholas Bauer	6fa3dae166	Fix type inference failure in `get_clims` (#3838 ) * For Shape type, cut off process * Remove fillcolor for now * NaN * Address type inference failure instead	2021-09-22 19:18:57 +02:00
Lukas Hauertmann	866cb0c335	Add `:mesh3d` seriesstyle for PyPlot backend (#3835 ) * Add `:mesh3d` seriesstyle for PyPlot backend via `Poly3DCollection`. * Add `:connections` to lists of supported keywords for the backends which support `:mesh3d` as series type. * Remove #47 from list of skipping examples for PyPlot * Add support for only-triangle syntax for `:connections` kw for PyPlot * Add 1-based indexing syntax for `connections` kw in `:mesh3d` * Update description for example `#47` (`:mesh3d`) * Hotfix 1-based indexing for mesh3d in pgfplotsx	2021-09-22 17:12:11 +02:00
t-bltg	4d40bae9cc	Update bug.md update supported backends	2021-09-21 00:28:51 +02:00
github-actions[bot]	5a48002d31	Format .jl files [skip ci] (#3829 ) Co-authored-by: t-bltg <t-bltg@users.noreply.github.com>	2021-09-20 16:10:29 +02:00
t-bltg	0cd81243ad	UnicodePlots: `compact` plots	2021-09-18 14:13:37 +02:00
t-bltg	ed3bab0e6f	1.22.1 [skip ci]	2021-09-17 22:11:50 +02:00
github-actions[bot]	4621c18b23	Update precompile_*.jl file [skip ci] (#3822 ) Co-authored-by: t-bltg <t-bltg@users.noreply.github.com>	2021-09-17 22:10:48 +02:00
BerndR	4f8a265c6a	Fix generic aliases (#3824 )	2021-09-17 21:43:26 +02:00
t-bltg	e2539a3d19	UnicodePlots: adjust layout width per column (#3825 )	2021-09-17 21:42:50 +02:00
t-bltg	85739932f0	Negate condition on `:warn_on_unsupported` (#3816 )	2021-09-17 14:55:43 +02:00
t-bltg	9d84e53bcb	Test cleanup (#3821 )	2021-09-17 12:00:40 +02:00
zhanibek	82f31c48b7	pyplot fixing ticks=:native	2021-09-17 16:30:22 +09:00
zhanibek	81571fe534	fix typos	2021-09-17 14:44:16 +09:00
zhanibek	293b8b112e	instructions for matplotlib update	2021-09-17 14:38:24 +09:00