1.25.7

* move ribbon handling after slicing

* format file

.github/workflows/format.yml.disabled

@@ -1,22 +0,0 @@
-name: format
-
-on:
-  pull_request:
-
-jobs:
-  JuliaFormatter:
-    if: "!contains(github.event.head_commit.message, '[skip ci]')"
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: julia-actions/setup-julia@latest
-        with:
-          version: 1
-
-      # Check format
-      - name: Install JuliaFormatter and format
-        run: |
-          git diff --name-only --exit-code
-          julia -e 'using Pkg; pkg"add JuliaFormatter CSTParser#master"'
-          julia -e 'using JuliaFormatter; [format(["src", "test"]) for _ in 1:2]'
-          git diff --exit-code

.github/workflows/format_check.yml

@@ -0,0 +1,38 @@
+name: format
+
+on:
+  push:
+    branches:
+      - 'master'
+    tags: '*'
+  pull_request:
+
+jobs:
+  check:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        julia-version: ['1']
+        julia-arch: [x64]
+        os: [ubuntu-latest]
+    steps:
+      - uses: julia-actions/setup-julia@latest
+        with:
+          version: ${{ matrix.julia-version }}
+
+      - uses: actions/checkout@v2
+      - name: Install JuliaFormatter and format
+        run: |
+          julia -e 'using Pkg; Pkg.add(PackageSpec(name="JuliaFormatter"))'
+          julia -e 'using JuliaFormatter; format(["src", "test"], verbose=true)'
+      - name: Format check
+        run: |
+          julia -e '
+          out = Cmd(`git diff --name-only`) |> read |> String
+          if out == ""
+              exit(0)
+          else
+              @error "Some files have not been formatted !!!"
+              write(stdout, out)
+              exit(1)
+          end'

.github/workflows/format_pr.yml

@@ -1,19 +1,19 @@
-name: format-pr
+name: format
 
 on:
   schedule:
-    - cron: '0 0 * * SUN'
+    - cron: '0 0 1 * *'
 
 jobs:
-  build:
+  pr:
     if: "!contains(github.event.head_commit.message, '[skip ci]')"
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
       - name: Install JuliaFormatter and format
         run: |
-          julia  -e 'using Pkg; pkg"add JuliaFormatter"'
-          julia  -e 'using JuliaFormatter; [format(["src", "test"]) for _ in 1:2]'
+          julia -e 'using Pkg; Pkg.add(PackageSpec(name="JuliaFormatter"))'
+          julia -e 'using JuliaFormatter; [format(["src", "test"]) for _ in 1:2]'
           git diff --exit-code
 
       - name: Create Pull Request

Project.toml

@@ -1,7 +1,7 @@
 name = "Plots"
 uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
 author = ["Tom Breloff (@tbreloff)"]
-version = "1.25.6"
+version = "1.25.7"
 
 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"
@@ -39,7 +39,7 @@ Unzip = "41fe7b60-77ed-43a1-b4f0-825fd5a5650d"
 Contour = "0.5"
 FFMPEG = "0.2 - 0.4"
 FixedPointNumbers = "0.6 - 0.8"
-GR = "0.63.0"
+GR = "0.63"
 GeometryBasics = "0.2, 0.3.1, 0.4"
 JSON = "0.21, 1"
 Latexify = "0.14 - 0.15"
@@ -55,7 +55,7 @@ Scratch = "1"
 Showoff = "0.3.1, 1.0"
 StatsBase = "0.32 - 0.33"
 UnicodeFun = "0.4"
-UnicodePlots = "2.4"
+UnicodePlots = "2.6"
 Unzip = "0.1"
 julia = "1.6"
 

README.md

@@ -10,7 +10,7 @@
 [gitter-url]: https://gitter.im/tbreloff/Plots.jl?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge
 
 [docs-img]: https://img.shields.io/badge/docs-stable-blue.svg
-[docs-url]: https://docs.juliaplots.org/latest/
+[docs-url]: https://docs.juliaplots.org/stable/
 
 [![][gh-ci-img]][gh-ci-url]
 [![][pkgeval-img]][pkgeval-url]
