Refactor marker and line attributes

.github/workflows/benchmark.yml

@@ -3,7 +3,7 @@ name: benchmarks
 on:
   pull_request:
 
-concurrency: 
+concurrency:
   group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
   cancel-in-progress: true
 
@@ -14,11 +14,14 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - uses: julia-actions/setup-julia@latest
-  
+
       - name: Ubuntu TESTCMD
         run: echo "TESTCMD=xvfb-run --auto-servernum julia" >> $GITHUB_ENV
       - name: Install Plots dependencies
-        uses: julia-actions/julia-buildpkg@latest
+        shell: xvfb-run julia --project=@. --color=yes {0}
+        run: |
+          using Pkg
+          foreach(path -> Pkg.develop(; path), ("RecipesBase", "RecipesPipeline"))
       - name: Install Benchmarking dependencies
         run: julia -e 'using Pkg; pkg"add PkgBenchmark BenchmarkCI"'
 

NEWS.md

@@ -590,7 +590,7 @@ Many updates, min julia 1.0
 - allow calling `plot!(sp, ...)` to update a target Subplot
 - PyPlot: zorder fix
 - new DataFrames logic/recipe: more flexible/robust and allow Symbols for:
-	- `(:fillrange, :line_z, :marker_z, :markersize, :ribbon, :weights, :xerror, :yerror)`
+	- `(:fillrange, :line_z, :marker_z, :marker_size, :ribbon, :weights, :xerror, :yerror)`
 - new `display_type` and `extra_kwargs` plot attributes
 - surface fix
 

RecipesBase/README.md

@@ -125,8 +125,8 @@ function RecipesBase.apply_recipe(d::Dict{Symbol,Any},::T,n=1)
     end
     series_list = RecipesBase.RecipeData[]
     func_return = begin
-            get!(d,:markershape,:auto)
-            d[:markercolor] = customcolor
+            get!(d,:marker_shape,:auto)
+            d[:marker_color] = customcolor
             get!(d,:xrotation,45)
             get!(d,:zrotation,90)
             rand(10,n)

RecipesBase/test/runtests.jl

@@ -61,9 +61,13 @@ end
     @testset "simple parametric type" begin
         @test_throws MethodError RB.apply_recipe(KW(), T1())
 
-        RB.@recipe function plot(t::T1, n::N = 1; customcolor = :green) where {N<:Integer}
-            :markershape --> :auto, :require
-            :markercolor --> customcolor, :force
+        RB.@recipe function plot(
+            t::T1,
+            n::N = 1;
+            customcolor = :green,
+        ) where {N<:Integer}
+            :marker_shape --> :auto, :require
+            :marker_color --> customcolor, :force
             :xrotation --> 5
             :zrotation --> 6, :quiet
             rand(StableRNG(1), 10, n)
@@ -73,8 +77,8 @@ end
             T1,
             KW(
                 :customcolor => :red,
-                :markershape => :auto,
-                :markercolor => :red,
+                :marker_shape => :auto,
+                :marker_color => :red,
                 :xrotation => 5,
                 :zrotation => 6,
             ),
@@ -85,8 +89,8 @@ end
         @test_throws MethodError RB.apply_recipe(KW(), T2())
 
         RB.@recipe function plot(t::T2, n::N = 1; customcolor = :green) where {N<:Integer}
-            :markershape --> :auto, :require
-            :markercolor --> customcolor, :force
+            :marker_shape --> :auto, :require
+            :marker_color --> customcolor, :force
             :xrotation --> 5
             :zrotation --> 6, :quiet
             rand(StableRNG(1), 10, n)
@@ -96,8 +100,8 @@ end
             T2,
             KW(
                 :customcolor => :red,
-                :markershape => :auto,
-                :markercolor => :red,
+                :marker_shape => :auto,
+                :marker_color => :red,
                 :xrotation => 5,
                 :zrotation => 6,
             ),
@@ -113,8 +117,8 @@ end
             m::M = 0.0;
             customcolor = :green,
         ) where {N<:Integer} where {M<:Float64}
-            :markershape --> :auto, :require
-            :markercolor --> customcolor, :force
+            :marker_shape --> :auto, :require
+            :marker_color --> customcolor, :force
             :xrotation --> 5
             :zrotation --> 6, :quiet
             rand(StableRNG(1), 10, n)
@@ -124,8 +128,8 @@ end
             T3,
             KW(
                 :customcolor => :red,
-                :markershape => :auto,
-                :markercolor => :red,
+                :marker_shape => :auto,
+                :marker_color => :red,
                 :xrotation => 5,
                 :zrotation => 6,
             ),
