fix vector of shapes

.github/workflows/ci.yml

@@ -71,10 +71,7 @@ jobs:
 
       # Run tests
       - name: Run Graphical test
-        run:  |
-          $TESTCMD --project -e 'using Pkg; Pkg.test(coverage=true);'
-          $TESTCMD -e 'using Pkg; Pkg.activate(tempdir()); Pkg.develop(path=abspath(".")); Pkg.add("StatsPlots"); Pkg.test("StatsPlots");'
-          $TESTCMD -e 'using Pkg; Pkg.activate(tempdir()); Pkg.develop(path=abspath(".")); Pkg.add("GraphRecipes"); Pkg.test("GraphRecipes");'
+        run:  $TESTCMD --project -e 'using Pkg; Pkg.test(coverage=true);'
 
       - name: Codecov
         uses: julia-actions/julia-uploadcodecov@latest

.zenodo.json

@@ -683,10 +683,6 @@
             "affiliation": "University of Cambridge",
             "name": "Will Tebbutt",
             "type": "Other"
-        },
-        {
-            "name": "@t-bltg",
-            "type": "Other"
         }
     ],
     "upload_type": "software"

Project.toml

@@ -1,7 +1,7 @@
 name = "Plots"
 uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
 author = ["Tom Breloff (@tbreloff)"]
-version = "1.16.2"
+version = "1.15.1"
 
 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
@@ -36,7 +36,7 @@ UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
 Contour = "0.5"
 FFMPEG = "0.2, 0.3, 0.4"
 FixedPointNumbers = "0.6, 0.7, 0.8"
-GR = "0.53, 0.54, 0.55, 0.57"
+GR = "0.46, 0.47, 0.48, 0.49, 0.50, 0.51, 0.52, 0.53, 0.54, 0.55, 0.57"
 GeometryBasics = "0.2, 0.3.1"
 JSON = "0.21, 1"
 Latexify = "0.14, 0.15"

deps/SnoopCompile/precompile/precompile_Plots.jl

@@ -97,15 +97,14 @@ function _precompile_()
     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)})
-    Base.precompile(Tuple{Core.kwftype(typeof(font)),NamedTuple{(:family, :pointsize, :valign, :halign, :rotation, :color), Tuple{String, Int64, Symbol, Symbol, Float64, RGBA{Float64}}},typeof(font)})
     Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),StepRange{Int64, Int64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),UnitRange{Int64},UnitRange{Int64}})
     Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),UnitRange{Int64},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(gr_polyline)),NamedTuple{(:arrowside, :arrowstyle), Tuple{Symbol, Symbol}},typeof(gr_polyline),Vector{Int64},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(gr_set_font)),NamedTuple{(:halign, :valign, :rotation), Tuple{Symbol, Symbol, Int64}},typeof(gr_set_font),Font,Subplot{GRBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(gr_set_font)),NamedTuple{(:halign, :valign, :rotation, :color), Tuple{Symbol, Symbol, Int64, RGBA{Float64}}},typeof(gr_set_font),Font,Subplot{GRBackend}})
     Base.precompile(Tuple{Core.kwftype(typeof(hline!)),Any,typeof(hline!),Any})
-    Base.precompile(Tuple{Core.kwftype(typeof(pie)),Any,typeof(pie),Any,Vararg{Any, N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Plot{GRBackend},Vector{GeometryBasics.Point2{Float64}}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{GeometryBasics.Point2{Float64}}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:alpha, :seriestype), Tuple{Float64, Symbol}},typeof(plot!),Vector{GeometryBasics.Point2{Float64}}})
@@ -119,6 +118,7 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype), Tuple{Tuple{Int64, Float64, Symbol}, Vector{Any}, Symbol}},typeof(plot!),Plot{PlotlyBackend},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vararg{Any, N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:marker, :series_annotations, :seriestype), Tuple{Tuple{Int64, Float64, Symbol}, Vector{Any}, Symbol}},typeof(plot!),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:markersize, :c, :seriestype), Tuple{Int64, Symbol, Symbol}},typeof(plot!),Plot{GRBackend},Vector{Float64}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:markersize, :c, :seriestype), Tuple{Int64, Symbol, Symbol}},typeof(plot!),Plot{PlotlyBackend},Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot!)),NamedTuple{(:markersize, :c, :seriestype), Tuple{Int64, Symbol, Symbol}},typeof(plot!),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{GRBackend},Vector{Int64},Vararg{Any, N} where N})
     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},Vararg{Any, N} where N})