@@ -22,7 +22,6 @@
 [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.4725317.svg)](https://doi.org/10.5281/zenodo.4725317)
 This is the DOI for all Versions, please follow the link to get the DOI for a specific version.
 
-
 #### Created by Tom Breloff (@tbreloff)
 
 #### Maintained by the [JuliaPlots members](https://github.com/orgs/JuliaPlots/people)

deps/SnoopCompile/precompile/1.6/precompile_Plots.jl

@@ -75,14 +75,12 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Nothing}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
     Base.precompile(Tuple{Core.kwftype(typeof(_make_hist)),NamedTuple{(:normed, :weights), Tuple{Bool, Vector{Int64}}},typeof(_make_hist),Tuple{Vector{Float64}},Symbol})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:flip,), Tuple{Bool}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:formatter,), Tuple{Symbol}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:formatter,), Tuple{typeof(datetimeformatter)}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :flip, :minorgrid, :guide), Tuple{Bool, Bool, Bool, String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :lims), Tuple{Bool, Tuple{Float64, Float64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :lims, :flip), Tuple{Bool, Tuple{Float64, Float64}, Bool}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :minorgrid, :guide), Tuple{Bool, Bool, String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid, :minorgrid, :mirror, :guide), Tuple{Bool, Bool, Bool, String}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:grid,), Tuple{Bool}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:gridlinewidth, :grid, :gridalpha, :gridstyle, :foreground_color_grid), Tuple{Int64, Bool, Float64, Symbol, RGBA{Float64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guide,), Tuple{String}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:guide_position, :guidefontvalign, :mirror, :guide), Tuple{Symbol, Symbol, Bool, String}},typeof(attr!),Axis})
@@ -92,9 +90,6 @@ function _precompile_()
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Int64, Float64}}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:lims,), Tuple{Tuple{Int64, Int64}}},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{(:minorgrid,), Tuple{Bool}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:rotation,), Tuple{Int64}},typeof(attr!),Axis})
-    Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,), Tuple{Nothing}},typeof(attr!),Axis})
     Base.precompile(Tuple{Core.kwftype(typeof(attr!)),NamedTuple{(:ticks,), Tuple{UnitRange{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)})
@@ -124,7 +119,6 @@ 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{GRBackend},StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}},Vector{Float64}})
     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}},Vector{Float64}})
     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},Vector{Float64}})
@@ -133,12 +127,11 @@ function _precompile_()
     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!),Plot{PlotlyBackend}})
     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}})
@@ -157,7 +150,6 @@ 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,Float64})
     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{Matrix{Any}, 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},Plot{GRBackend}})
     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},Plot{PlotlyBackend}})
@@ -238,6 +230,7 @@ function _precompile_()
     Base.precompile(Tuple{typeof(RecipesPipeline.process_userrecipe!),Plot{GRBackend},Vector{Dict{Symbol, Any}},Dict{Symbol, Any}})
     Base.precompile(Tuple{typeof(RecipesPipeline.process_userrecipe!),Plot{PlotlyBackend},Vector{Dict{Symbol, Any}},Dict{Symbol, Any}})
     Base.precompile(Tuple{typeof(RecipesPipeline.unzip),Vector{GeometryBasics.Point2{Float64}}})
+    Base.precompile(Tuple{typeof(RecipesPipeline.warn_on_recipe_aliases!),Plot{PlotlyBackend},Dict{Symbol, Any},Symbol,Any})
     Base.precompile(Tuple{typeof(_bin_centers),StepRangeLen{Float64, Base.TwicePrecision{Float64}, Base.TwicePrecision{Float64}}})
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{Float64},String})
     Base.precompile(Tuple{typeof(_cbar_unique),Vector{Int64},String})
@@ -245,11 +238,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),Base.OneTo{Int64},Vector{Int64}})
-    Base.precompile(Tuple{typeof(_cycle),ColorPalette,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})
@@ -274,12 +263,10 @@ function _precompile_()
     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(fakedata),Int64,Int64})