@@ -136,8 +140,8 @@ end
         @test_throws MethodError RB.apply_recipe(KW(), T4())
 
         RB.@recipe function plot(t::T4, n = 1; customcolor = :green)
-            :markershape --> :auto, :require
-            :markercolor --> customcolor, :force
+            :marker_shape --> :auto, :require
+            :marker_color --> customcolor, :force
             :xrotation --> 5
             :zrotation --> 6, :quiet
             plotattributes[:hello] = "hi"
@@ -148,8 +152,8 @@ end
             T4,
             KW(
                 :customcolor => :red,
-                :markershape => :auto,
-                :markercolor => :red,
+                :marker_shape => :auto,
+                :marker_color => :red,
                 :xrotation => 5,
                 :zrotation => 6,
                 :hello => "hi",

RecipesPipeline/src/RecipesPipeline.jl

@@ -38,6 +38,7 @@ export warn_on_recipe_aliases,
     get_axis_limits,
     is_axis_attribute,
     type_alias,
+    key_alias,
     plot_setup!,
     slice_series_attributes!,
     process_sliced_series_attributes!

RecipesPipeline/src/api.jl

@@ -150,12 +150,18 @@ get_axis_limits(plt, letter) = throw(ErrorException("Axis limits not defined."))
 # ## Plot recipes
 
 """
-    type_alias(plt, st)
+    type_alias(typeof(plt), st)
 
-Return the seriestype alias for `st`.
+Return the canonical seriestype for `st`.
 """
-type_alias(plt, st) = st
+type_alias(plt::Type{<:Any}, st) = st
 
+"""
+    key_alias(typeof(plt), key)
+
+Return the canonical key for `key`.
+"""
+key_alias(plt::Type{<:Any}, key) = key
 # ## Plot setup
 
 """

RecipesPipeline/src/plot_recipe.jl

@@ -27,7 +27,6 @@ function _process_plotrecipe(plt, kw, kw_list, still_to_process)
         return
     end
     st = kw[:seriestype]
-    st = kw[:seriestype] = type_alias(plt, st)
     datalist = RecipesBase.apply_recipe(kw, Val{st}, plt)
     if !isnothing(datalist)
         warn_on_recipe_aliases!(plt, datalist, :plot, st)

RecipesPipeline/src/series_recipe.jl

@@ -15,7 +15,7 @@ function _process_seriesrecipes!(plt, kw_list)
     end
     process_sliced_series_attributes!(plt, kw_list)
     for kw in kw_list
-        series_attr = DefaultsDict(kw, series_defaults(plt))
+        series_attr = DefaultsDict(typeof(plt), kw, series_defaults(plt))
         # now we have a fully specified series, with colors chosen. we must recursively
         # handle series recipes, which dispatch on seriestype. If a backend does not
         # natively support a seriestype, we check for a recipe that will convert that
@@ -33,7 +33,6 @@ end
 function _process_seriesrecipe(plt, plotattributes)
     # replace seriestype aliases
     st = Symbol(plotattributes[:seriestype])
-    st = plotattributes[:seriestype] = type_alias(plt, st)
 
     # shapes shouldn't have fillrange set
     if plotattributes[:seriestype] == :shape

RecipesPipeline/src/utils.jl

@@ -9,28 +9,54 @@ const AKW = AbstractDict{Symbol,Any}
 # ## DefaultsDict
 # --------------------------------
 
-struct DefaultsDict <: AbstractDict{Symbol,Any}
+struct DefaultsDict{P} <: AbstractDict{Symbol,Any}
+    plot_type::Type{P}
     explicit::KW
     defaults::KW
+    function DefaultsDict{P}(plot_type::Type{P}, explicit::AbstractDict, defaults::AbstractDict) where {P}
+        e = KW(
+            key_alias(plot_type, k) => v === :seriestype ? type_alias(plot_type, v) : v
+            for (k, v) in explicit
+        )
+        new{P}(plot_type, e, defaults)
+    end
 end
 
-Base.merge(d1::DefaultsDict, d2::DefaultsDict) =
-    DefaultsDict(merge(d1.explicit, d2.explicit), merge(d1.defaults, d2.defaults))
-Base.getindex(dd::DefaultsDict, k) =
+DefaultsDict(pt, e, d) = DefaultsDict{pt}(pt, e, d)
+function Base.merge(d1::DefaultsDict, d2::DefaultsDict)
+    @assert d1.plot_type === d2.plot_type
+    DefaultsDict(
+        d1.plot_type,
+        merge(d1.explicit, d2.explicit),
+        merge(d1.defaults, d2.defaults),
+    )
+end
+function Base.getindex(dd::DefaultsDict, k)
+    k = key_alias(dd.plot_type, k)
     if haskey(dd.explicit, k)
         dd.explicit[k]
     else
         dd.defaults[k]
     end
-Base.haskey(dd::DefaultsDict, k) = haskey(dd.explicit, k) || haskey(dd.defaults, k)
-Base.get(dd::DefaultsDict, k, default) = haskey(dd, k) ? dd[k] : default
-Base.get!(dd::DefaultsDict, k, default) =
+end
+function Base.haskey(dd::DefaultsDict, k)
+    k = key_alias(dd.plot_type, k)
+    haskey(dd.explicit, k) || haskey(dd.defaults, k)
+end
+function Base.get(dd::DefaultsDict, k, default)
+    k = key_alias(dd.plot_type, k)
+    haskey(dd, k) ? dd[k] : default
+end
+function Base.get!(dd::DefaultsDict, k, default)
+    k = key_alias(dd.plot_type, k)
     if haskey(dd, k)
         dd[k]
     else
         dd.defaults[k] = default
     end
+end
 function Base.delete!(dd::DefaultsDict, k)
+    k = key_alias(dd.plot_type, k)
     haskey(dd.explicit, k) && delete!(dd.explicit, k)
     haskey(dd.defaults, k) && delete!(dd.defaults, k)
     dd
@@ -46,12 +72,24 @@ function Base.iterate(dd::DefaultsDict, (key_list, i))
     (k => dd[k], (key_list, i + 1))
 end
 
-Base.copy(dd::DefaultsDict) = DefaultsDict(copy(dd.explicit), dd.defaults)
+Base.copy(dd::DefaultsDict) = DefaultsDict(dd.plot_type, copy(dd.explicit), dd.defaults)
 
-RecipesBase.is_explicit(dd::DefaultsDict, k) = haskey(dd.explicit, k)
-RecipesBase.is_default(dd::DefaultsDict, k) = !is_explicit(dd, k) && haskey(dd.defaults, k)
+function RecipesBase.is_explicit(dd::DefaultsDict, k)
+    k = key_alias(dd.plot_type, k)
+    haskey(dd.explicit, k)
+end
+function RecipesBase.is_default(dd::DefaultsDict, k)
+    k = key_alias(dd.plot_type, k)
+    !is_explicit(dd, k) && haskey(dd.defaults, k)
+end
 
-Base.setindex!(dd::DefaultsDict, v, k) = dd.explicit[k] = v
+function Base.setindex!(dd::DefaultsDict, v, k)
+    k = key_alias(dd.plot_type, k)
+    if k === :seriestype
+        v = type_alias(dd.plot_type, v)
+    end
+    dd.explicit[k] = v
+end
 
 # Reset to default value and return dict
 function reset_kw!(dd::DefaultsDict, k)

RecipesPipeline/test/runtests.jl

@@ -6,8 +6,10 @@ using Test
 import RecipesPipeline: _prepare_series_data
 import RecipesBase
 
+struct MyPlot end
+
 @testset "DefaultsDict" begin
-    dd = DefaultsDict(Dict(:foo => 1, :bar => missing), Dict(:foo => nothing, :baz => 'x'))
+    dd = DefaultsDict(MyPlot, Dict(:foo => 1, :bar => missing), Dict(:foo => nothing, :baz => 'x'))
 
     @test all(explicitkeys(dd) .== [:bar, :foo])
     @test all(defaultkeys(dd) .== [:baz, :foo])
@@ -44,7 +46,8 @@ end
     @test !is_axis_attribute(plt, :foo)
 
     @test process_userrecipe!(plt, [:foo], :bar) == [:foo, :bar]
-    @test type_alias(plt, :wireframe) ≡ :wireframe
+    @test type_alias(typeof(plt), :wireframe) ≡ :wireframe
+    @test key_alias(typeof(plt), :label) ≡ :label
 
     @test plot_setup!(plt, plotattributes, kw_list) isa Nothing
     @test slice_series_attributes!(plt, kw_list, kw) isa Nothing

ext/UnitfulExt.jl

@@ -152,7 +152,7 @@ function fixmarkercolor!(attr)
     ustripattribute!(attr, :clims, u)
     u == NoUnits || append_unit_if_needed!(attr, :colorbar_title, u)
 end
-fixmarkersize!(attr) = ustripattribute!(attr, :markersize)
+fixmarkersize!(attr) = ustripattribute!(attr, :marker_size)
 fixlinecolor!(attr) = ustripattribute!(attr, :line_z)
 
 # strip unit from attribute[key]

src/Plots.jl

@@ -26,7 +26,6 @@ import RecipesPipeline:
     timeformatter,
     needs_3d_axes,
     DefaultsDict,
-    explicitkeys,
     scale_func,
     is_surface,
     Formatted,