@@ -147,6 +147,7 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:lab, :w, :palette, :fill, :α), Tuple{String, Int64, PlotUtils.ContinuousColorGradient, Int64, Float64}},typeof(plot),StepRange{Int64, Int64},Matrix{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:label, :title, :xlabel, :linewidth, :legend), Tuple{Matrix{String}, String, String, Int64, Symbol}},typeof(plot),Vector{Function},Float64,Vararg{Float64, N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:label,), Tuple{Matrix{String}}},typeof(plot),Vector{AbstractVector{Float64}}})
+    Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:labels,), Tuple{Matrix{String}}},typeof(plot),PortfolioComposition})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :group, :linetype, :linecolor), Tuple{GridLayout, Vector{String}, Matrix{Symbol}, Symbol}},typeof(plot),Vector{Float64}})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :label, :fillrange, :fillalpha), Tuple{Tuple{Int64, Int64}, String, Int64, Float64}},typeof(plot),Plot{GRBackend},Plot{GRBackend},Vararg{Plot{GRBackend}, N} where N})
     Base.precompile(Tuple{Core.kwftype(typeof(plot)),NamedTuple{(:layout, :label, :fillrange, :fillalpha), Tuple{Tuple{Int64, Int64}, String, Int64, Float64}},typeof(plot),Plot{PlotlyBackend},Plot{PlotlyBackend},Vararg{Plot{PlotlyBackend}, N} where N})
@@ -213,7 +214,6 @@ function _precompile_()
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:lens}},AbstractPlot})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:pie}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:quiver}},Any,Any,Any})
-    Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:spy}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:steppre}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:sticks}},Any,Any,Any})
     Base.precompile(Tuple{typeof(RecipesBase.apply_recipe),AbstractDict{Symbol, Any},Type{Val{:vline}},Any,Any,Any})
@@ -239,8 +239,8 @@ function _precompile_()
     Base.precompile(Tuple{typeof(_cycle),Base.OneTo{Int64},Vector{Int64}})
     Base.precompile(Tuple{typeof(_cycle),StepRange{Int64, Int64},Vector{Int64}})
     Base.precompile(Tuple{typeof(_cycle),Vector{Float64},StepRange{Int64, Int64}})
-    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})
     Base.precompile(Tuple{typeof(_plot!),Plot,Any,Any})
     Base.precompile(Tuple{typeof(_preprocess_barlike),DefaultsDict,Base.OneTo{Int64},Vector{Float64}})
@@ -255,22 +255,21 @@ function _precompile_()
     Base.precompile(Tuple{typeof(bbox),Float64,Float64,Float64,Float64})
     Base.precompile(Tuple{typeof(build_layout),GridLayout,Int64})
     Base.precompile(Tuple{typeof(contour),Any,Vararg{Any, N} where N})
-    Base.precompile(Tuple{typeof(convertLegendValue),Symbol})
     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(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,Base.OneTo{Int64}})
+    Base.precompile(Tuple{typeof(font),String,Vararg{Any, N} where N})
     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),Vector{Symbol},Subplot{GRBackend},Int64,Symbol})
+    Base.precompile(Tuple{typeof(get_series_color),Vector{Symbol},Subplot{PlotlyBackend},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})
     Base.precompile(Tuple{typeof(get_ticks),Symbol,Vector{Float64},Vector{Any},Tuple{Int64, Int64},Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(get_ticks),UnitRange{Int64},Vector{Float64},Vector{Any},Tuple{Float64, Float64},Vararg{Any, N} where N})
-    Base.precompile(Tuple{typeof(get_xy),OHLC{Float64},Int64,Float64})
     Base.precompile(Tuple{typeof(get_xy),Vector{OHLC}})
     Base.precompile(Tuple{typeof(gr_add_legend),Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), NTuple{9, Float64}},Vector{Float64}})
     Base.precompile(Tuple{typeof(gr_add_legend),Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), Tuple{Int64, Float64, Float64, Float64, Int64, Float64, Float64, Float64, Float64}},Vector{Float64}})