-    Base.precompile(Tuple{typeof(fakedata),MersenneTwister,Int64,Vararg{Int64, 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),SubArray{Symbol, 1, Vector{Symbol}, Tuple{UnitRange{Int64}}, true},Subplot{GRBackend},Int64,Symbol})
     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})
@@ -295,15 +282,9 @@ function _precompile_()
     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},Int64,Int64})
-    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}})
-    Base.precompile(Tuple{typeof(gr_draw_segments),Series,UnitRange{Int64},Vector{Float64},Nothing,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_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}})
@@ -315,7 +296,6 @@ function _precompile_()
     Base.precompile(Tuple{typeof(gr_label_ticks),Subplot{GRBackend},Symbol,Tuple{Vector{Int64}, Vector{String}}})
     Base.precompile(Tuple{typeof(gr_label_ticks_3d),Subplot{GRBackend},Symbol,Tuple{Vector{Float64}, Vector{String}}})
     Base.precompile(Tuple{typeof(gr_polaraxes),Int64,Float64,Subplot{GRBackend}})
-    Base.precompile(Tuple{typeof(gr_polyline),Vector{Float64},Vector{Float64},Function})
     Base.precompile(Tuple{typeof(gr_set_gradient),PlotUtils.ContinuousColorGradient})
     Base.precompile(Tuple{typeof(gr_text),Float64,Float64,String})
     Base.precompile(Tuple{typeof(gr_update_viewport_legend!),Vector{Float64},Subplot{GRBackend},NamedTuple{(:w, :h, :dy, :leftw, :textw, :rightw, :xoffset, :yoffset, :width_factor), NTuple{9, Float64}}})
@@ -333,6 +313,7 @@ function _precompile_()
     Base.precompile(Tuple{typeof(layout_args),NamedTuple{(:label, :blank), Tuple{Symbol, Bool}}})
     Base.precompile(Tuple{typeof(layout_args),NamedTuple{(:label, :width, :height), Tuple{Symbol, Symbol, Float64}}})
     Base.precompile(Tuple{typeof(make_fillrange_side),UnitRange{Int64},LinRange{Float64}})
+    Base.precompile(Tuple{typeof(make_steps),Vector{Float64},Symbol,Bool})
     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})
@@ -348,7 +329,6 @@ function _precompile_()
     Base.precompile(Tuple{typeof(processGridArg!),Dict{Symbol, Any},Symbol,Symbol})
     Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol, Any},Matrix{Symbol}})
     Base.precompile(Tuple{typeof(processLineArg),Dict{Symbol, Any},Symbol})
-    Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Bool})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Matrix{Symbol}})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},RGBA{Float64}})
     Base.precompile(Tuple{typeof(processMarkerArg),Dict{Symbol, Any},Shape{Float64, Float64}})
@@ -362,17 +342,11 @@ 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(quiver_using_arrows),DefaultsDict})
     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),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{PlotUtils.ContinuousColorGradient},Int64})
     Base.precompile(Tuple{typeof(slice_arg),Matrix{RGBA{Float64}},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Matrix{String},Int64})
-    Base.precompile(Tuple{typeof(slice_arg),Matrix{Symbol},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})
@@ -381,6 +355,7 @@ function _precompile_()
     Base.precompile(Tuple{typeof(warn_on_attr_dim_mismatch),Series,Vector{Float64},Vector{Float64},Nothing,Base.Iterators.Flatten{Vector{Tuple{SeriesSegment}}}})
     Base.precompile(Tuple{typeof(xgrid!),Plot{GRBackend},Symbol,Vararg{Any, N} where N})
     Base.precompile(Tuple{typeof(xlims),Subplot{PlotlyBackend}})
+    isdefined(Plots, Symbol("#296#332")) && Base.precompile(Tuple{getfield(Plots, Symbol("#296#332"))})
     isdefined(Plots, Symbol("#297#333")) && Base.precompile(Tuple{getfield(Plots, Symbol("#297#333"))})
     isdefined(Plots, Symbol("#4#8")) && Base.precompile(Tuple{getfield(Plots, Symbol("#4#8")),UnitRange{Int64}})
     isdefined(Plots, Symbol("#add_major_or_minor_segments#102")) && Base.precompile(Tuple{getfield(Plots, Symbol("#add_major_or_minor_segments#102")),Vector{Float64},Bool,Segments{Tuple{Float64, Float64}},Float64,Bool})
