Refactor marker and line attributes

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,

src/arg_desc.jl

@@ -9,22 +9,22 @@ const _arg_desc = KW(
     :seriescolor        => (ColorType, "The base color for this series. `:auto` (the default) will select a color from the subplot's `color_palette`, based on the order it was added to the subplot. Also describes the colormap for surfaces."),
     :seriesalpha        => (Real, "The alpha/opacity override for the series. `nothing` (the default) means it will take the alpha value of the color."),
     :seriestype         => (Symbol, "This is the identifier of the type of visualization for this series. Choose from $(_allTypes) or any series recipes which are defined."),
-    :linestyle          => (Symbol, "Style of the line (for path and bar stroke). Choose from $(_allStyles)"),
-    :linewidth          => (Real, "Width of the line (in pixels)."),
-    :linecolor          => (ColorType, "Color of the line (for path and bar stroke). `:match` will take the value from `:seriescolor`, (though histogram/bar types use `:black` as a default)."),
-    :linealpha          => (Real, "The alpha/opacity override for the line. `nothing` (the default) means it will take the alpha value of linecolor."),
+    :line_style          => (Symbol, "Style of the line (for path and bar stroke). Choose from $(_allStyles)"),
+    :line_width          => (Real, "Width of the line (in pixels)."),
+    :line_color          => (ColorType, "Color of the line (for path and bar stroke). `:match` will take the value from `:seriescolor`, (though histogram/bar types use `:black` as a default)."),
+    :line_alpha          => (Real, "The alpha/opacity override for the line. `nothing` (the default) means it will take the alpha value of linecolor."),
     :fillrange          => (Union{Real,AVec}, "Fills area between fillrange and `y` for line-types, sets the base for `bar`, `sticks` types, and similar for other types."),
     :fillcolor          => (ColorType, "Color of the filled area of path or bar types. `:match` will take the value from `:seriescolor`."),
     :fillalpha          => (Real, "The alpha/opacity override for the fill area. `nothing` (the default) means it will take the alpha value of fillcolor."),
-    :markershape        => (Union{Symbol,Shape,AVec}, "Choose from $(_allMarkers)."),
+    :marker_shape        => (Union{Symbol,Shape,AVec}, "Choose from $(_allMarkers)."),
     :fillstyle          => (Symbol, "Style of the fill area. `nothing` (the default) means solid fill. Choose from :/, :\\, :|, :-, :+, :x."),
-    :markercolor        => (ColorType, "Color of the interior of the marker or shape. `:match` will take the value from `:seriescolor`."),
-    :markeralpha        => (Real, "The alpha/opacity override for the marker interior. `nothing` (the default) means it will take the alpha value of markercolor."),
-    :markersize         => (Union{Real,AVec}, "Size (radius pixels) of the markers."),
-    :markerstrokestyle  => (Symbol, "Style of the marker stroke (border). Choose from $(_allStyles)."),
-    :markerstrokewidth  => (Real, "Width of the marker stroke (border) in pixels."),
-    :markerstrokecolor  => (ColorType, "Color of the marker stroke (border). `:match` will take the value from `:foreground_color_subplot`."),
-    :markerstrokealpha  => (Real, "The alpha/opacity override for the marker stroke (border). `nothing` (the default) means it will take the alpha value of markerstrokecolor."),
+    :marker_color        => (ColorType, "Color of the interior of the marker or shape. `:match` will take the value from `:seriescolor`."),
+    :marker_alpha        => (Real, "The alpha/opacity override for the marker interior. `nothing` (the default) means it will take the alpha value of markercolor."),
+    :marker_size         => (Union{Real,AVec}, "Size (radius pixels) of the markers."),
+    :marker_stroke_style  => (Symbol, "Style of the marker stroke (border). Choose from $(_allStyles)."),
+    :marker_stroke_width  => (Real, "Width of the marker stroke (border) in pixels."),
+    :marker_stroke_color  => (ColorType, "Color of the marker stroke (border). `:match` will take the value from `:foreground_color_subplot`."),
+    :marker_stroke_alpha  => (Real, "The alpha/opacity override for the marker stroke (border). `nothing` (the default) means it will take the alpha value of markerstrokecolor."),
     :bins               => (Union{Integer,NTuple{2,Integer},AVec,Symbol}, """
                         Default is :auto (the Freedman-Diaconis rule). For histogram-types, defines the approximate number of bins to aim for, or the auto-binning algorithm to use (:sturges, :sqrt, :rice, :scott or :fd).
                         For fine-grained control pass a Vector of break values, e.g. `range(minimum(x), stop = maximum(x), length = 25)`."""),
@@ -195,7 +195,7 @@ const _arg_desc = KW(
     :showaxis                    => (Union{Bool,Symbol,AStr}, "Show the axis. `true`, `false`, `:show`, `:hide`, `:yes`, `:no`, `:x`, `:y`, `:z`, `:xy`, ..., `:all`, `:off`."),
     :widen                       => (Union{Bool,Real,Symbol}, """
                                     Widen the axis limits by a small factor to avoid cut-off markers and lines at the borders.
-                                    If set to `true`, scale the axis limits by the default factor of $(default_widen_factor). 
+                                    If set to `true`, scale the axis limits by the default factor of $(default_widen_factor).
                                     A different factor may be specified by setting `widen` to a number.
                                     Defaults to `:auto`, which widens by the default factor unless limits were manually set.
                                     See also the `scale_limits!` function for scaling axis limits in an existing plot."""),