@@ -278,12 +277,11 @@ function _precompile_()
     Base.precompile(Tuple{typeof(gr_draw_colorbar),GRColorbar,Subplot{GRBackend},Tuple{Float64, Float64},Vector{Float64}})
     Base.precompile(Tuple{typeof(gr_draw_contour),Series,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Matrix{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_heatmap),Series,Vector{Float64},Vector{Float64},Matrix{Float64},Tuple{Float64, Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,Float64,Float64,Symbol})
     Base.precompile(Tuple{typeof(gr_draw_marker),Series,Float64,Float64,Tuple{Float64, Float64},Int64,Int64,Int64,Shape{Float64, Float64}})
-    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Float64,Tuple{Float64, Float64},Int64,Float64,Int64,Symbol})
-    Base.precompile(Tuple{typeof(gr_draw_marker),Series,Int64,Int64,Tuple{Float64, Float64},Int64,Int64,Int64,Symbol})
     Base.precompile(Tuple{typeof(gr_draw_markers),Series,Base.OneTo{Int64},Vector{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_markers),Series,StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64},Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_markers),Series,UnitRange{Int64},Vector{Float64},Tuple{Float64, Float64}})
+    Base.precompile(Tuple{typeof(gr_draw_markers),Series,Vector{Int64},Vector{Float64},Tuple{Float64, Float64}})
     Base.precompile(Tuple{typeof(gr_draw_segments),Series,Base.OneTo{Int64},UnitRange{Int64},Tuple{Vector{Float64}, Vector{Float64}},Tuple{Float64, Float64}})
     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}})
@@ -291,7 +289,6 @@ function _precompile_()
     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}})
-    Base.precompile(Tuple{typeof(gr_fill_viewport),Vector{Float64},RGBA{Float64}})
     Base.precompile(Tuple{typeof(gr_get_ticks_size),Tuple{Vector{Float64}, Vector{String}},Int64})
     Base.precompile(Tuple{typeof(gr_get_ticks_size),Tuple{Vector{Int64}, Vector{String}},Int64})
     Base.precompile(Tuple{typeof(gr_label_ticks),Subplot{GRBackend},Symbol,Tuple{Vector{Float64}, Vector{String}}})
@@ -310,6 +307,7 @@ function _precompile_()
     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(is_marker_supported),GRBackend,Vector{Symbol}})
     Base.precompile(Tuple{typeof(layout_args),Int64})
     Base.precompile(Tuple{typeof(make_fillrange_side),UnitRange{Int64},LinRange{Float64}})
     Base.precompile(Tuple{typeof(optimal_ticks_and_labels),Nothing,Tuple{Float64, Float64},Symbol,Function})
@@ -321,7 +319,6 @@ function _precompile_()
     Base.precompile(Tuple{typeof(partialcircle),Int64,Float64,Int64})
     Base.precompile(Tuple{typeof(plot),Any,Any,Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(plot),Any})
-    Base.precompile(Tuple{typeof(processFillArg),Dict{Symbol, Any},Symbol})
     Base.precompile(Tuple{typeof(processGridArg!),DefaultsDict,Bool,Symbol})
     Base.precompile(Tuple{typeof(processGridArg!),Dict{Symbol, Any},Symbol,Symbol})
     Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol, Any},Matrix{Symbol}})
@@ -336,9 +333,10 @@ function _precompile_()
     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(push!),Plot{GRBackend},Float64,Vector{Float64}})
+    Base.precompile(Tuple{typeof(push!),Segments{Tuple{Float64, Float64}},Tuple{Int64, Int64},Tuple{Float64, Int64}})
     Base.precompile(Tuple{typeof(slice_arg),Base.ReshapedArray{Int64, 2, UnitRange{Int64}, Tuple{}},Int64})
+    Base.precompile(Tuple{typeof(slice_arg),Matrix{AbsoluteLength},Int64})
     Base.precompile(Tuple{typeof(slice_arg),Matrix{Bool},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Matrix{Int64},Int64})
     Base.precompile(Tuple{typeof(slice_arg),Matrix{PlotUtils.ContinuousColorGradient},Int64})
     Base.precompile(Tuple{typeof(slice_arg),Matrix{RGBA{Float64}},Int64})
     Base.precompile(Tuple{typeof(slice_arg),Matrix{String},Int64})