@@ -390,11 +365,6 @@ function _precompile_()
             precompile(fbody, (Base.Iterators.Pairs{Union{}, Union{}, Tuple{}, NamedTuple{(), Tuple{}}},typeof(font),Font,Vararg{Any, N} where N,))
         end
     end
-    let fbody = try __lookup_kwbody__(which(gr_polyline, (Vector{Float64},Vector{Float64},typeof(GR.fillarea),))) catch missing end
-        if !ismissing(fbody)
-            precompile(fbody, (Symbol,Symbol,typeof(gr_polyline),Vector{Float64},Vector{Float64},typeof(GR.fillarea),))
-        end
-    end
     let fbody = try __lookup_kwbody__(which(plot!, (Any,))) catch missing end
         if !ismissing(fbody)
             precompile(fbody, (Any,typeof(plot!),Any,))
@@ -420,4 +390,9 @@ function _precompile_()
             precompile(fbody, (Any,typeof(title!),AbstractString,))
         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/args.jl

@@ -1058,10 +1058,14 @@ end
 # update the defaults globally
 
 """
-`default(key)` returns the current default value for that key
-`default(key, value)` sets the current default value for that key
-`default(; kw...)` will set the current default value for each key/value pair
-`default(plotattributes, key)` returns the key from  plotattributes if it exists, otherwise `default(key)`
+`default(key)` returns the current default value for that key.
+    
+`default(key, value)` sets the current default value for that key.
+    
+`default(; kw...)` will set the current default value for each key/value pair.
+    
+`default(plotattributes, key)` returns the key from plotattributes if it exists, otherwise `default(key)`.
+    
 """
 function default(k::Symbol)
     k = get(_keyAliases, k, k)

src/backends.jl

@@ -923,6 +923,8 @@ const _unicodeplots_attr = merge_with_base_supported([
     :linecolor,
     :linestyle,
     :markershape,
+    :quiver,
+    :arrow,
     :seriesalpha,
     :seriescolor,
     :scale,
@@ -936,6 +938,7 @@ const _unicodeplots_seriestype = [
     :shape,
     :histogram2d,
     :heatmap,
+    :contour,
     :spy,
 ]
 const _unicodeplots_style = [:auto, :solid]
@@ -970,10 +973,10 @@ const _unicodeplots_marker = [
 const _unicodeplots_scale = [:identity, :ln, :log2, :log10]
 
 # Additional constants
-const _unicodeplots_canvas = Ref(:auto)
-const _unicodeplots_border = Ref(:auto)
-const _unicodeplots_height = Ref(15)
-const _unicodeplots_width = Ref(40)
+const _up_colormap = Ref(:none)
+const _up_canvas = Ref(:auto)
+const _up_border = Ref(:auto)
+const _up_fix_ar = Ref(true)
 
 # ------------------------------------------------------------------------------
 # hdf5

src/backends/gr.jl

@@ -1272,7 +1272,7 @@ function gr_get_legend_geometry(viewport_plotarea, sp)
         GR.restorestate()
     end
 
-    legend_width_factor = (viewport_plotarea[2] - viewport_plotarea[1]) / 45 # Determines the width of legend box
+    legend_width_factor = 0.02
     legend_textw = legendw
     legend_rightw = legend_width_factor
     legend_leftw = legend_width_factor * 4

src/backends/plotly.jl

@@ -1031,6 +1031,9 @@ end
 
 # get a list of dictionaries, each representing the series params
 function plotly_series(plt::Plot)
+    if isempty(plt.series_list)
+        return KW[]
+    end
     reduce(vcat, plotly_series(plt, series) for series in plt.series_list)
 end
 

src/backends/unicodeplots.jl

@@ -19,40 +19,63 @@ const _canvas_map = (
 function unicodeplots_rebuild(plt::Plot{UnicodePlotsBackend})
     plt.o = UnicodePlots.Plot[]
 
+    has_layout = prod(size(plt.layout)) > 1
     for sp in plt.subplots
         xaxis = sp[:xaxis]
         yaxis = sp[:yaxis]
         xlim = collect(axis_limits(sp, :x))
         ylim = collect(axis_limits(sp, :y))
+        F = float(eltype(xlim))
 
         # 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 should be hidden by consecutive plotting commands.
-        x = Float64[xlim[1]]
-        y = Float64[ylim[1]]
+        x = F[xlim[1]]
+        y = F[ylim[1]]
 
         # create a plot window with xlim/ylim set,
         # but the X/Y vectors are outside the bounds
-        canvas = if (up_c = _unicodeplots_canvas[]) == :auto
+        canvas = if (up_c = _up_canvas[]) == :auto
             isijulia() ? :ascii : :braille
         else
             up_c
         end
 
-        border = if (up_b = _unicodeplots_border[]) == :auto
+        border = if (up_b = _up_border[]) == :auto
             isijulia() ? :ascii : :solid
         else
             up_b
         end
 
+        # blank plots will not be shown
+        width = has_layout && isempty(series_list(sp)) ? 0 : UnicodePlots.DEFAULT_WIDTH[]
+        height = UnicodePlots.DEFAULT_HEIGHT[]
+
+        grid = xaxis[:grid] && yaxis[:grid]
+        quiver = contour = false
+        for series in series_list(sp)
+            st = series[:seriestype]
+            quiver |= series[:arrow] isa Arrow  # post-pipeline detection (:quiver -> :path)
+            contour |= st === :contour
+            if st === :histogram2d
+                xlim = ylim = (0, 0)
+            elseif st === :spy || st === :heatmap
+                width = height = 0
+                grid = false
+            end
+        end
+        grid &= !contour && !quiver
+
         kw = (
             compact = true,
             title = texmath2unicode(sp[:title]),
             xlabel = texmath2unicode(xaxis[:guide]),
             ylabel = texmath2unicode(yaxis[:guide]),
-            height = _unicodeplots_height[],
-            width = _unicodeplots_width[],
+            grid = grid,
+            blend = !(quiver || contour),
+            height = height,
+            width = width,
             xscale = xaxis[:scale],
             yscale = yaxis[:scale],
             border = border,
@@ -87,6 +110,11 @@ up_color(col::RGBA) =
     (c = convert(ARGB32, col); map(Int, (red(c).i, green(c).i, blue(c).i)))
 up_color(col) = :auto
 
+function up_cmap(series)
+    rng = range(0, 1, length = length(UnicodePlots.COLOR_MAP_DATA[:viridis]))
+    [(red(c), green(c), blue(c)) for c in get(get_colorgradient(series), rng)]
+end
+
 # add a single series
 function addUnicodeSeries!(
     sp::Subplot{UnicodePlotsBackend},
@@ -98,41 +126,51 @@ function addUnicodeSeries!(
     st = series[:seriestype]
 
     # get the series data and label
-    x, y = if st == :straightline
+    x, y = if st === :straightline
         straightline_data(series)
-    elseif st == :shape
+    elseif st === :shape
         shape_data(series)
     else
         float(series[:x]), float(series[:y])
     end
 
     # special handling (src/interface)
-    if st == :histogram2d
-        kw[:xlim][:] .= kw[:ylim][:] .= 0
+    if st === :histogram2d
         return UnicodePlots.densityplot(x, y; kw...)
-    elseif st == :heatmap
-        rng = range(0, 1, length = length(UnicodePlots.COLOR_MAP_DATA[:viridis]))
-        cmap = [(red(c), green(c), blue(c)) for c in get(get_colorgradient(series), rng)]
-        return UnicodePlots.heatmap(
-            series[:z].surf;
-            zlabel = sp[:colorbar_title],
-            colormap = cmap,
+    elseif st === :spy
+        return UnicodePlots.spy(series[:z].surf; fix_ar = _up_fix_ar[], kw...)
+    elseif st in (:contour, :heatmap)
+        kw = (
             kw...,
+            zlabel = sp[:colorbar_title],
+            colormap = (cm = _up_colormap[] === :none) ? up_cmap(series) : cm,
+            colorbar = hascolorbar(sp),
         )
-    elseif st == :spy
-        return UnicodePlots.spy(series[:z].surf; kw...)
+        if st === :contour
+            isfilledcontour(series) &&
+                @warn "Plots(UnicodePlots): filled contour is not implemented"
+            return UnicodePlots.contourplot(
+                x,
+                y,
+                series[:z].surf;
+                kw...,
+                levels = series[:levels],
+            )
+        elseif st === :heatmap
+            return UnicodePlots.heatmap(series[:z].surf; fix_ar = _up_fix_ar[], kw...)
+            # zlim = collect(axis_limits(sp, :z))
+        end
     end
 
-    series_kw = (;)
-
     # now use the ! functions to add to the plot
     if st in (:path, :straightline, :shape)
         func = UnicodePlots.lineplot!
-    elseif st == :scatter || series[:markershape] != :none
+        series_kw = (; head_tail = series[:arrow] isa Arrow ? series[:arrow].side : nothing)
+    elseif st === :scatter || series[:markershape] != :none
         func = UnicodePlots.scatterplot!
         series_kw = (; marker = series[:markershape])
     else
-        error("Series type $st not supported by UnicodePlots")
+        error("Plots(UnicodePlots): series type $st not supported")
     end
 
     label = addlegend ? series[:label] : ""
@@ -162,7 +200,7 @@ function addUnicodeSeries!(
         )
     end
 
-    return up
+    up
 end
 
 # ------------------------------------------------------------------------------------------
@@ -198,7 +236,7 @@ end
 Base.show(plt::Plot{UnicodePlotsBackend}) = show(stdout, plt)
 Base.show(io::IO, plt::Plot{UnicodePlotsBackend}) = _show(io, MIME("text/plain"), plt)
 
-# NOTE: _show(..) must be kept for Base.showable (src/output.jl)
+# NOTE: _show(...) must be kept for Base.showable (src/output.jl)
 function _show(io::IO, ::MIME"text/plain", plt::Plot{UnicodePlotsBackend})
     unicodeplots_rebuild(plt)
     nr, nc = size(plt.layout)
@@ -222,7 +260,7 @@ function _show(io::IO, ::MIME"text/plain", plt::Plot{UnicodePlotsBackend})
             for c in 1:nc
                 l = plt.layout[r, c]
                 if l isa GridLayout && size(l) != (1, 1)
-                    @error "UnicodePlots: complex nested layout is currently unsupported !"
+                    @error "Plots(UnicodePlots): complex nested layout is currently unsupported"
                 else
                     if get(l.attr, :blank, false)
                         lines_colored[r, c] = lines_uncolored[r, c] = nothing

src/consts.jl

@@ -50,7 +50,8 @@ const _magic_axis_args = [:axis, :tickfont, :guidefont, :grid, :minorgrid]
 const _magic_subplot_args =
     [:title_font, :legend_font, :legend_title_font, :plot_title_font, :colorbar_titlefont]
 const _magic_series_args = [:line, :marker, :fill]
-const _all_magic_args = sort(union(_magic_axis_args, _magic_series_args, _magic_subplot_args))
+const _all_magic_args =
+    sort(union(_magic_axis_args, _magic_series_args, _magic_subplot_args))
 
 const _all_axis_args = sort(union([_axis_args; _magic_axis_args]))
 const _all_subplot_args = sort(union([_subplot_args; _magic_subplot_args]))

src/examples.jl

@@ -1289,7 +1289,6 @@ _backend_skips = Dict(
         6,  # embedded images unsupported
         16,  # nested layout unsupported
         21,  # custom markers unsupported
-        22,  # contours unsupported
         24,  # 3D unsupported
         26,  # nested layout unsupported
         27,  # polar plots unsupported

src/pipeline.jl

@@ -83,19 +83,6 @@ function _preprocess_userrecipe(kw::AKW)
             map(kw[:line_z], kw[:x], kw[:y], kw[:z])
     end
 
-    rib = get(kw, :ribbon, default(:ribbon))
-    fr = get(kw, :fillrange, default(:fillrange))
-    # map ribbon if it's a Function
-    if rib isa Function
-        kw[:ribbon] = map(rib, kw[:x])
-    end
-    # convert a ribbon into a fillrange
-    if  rib !== nothing
-        make_fillrange_from_ribbon(kw)
-    # map fillrange if it's a Function
-    elseif fr !== nothing && fr isa Function
-        kw[:fillrange] = map(fr, kw[:x])
-    end
     return
 end
 
@@ -164,6 +151,21 @@ function RecipesPipeline.process_sliced_series_attributes!(plt::Plots.Plot, kw_l
         end
     end
 
+    for kw in kw_list
+        rib = get(kw, :ribbon, default(:ribbon))
+        fr = get(kw, :fillrange, default(:fillrange))
+        # map ribbon if it's a Function
+        if rib isa Function
+            kw[:ribbon] = map(rib, kw[:x])
+        end
+        # convert a ribbon into a fillrange
+        if rib !== nothing
+            make_fillrange_from_ribbon(kw)
+            # map fillrange if it's a Function
+        elseif fr !== nothing && fr isa Function
+            kw[:fillrange] = map(fr, kw[:x])
+        end
+    end
     return nothing
 end
 
@@ -294,7 +296,8 @@ function _add_plot_title!(plt)
             the_layout = plt.layout
             vspan = plt[:plot_titlevspan]
             plt.layout = grid(2, 1, heights = (vspan, 1 - vspan))
-            plt.layout.grid[1, 1] = subplot = Subplot(plt.backend, parent = plt.layout[1, 1])
+            plt.layout.grid[1, 1] =
+                subplot = Subplot(plt.backend, parent = plt.layout[1, 1])
             plt.layout.grid[2, 1] = the_layout
             subplot.plt = plt
 
@@ -428,4 +431,3 @@ function _add_the_series(plt, sp, plotattributes)
     _series_added(plt, series)
     _update_subplot_colorbars(sp)
 end
-

test/test_defaults.jl

@@ -13,7 +13,7 @@ empty!(PLOTS_DEFAULTS)
 Plots.__init__()
 
 @testset "default" begin
-    default(fillrange=0)
+    default(fillrange = 0)
     @test Plots._series_defaults[:fillrange] == 0
     pl = plot(1:5)
     @test pl[1][1][:fillrange] == 0

test/test_pipeline.jl

@@ -19,12 +19,18 @@ end
 end
 
 @testset "Slicing" begin
-
     @test plot(1:5, fillrange = 0)[1][1][:fillrange] == 0
-    data4 = rand(4,4)
+    data4 = rand(4, 4)
+    mat = reshape(1:8, 2, 4)
     for i in axes(data4, 1)
-        @test plot(data4, fillrange = 0)[1][i][:fillrange] == 0
-        @test plot(data4, fillrange = [1, 2])[1][i][:fillrange] == [1.0, 2.0]
-        @test plot(data4, fillrange = [1 2])[1][i][:fillrange] == (iseven(i) ? 2 : 1)
+        for attribute in (:fillrange, :ribbon)
+            @test plot(data4; NamedTuple{tuple(attribute)}(0)...)[1][i][attribute] == 0
+            @test plot(data4; NamedTuple{tuple(attribute)}(Ref([1, 2]))...)[1][i][attribute] ==
+                  [1.0, 2.0]
+            @test plot(data4; NamedTuple{tuple(attribute)}(Ref([1 2]))...)[1][i][attribute] ==
+                  (iseven(i) ? 2 : 1)
+            @test plot(data4; NamedTuple{tuple(attribute)}(Ref(mat))...)[1][i][attribute] ==
+                  [2(i - 1) + 1, 2i]
+        end
     end
 end

test/test_plotly.jl

@@ -7,6 +7,7 @@ using Plots, Test
 
         p = plot(rand(10))
         @test isa(p, Plots.Plot) == true
+        @test_nowarn Plots.plotly_series(plot())
     end
 
     @testset "Contours" begin