@@ -398,4 +396,14 @@ function _precompile_()
             precompile(fbody, (Any,typeof(title!),AbstractString,))
         end
     end
+    let fbody = try __lookup_kwbody__(which(vline!, (Any,))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Any,typeof(vline!),Any,))
+        end
+    end
+    let fbody = try __lookup_kwbody__(which(yaxis!, (Any,Vararg{Any, N} where N,))) catch missing end
+        if !ismissing(fbody)
+            precompile(fbody, (Any,typeof(yaxis!),Any,Vararg{Any, N} where N,))
+        end
+    end
 end

src/axes.jl

@@ -533,20 +533,13 @@ function axis_limits(sp, letter, should_widen = default_should_widen(sp[Symbol(l
     has_user_lims = (isa(lims, Tuple) || isa(lims, AVec)) && length(lims) == 2
     if has_user_lims
         lmin, lmax = lims
-        if lmin == :auto
-        elseif isfinite(lmin)
+        if lmin != :auto && isfinite(lmin)
             amin = lmin
         end
-        if lmax == :auto
-        elseif isfinite(lmax)
+        if lmax != :auto && isfinite(lmax)
             amax = lmax
         end
     end
-    if lims == :symmetric
-        aval = max(abs(amin), abs(amax))
-        amin = -aval
-        amax = aval
-    end
     if amax <= amin && isfinite(amin)
         amax = amin + 1.0
     end

src/backends/gr.jl

@@ -1510,10 +1510,8 @@ function gr_label_axis(sp, letter, viewport_plotarea)
         GR.savestate()
         gr_set_font(guidefont(axis), sp)
         guide_position = axis[:guide_position]
-        angle = float(axis[:guidefontrotation])  # github.com/JuliaPlots/Plots.jl/issues/3089
         if letter === :y
-            angle += 180.  # default angle = 0. should yield GR.setcharup(-1, 0) i.e. 180°
-            GR.setcharup(cosd(angle), sind(angle))
+            GR.setcharup(-1, 0)
             ypos = gr_view_yposition(viewport_plotarea, position(axis[:guidefontvalign]))
             yalign = alignment(axis[:guidefontvalign])
             if guide_position === :right || (guide_position == :auto && mirror)
@@ -1524,8 +1522,6 @@ function gr_label_axis(sp, letter, viewport_plotarea)
                 xpos = viewport_plotarea[1] - 0.03 - !mirror * gr_axis_width(sp, axis)
             end
         else
-            angle += 90.  # default angle = 0. should yield GR.setcharup(0, 1) i.e. 90°
-            GR.setcharup(cosd(angle), sind(angle))
             xpos = gr_view_xposition(viewport_plotarea, position(axis[:guidefonthalign]))
             xalign = alignment(axis[:guidefonthalign])
             if guide_position === :top || (guide_position == :auto && mirror)

src/components.jl

@@ -288,7 +288,7 @@ function font(args...;kw...)
 
   for symbol in keys(kw)
     if symbol == :family
-      family = string(kw[:family])
+      family = kw[:family]
     elseif symbol == :pointsize
       pointsize = kw[:pointsize]
     elseif symbol == :halign

src/pipeline.jl

@@ -313,7 +313,7 @@ function _prepare_subplot(plt::Plot{T}, plotattributes::AKW) where {T}
     st = _override_seriestype_check(plotattributes, st)
 
     # change to a 3d projection for this subplot?
-    if RecipesPipeline.needs_3d_axes(st) || (st == :quiver && plotattributes[:z] !== nothing)
+    if RecipesPipeline.needs_3d_axes(st)
         sp.attr[:projection] = "3d"
     end
 
@@ -329,7 +329,7 @@ function _override_seriestype_check(plotattributes::AKW, st::Symbol)
     # do we want to override the series type?
     if !RecipesPipeline.is3d(st) && !(st in (:contour, :contour3d, :quiver))
         z = plotattributes[:z]
-        if z !== nothing &&
+        if !isa(z, Nothing) &&
            (size(plotattributes[:x]) == size(plotattributes[:y]) == size(z))
             st = (st == :scatter ? :scatter3d : :path3d)
             plotattributes[:seriestype] = st

src/utils.jl

@@ -57,7 +57,7 @@ struct SeriesSegment
     # indexes of this segement in series data vectors
     range::UnitRange
     # index into vector-valued attributes corresponding to this segment
-    attr_index::Int
+    attr_index::Int 
 end
 
 # -----------------------------------------------------
@@ -88,11 +88,11 @@ function series_segments(series::Series, seriestype::Symbol = :path)
                 (SeriesSegment(i:i, i) for i in r)
             else
                 (SeriesSegment(i:i+1, i) for i in first(r):last(r)-1)
-            end
+            end 
         end)
     else
         (SeriesSegment(r, 1) for r in nan_segments)
-    end
+    end 
 
     warn_on_attr_dim_mismatch(series, x, y, z, segments)
     return segments
@@ -109,7 +109,7 @@ function warn_on_attr_dim_mismatch(series, x, y, z, segments)
             if any(v -> !isnothing(v) && any(isnan, v), (x,y,z))
                 @info """Data contains NaNs or missing values, and indices of `$attr` vector do not match data indices.
                     If you intend elements of `$attr` to apply to individual NaN-separated segements in the data,
-                    pass each segment in a separate vector instead, and use a row vector for `$attr`. Legend entries
+                    pass each segment in a separate vector instead, and use a row vector for `$attr`. Legend entries 
                     may be suppressed by passing an empty label.
                     For example,
                         plot([1:2,1:3], [[4,5],[3,4,5]], label=["y" ""], $attr=[1 2])
@@ -270,7 +270,7 @@ function heatmap_edges(x::AVec, xscale::Symbol, y::AVec, yscale::Symbol, z_size:
                 or `size(z) == (length(y)+1, length(x)+1))` (x & y define edges).""")
     end
     x, y = heatmap_edges(x, xscale, isedges),
-           heatmap_edges(y, yscale, isedges, ispolar) # special handle for `r` in polar plots
+           heatmap_edges(y, yscale, isedges, ispolar) # special handle for `r` in polar plots 
     return x, y
 end
 
@@ -939,67 +939,67 @@ ignorenan_extrema(plt::Plot) = (xmin(plt), xmax(plt))
 # ---------------------------------------------------------------
 # get fonts from objects:
 
-plottitlefont(p::Plot) = font(;
-    family = p[:plot_titlefontfamily],
-    pointsize = p[:plot_titlefontsize],
-    valign = p[:plot_titlefontvalign],
-    halign = p[:plot_titlefonthalign],
-    rotation = p[:plot_titlefontrotation],
-    color = p[:plot_titlefontcolor],
+plottitlefont(p::Plot) = font(
+    p[:plot_titlefontfamily],
+    p[:plot_titlefontsize],
+    p[:plot_titlefontvalign],
+    p[:plot_titlefonthalign],
+    p[:plot_titlefontrotation],
+    p[:plot_titlefontcolor],
 )
 
-colorbartitlefont(sp::Subplot) = font(;
-    family = sp[:colorbar_titlefontfamily],
-    pointsize = sp[:colorbar_titlefontsize],
-    valign = sp[:colorbar_titlefontvalign],
-    halign = sp[:colorbar_titlefonthalign],
-    rotation = sp[:colorbar_titlefontrotation],
-    color = sp[:colorbar_titlefontcolor],
+colorbartitlefont(sp::Subplot) = font(
+    sp[:colorbar_titlefontfamily],
+    sp[:colorbar_titlefontsize],
+    sp[:colorbar_titlefontvalign],
+    sp[:colorbar_titlefonthalign],
+    sp[:colorbar_titlefontrotation],
+    sp[:colorbar_titlefontcolor],
 )
 
-titlefont(sp::Subplot) = font(;
-    family = sp[:titlefontfamily],
-    pointsize = sp[:titlefontsize],
-    valign = sp[:titlefontvalign],
-    halign = sp[:titlefonthalign],
-    rotation = sp[:titlefontrotation],
-    color = sp[:titlefontcolor],
+titlefont(sp::Subplot) = font(
+    sp[:titlefontfamily],
+    sp[:titlefontsize],
+    sp[:titlefontvalign],
+    sp[:titlefonthalign],
+    sp[:titlefontrotation],
+    sp[:titlefontcolor],
 )
 
-legendfont(sp::Subplot) = font(;
-    family = sp[:legendfontfamily],
-    pointsize = sp[:legendfontsize],
-    valign = sp[:legendfontvalign],
-    halign = sp[:legendfonthalign],
-    rotation = sp[:legendfontrotation],
-    color = sp[:legendfontcolor],
+legendfont(sp::Subplot) = font(
+    sp[:legendfontfamily],
+    sp[:legendfontsize],
+    sp[:legendfontvalign],
+    sp[:legendfonthalign],
+    sp[:legendfontrotation],
+    sp[:legendfontcolor],
 )
 
-legendtitlefont(sp::Subplot) = font(;
-    family = sp[:legendtitlefontfamily],
-    pointsize = sp[:legendtitlefontsize],
-    valign = sp[:legendtitlefontvalign],
-    halign = sp[:legendtitlefonthalign],
-    rotation = sp[:legendtitlefontrotation],
-    color = sp[:legendtitlefontcolor],
+legendtitlefont(sp::Subplot) = font(
+    sp[:legendtitlefontfamily],
+    sp[:legendtitlefontsize],
+    sp[:legendtitlefontvalign],
+    sp[:legendtitlefonthalign],
+    sp[:legendtitlefontrotation],
+    sp[:legendtitlefontcolor],
 )
 
-tickfont(ax::Axis) = font(;
-    family = ax[:tickfontfamily],
-    pointsize = ax[:tickfontsize],
-    valign = ax[:tickfontvalign],
-    halign = ax[:tickfonthalign],
-    rotation = ax[:tickfontrotation],
-    color = ax[:tickfontcolor],
+tickfont(ax::Axis) = font(
+    ax[:tickfontfamily],
+    ax[:tickfontsize],
+    ax[:tickfontvalign],
+    ax[:tickfonthalign],
+    ax[:tickfontrotation],
+    ax[:tickfontcolor],
 )
 
-guidefont(ax::Axis) = font(;
-    family = ax[:guidefontfamily],
-    pointsize = ax[:guidefontsize],
-    valign = ax[:guidefontvalign],
-    halign = ax[:guidefonthalign],
-    rotation = ax[:guidefontrotation],
-    color = ax[:guidefontcolor],
+guidefont(ax::Axis) = font(
+    ax[:guidefontfamily],
+    ax[:guidefontsize],
+    ax[:guidefontvalign],
+    ax[:guidefonthalign],
+    ax[:guidefontrotation],
+    ax[:guidefontcolor],
 )
 
 # ---------------------------------------------------------------

test/runtests.jl

@@ -1,4 +1,3 @@
-using Plots: guidefont
 import ImageMagick
 using VisualRegressionTests
 using Plots

test/test_axes.jl

@@ -31,13 +31,3 @@ end
     @test xticks(p) == yticks(p) == zticks(p) == [ticks1, ticks2]
     @test xticks(p[1]) == yticks(p[1]) == zticks(p[1]) == ticks1
 end
-
-@testset "Axis limits" begin
-    pl = plot(1:5, xlims=:symmetric, widen = false)
-    @test Plots.xlims(pl) == (-5, 5)
-end
-
-@testset "3D Axis" begin
-    ql = quiver([1, 2], [2, 1], [3, 4], quiver = ([1, -1], [0, 0], [1, -0.5]), arrow=true)
-    @test ql[1][:projection] == "3d"
-end

test/test_defaults.jl

@@ -1,12 +1,10 @@
 using Plots, Test
 
-const PLOTS_DEFAULTS = Dict(:theme => :wong2, :fontfamily => :palantino)
+const PLOTS_DEFAULTS = Dict(:theme => :wong2)
 Plots.__init__()
 
 @testset "Loading theme" begin
-    pl = plot(1:5)
-    @test pl[1][1][:seriescolor] == RGBA(colorant"black")
-    @test guidefont(pl[1][:xaxis]).family == "palantino"
+    @test plot(1:5)[1][1][:seriescolor] == RGBA(colorant"black")
 end
 
 empty!(PLOTS_DEFAULTS)