bump version [skip ci]

Project.toml

@@ -1,7 +1,7 @@
 name = "Plots"
 uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
 author = ["Tom Breloff (@tbreloff)"]
-version = "1.0.14"
+version = "1.0.11"
 
 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"

src/args.jl

@@ -681,14 +681,10 @@ function default(k::Symbol, v)
 end
 
 function default(; kw...)
-    if isempty(kw)
-        reset_defaults()
-    else
-        kw = KW(kw)
-        RecipesPipeline.preprocess_attributes!(kw)
-        for (k,v) in kw
-            default(k, v)
-        end
+    kw = KW(kw)
+    RecipesPipeline.preprocess_attributes!(kw)
+    for (k,v) in kw
+        default(k, v)
     end
 end
 

src/axes.jl

@@ -462,12 +462,11 @@ function axis_limits(sp, letter, should_widen = default_should_widen(sp[Symbol(l
     lims = axis[:lims]
     has_user_lims = (isa(lims, Tuple) || isa(lims, AVec)) && length(lims) == 2
     if has_user_lims
-        lmin, lmax = lims
-        if lmin != :auto && isfinite(lmin)
-            amin = lmin
+        if isfinite(lims[1])
+            amin = lims[1]
         end
-        if lmax != :auto && isfinite(lmax)
-            amax = lmax
+        if isfinite(lims[2])
+            amax = lims[2]
         end
     end
     if amax <= amin && isfinite(amin)

src/backends/plotlyjs.jl

@@ -40,9 +40,11 @@ _show(io::IO, ::MIME"text/html", plt::Plot{PlotlyJSBackend}) = write(io, standal
 
 _display(plt::Plot{PlotlyJSBackend}) = display(plotlyjs_syncplot(plt))
 
-function PlotlyJS.WebIO.render(plt::Plot{PlotlyJSBackend})
-    plt_html = sprint(show, MIME("text/html"), plt)
-    return PlotlyJS.WebIO.render(PlotlyJS.WebIO.dom"div"(innerHTML=plt_html))
+@require WebIO = "0f1e0344-ec1d-5b48-a673-e5cf874b6c29" begin
+    function WebIO.render(plt::Plot{PlotlyJSBackend})
+        plt_html = sprint(show, MIME("text/html"), plt)
+        return WebIO.render(WebIO.dom"div"(innerHTML=plt_html))
+    end
 end
 
 function closeall(::PlotlyJSBackend)

src/backends/pyplot.jl

@@ -229,6 +229,11 @@ function fix_xy_lengths!(plt::Plot{PyPlotBackend}, series::Series)
     end
 end
 
+py_linecolor(series::Series)          = py_color(series[:linecolor])
+py_markercolor(series::Series)        = py_color(series[:markercolor])
+py_markerstrokecolor(series::Series)  = py_color(series[:markerstrokecolor])
+py_fillcolor(series::Series)          = py_color(series[:fillcolor])
+
 py_linecolormap(series::Series)       = py_colormap(series[:linecolor])
 py_markercolormap(series::Series)     = py_colormap(series[:markercolor])
 py_fillcolormap(series::Series)       = py_colormap(series[:fillcolor])
@@ -481,8 +486,8 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                         :arrowstyle => "simple,head_length=$(a.headlength),head_width=$(a.headwidth)",
                         :shrinkA => 0,
                         :shrinkB => 0,
-                        :edgecolor => py_color(get_linecolor(series)),
-                        :facecolor => py_color(get_linecolor(series)),
+                        :edgecolor => py_linecolor(series),
+                        :facecolor => py_linecolor(series),
                         :linewidth => py_thickness_scale(plt, get_linewidth(series)),
                         :linestyle => py_linestyle(st, get_linestyle(series)),
                     )
@@ -528,11 +533,11 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
             handle = []
             x,y = xyargs
             shapes = series[:markershape]
-            msc = py_color(get_markerstrokecolor(series), get_markerstrokealpha(series))
+            msc = py_markerstrokecolor(series)
             lw = py_thickness_scale(plt, series[:markerstrokewidth])
             for i=eachindex(y)
                 if series[:marker_z] !== nothing
-                    extrakw[:c] = [py_color(get_markercolor(series, i), get_markercoloralpha(series, i))]
+                    extrakw[:c] = [py_color(get_markercolor(series, i))]
                 end
 
                 push!(handle, ax."scatter"(_cycle(x,i), _cycle(y,i);
@@ -540,7 +545,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                     zorder = series[:series_plotindex] + 0.5,
                     marker = py_marker(_cycle(shapes,i)),
                     s =  py_thickness_scale(plt, _cycle(series[:markersize],i) .^ 2),
-                    facecolors = py_color(get_markercolor(series, i), get_markercoloralpha(series, i)),
+                    facecolors = get_markercolor(series, i),
                     edgecolors = msc,
                     linewidths = lw,
                     extrakw...
@@ -580,7 +585,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                   zorder = series[:series_plotindex] + 0.5,
                   marker = prev_marker,
                   s = cur_scale_list,
-                  edgecolors = py_color(get_markerstrokecolor(series), get_markerstrokealpha(series)),  # Do we need include i?
+                  edgecolors = py_markerstrokecolor(series),
                   linewidths = py_thickness_scale(plt, series[:markerstrokewidth]),
                   facecolors = cur_color_list,
                   extrakw...
@@ -601,7 +606,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                 zorder = series[:series_plotindex] + 0.5,
                 marker = prev_marker,
                 s = cur_scale_list,
-                edgecolors = py_color(get_markerstrokecolor(series), get_markerstrokealpha(series)),
+                edgecolors = py_markerstrokecolor(series),
                 linewidths = py_thickness_scale(plt, series[:markerstrokewidth]),
                 facecolors = cur_color_list,
                 extrakw...
@@ -616,7 +621,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                 zorder = series[:series_plotindex] + 0.5,
                 marker = py_marker(series[:markershape]),
                 s = py_thickness_scale(plt, series[:markersize] .^ 2),
-                edgecolors = py_color(get_markerstrokecolor(series), get_markerstrokealpha(series)),
+                edgecolors = py_markerstrokecolor(series),
                 linewidths = py_thickness_scale(plt, series[:markerstrokewidth]),
                 extrakw...
             )
@@ -630,7 +635,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
             zorder = series[:series_plotindex],
             gridsize = series[:bins],
             linewidths = py_thickness_scale(plt, series[:linewidth]),
-            edgecolors = py_color(get_linecolor(series)),
+            edgecolors = py_linecolor(series),
             cmap = py_fillcolormap(series),  # applies to the pcolorfast object
             extrakw...
         )
@@ -703,7 +708,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                 rstride = series[:stride][1],
                 cstride = series[:stride][2],
                 linewidth = py_thickness_scale(plt, series[:linewidth]),
-                edgecolor = py_color(get_linecolor(series)),
+                edgecolor = py_linecolor(series),
                 extrakw...
             )
             push!(handles, handle)
@@ -729,7 +734,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                 zorder = series[:series_plotindex],
                 cmap = py_fillcolormap(series),
                 linewidth = py_thickness_scale(plt, series[:linewidth]),
-                edgecolor = py_color(get_linecolor(series)),
+                edgecolor = py_linecolor(series),
                 extrakw...
             )
             push!(handles, handle)
@@ -1101,10 +1106,7 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
                 ticks[2][ticks[1] .== 0] .= ""
             end
             axis[:ticks] != :native ? py_set_ticks(ax, ticks, letter) : nothing
-
-            intensity = 0.5  # This value corresponds to scaling of other grid elements
-            pyaxis."set_tick_params"(direction = axis[:tick_direction] == :out ? "out" : "in", width=py_thickness_scale(plt, intensity))
-
+            pyaxis."set_tick_params"(direction = axis[:tick_direction] == :out ? "out" : "in")
             getproperty(ax, Symbol("set_", letter, "label"))(axis[:guide])
             if get(axis.plotattributes, :flip, false)
                 getproperty(ax, Symbol("invert_", letter, "axis"))()
@@ -1306,29 +1308,25 @@ function py_add_legend(plt::Plot, sp::Subplot, ax)
             if should_add_to_legend(series)
                 clims = get_clims(sp, series)
                 # add a line/marker and a label
-                push!(handles,
-                    if series[:seriestype] == :shape || series[:fillrange] !== nothing
-                        pypatches."Patch"(
-                            edgecolor = py_color(single_color(get_linecolor(series, clims)), get_linealpha(series)),
-                            facecolor = py_color(single_color(get_fillcolor(series, clims)), get_fillalpha(series)),
-                            linewidth = py_thickness_scale(plt, clamp(get_linewidth(series), 0, 5)),
-                            linestyle = py_linestyle(series[:seriestype], get_linestyle(series))
-                        )
-                    elseif series[:seriestype] in (:path, :straightline, :scatter)
-                        PyPlot.plt."Line2D"((0,1),(0,0),
-                            color = py_color(single_color(get_linecolor(series, clims)), get_linealpha(series)),
-                            linewidth = py_thickness_scale(plt, clamp(get_linewidth(series), 0, 5)),
-                            linestyle = py_linestyle(:path, get_linestyle(series)),
-                            marker = py_marker(_cycle(series[:markershape], 1)),
-                            # markersize = py_thickness_scale(plt, series[:markersize]), # In case we decide that markersize needs to be scaled in the legend too
-                            markeredgecolor = py_color(single_color(get_markerstrokecolor(series)), get_markerstrokealpha(series)),
-                            markerfacecolor = py_color(single_color(get_markercolor(series, clims)), get_markeralpha(series)),
-                            markeredgewidth = py_thickness_scale(plt, series[:markerstrokewidth])
-                        )
-                    else
-                        series[:serieshandle][1]
-                    end
-                )
+                push!(handles, if series[:seriestype] == :shape || series[:fillrange] !== nothing
+                    pypatches."Patch"(
+                        edgecolor = py_color(single_color(get_linecolor(series, clims)), get_linealpha(series)),
+                        facecolor = py_color(single_color(get_fillcolor(series, clims)), get_fillalpha(series)),
+                        linewidth = py_thickness_scale(plt, clamp(get_linewidth(series), 0, 5)),
+                        linestyle = py_linestyle(series[:seriestype], get_linestyle(series))
+                    )
+                elseif series[:seriestype] in (:path, :straightline, :scatter)
+                    PyPlot.plt."Line2D"((0,1),(0,0),
+                        color = py_color(single_color(get_linecolor(series, clims)), get_linealpha(series)),
+                        linewidth = py_thickness_scale(plt, clamp(get_linewidth(series), 0, 5)),
+                        linestyle = py_linestyle(:path, get_linestyle(series)),
+                        marker = py_marker(_cycle(series[:markershape], 1)),
+                        markeredgecolor = py_color(single_color(get_markerstrokecolor(series)), get_markerstrokealpha(series)),
+                        markerfacecolor = py_color(single_color(get_markercolor(series, clims)), get_markeralpha(series))
+                    )
+                else
+                    series[:serieshandle][1]
+                end)
                 push!(labels, series[:label])
             end
         end
@@ -1344,7 +1342,6 @@ function py_add_legend(plt::Plot, sp::Subplot, ax)
                 facecolor = py_color(sp[:background_color_legend]),
                 edgecolor = py_color(sp[:foreground_color_legend]),
                 framealpha = alpha(plot_color(sp[:background_color_legend])),
-                fancybox = false  # makes the legend box square
             )
             frame = leg."get_frame"()
             frame."set_linewidth"(py_thickness_scale(plt, 1))

src/output.jl

@@ -1,51 +1,54 @@
 
+
 defaultOutputFormat(plt::Plot) = "png"
 
 function png(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "png")
-    io = open(fn, "w")
-    show(io, MIME("image/png"), plt)
-    close(io)
+  fn = addExtension(fn, "png")
+  io = open(fn, "w")
+  show(io, MIME("image/png"), plt)
+  close(io)
 end
 png(fn::AbstractString) = png(current(), fn)
 
 function svg(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "svg")
-    io = open(fn, "w")
-    show(io, MIME("image/svg+xml"), plt)
-    close(io)
+  fn = addExtension(fn, "svg")
+  io = open(fn, "w")
+  show(io, MIME("image/svg+xml"), plt)
+  close(io)
 end
 svg(fn::AbstractString) = svg(current(), fn)
 
+
 function pdf(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "pdf")
-    io = open(fn, "w")
-    show(io, MIME("application/pdf"), plt)
-    close(io)
+  fn = addExtension(fn, "pdf")
+  io = open(fn, "w")
+  show(io, MIME("application/pdf"), plt)
+  close(io)
 end
 pdf(fn::AbstractString) = pdf(current(), fn)
 
+
 function ps(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "ps")
-    io = open(fn, "w")
-    show(io, MIME("application/postscript"), plt)
-    close(io)
+  fn = addExtension(fn, "ps")
+  io = open(fn, "w")
+  show(io, MIME("application/postscript"), plt)
+  close(io)
 end
 ps(fn::AbstractString) = ps(current(), fn)
 
 function eps(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "eps")
-    io = open(fn, "w")
-    show(io, MIME("image/eps"), plt)
-    close(io)
+  fn = addExtension(fn, "eps")
+  io = open(fn, "w")
+  show(io, MIME("image/eps"), plt)
+  close(io)
 end
 eps(fn::AbstractString) = eps(current(), fn)
 
 function tex(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "tex")
-    io = open(fn, "w")
-    show(io, MIME("application/x-tex"), plt)
-    close(io)
+  fn = addExtension(fn, "tex")
+  io = open(fn, "w")
+  show(io, MIME("application/x-tex"), plt)
+  close(io)
 end
 tex(fn::AbstractString) = tex(current(), fn)
 
@@ -66,39 +69,48 @@ end
 html(fn::AbstractString) = html(current(), fn)
 
 function txt(plt::Plot, fn::AbstractString)
-    fn = addExtension(fn, "txt")
-    io = open(fn, "w")
-    show(io, MIME("text/plain"), plt)
-    close(io)
+  fn = addExtension(fn, "txt")
+  io = open(fn, "w")
+  show(io, MIME("text/plain"), plt)
+  close(io)
 end
 txt(fn::AbstractString) = txt(current(), fn)
 
-
 # ----------------------------------------------------------------
 
+
 const _savemap = Dict(
     "png" => png,
     "svg" => svg,
     "pdf" => pdf,
-    "ps" => ps,
+    "ps"  => ps,
     "eps" => eps,
     "tex" => tex,
     "json" => json,
     "html" => html,
     "tikz" => tex,
     "txt" => txt,
-)
+  )
 
-const _extension_map = Dict("tikz" => "tex")
+function getExtension(fn::AbstractString)
+  pieces = split(fn, ".")
+  length(pieces) > 1 || error("Can't extract file extension: ", fn)
+  ext = pieces[end]
+  haskey(_savemap, ext) || error("Invalid file extension: ", fn)
+  ext
+end
 
 function addExtension(fn::AbstractString, ext::AbstractString)
-    oldfn, oldext = splitext(fn)
-    oldext = chop(oldext, head = 1, tail = 0)
-    if get(_extension_map, oldext, oldext) == ext
-        return fn
+  try
+    oldext = getExtension(fn)
+    if oldext == ext
+      return fn
     else
-        return string(fn, ".", ext)
+      return "$fn.$ext"
     end
+  catch
+    return "$fn.$ext"
+  end
 end
 
 """
@@ -109,28 +121,27 @@ type is inferred from the file extension. All backends support png and pdf
 file types, some also support svg, ps, eps, html and tex.
 """
 function savefig(plt::Plot, fn::AbstractString)
-    fn = abspath(expanduser(fn))
+  fn = abspath(expanduser(fn))
+  # get the extension
+  local ext
+  try
+    ext = getExtension(fn)
+  catch
+    # if we couldn't extract the extension, add the default
+    ext = defaultOutputFormat(plt)
+    fn = addExtension(fn, ext)
+  end
 
-    # get the extension
-    fn, ext = splitext(fn)
-    ext = chop(ext, head = 1, tail = 0)
-    if isempty(ext)
-        ext = defaultOutputFormat(plt)
-    end
-
-    # save it
-    if haskey(_savemap, ext)
-        func = _savemap[ext]
-        return func(plt, fn)
-    else
-        error("Invalid file extension: ", fn)
-    end
+  # save it
+  func = get(_savemap, ext) do
+    error("Unsupported extension $ext with filename ", fn)
+  end
+  func(plt, fn)
 end
 savefig(fn::AbstractString) = savefig(current(), fn)
 
 
 # ---------------------------------------------------------
-
 """
     gui([plot])
 
@@ -153,13 +164,17 @@ end
 _do_plot_show(plt, showval::Bool) = showval && gui(plt)
 function _do_plot_show(plt, showval::Symbol)
     showval == :gui && gui(plt)
-    showval in (:inline, :ijulia) && inline(plt)
+    showval in (:inline,:ijulia) && inline(plt)
 end
 
 # ---------------------------------------------------------
 
-const _best_html_output_type =
-    KW(:pyplot => :png, :unicodeplots => :txt, :plotlyjs => :html, :plotly => :html)
+const _best_html_output_type = KW(
+    :pyplot => :png,
+    :unicodeplots => :txt,
+    :plotlyjs => :html,
+    :plotly => :html
+)
 
 # a backup for html... passes to svg or png depending on the html_output_format arg
 function _show(io::IO, ::MIME"text/html", plt::Plot)
@@ -169,12 +184,7 @@ function _show(io::IO, ::MIME"text/html", plt::Plot)
     end
     if output_type == :png
         # @info("writing png to html output")
-        print(
-            io,
-            "<img src=\"data:image/png;base64,",
-            base64encode(show, MIME("image/png"), plt),
-            "\" />",
-        )
+        print(io, "<img src=\"data:image/png;base64,", base64encode(show, MIME("image/png"), plt), "\" />")
     elseif output_type == :svg
         # @info("writing svg to html output")
         show(io, MIME("image/svg+xml"), plt)
@@ -186,7 +196,7 @@ function _show(io::IO, ::MIME"text/html", plt::Plot)
 end
 
 # delegate showable to _show instead
-function Base.showable(m::M, plt::P) where {M <: MIME, P <: Plot}
+function Base.showable(m::M, plt::P) where {M<:MIME, P<:Plot}
     return hasmethod(_show, Tuple{IO, M, P})
 end
 
@@ -195,31 +205,21 @@ function _display(plt::Plot)
 end
 
 # for writing to io streams... first prepare, then callback
-for mime in (
-    "text/plain",
-    "text/html",
-    "image/png",
-    "image/eps",
-    "image/svg+xml",
-    "application/eps",
-    "application/pdf",
-    "application/postscript",
-    "application/x-tex",
-    "application/vnd.plotly.v1+json",
-)
+for mime in ("text/plain", "text/html", "image/png", "image/eps", "image/svg+xml",
+             "application/eps", "application/pdf", "application/postscript",
+             "application/x-tex", "application/vnd.plotly.v1+json")
     @eval function Base.show(io::IO, m::MIME{Symbol($mime)}, plt::Plot)
         if haskey(io, :juno_plotsize)
-            showjuno(io, m, plt)
+          showjuno(io, m, plt)
         else
-            prepare_output(plt)
-            _show(io, m, plt)
+          prepare_output(plt)
+          _show(io, m, plt)
         end
         return nothing
     end
 end
 
-Base.show(io::IO, m::MIME"application/prs.juno.plotpane+html", plt::Plot) =
-    showjuno(io, MIME("text/html"), plt)
+Base.show(io::IO, m::MIME"application/prs.juno.plotpane+html", plt::Plot) = showjuno(io, MIME("text/html"), plt)
 
 # default text/plain for all backends
 _show(io::IO, ::MIME{Symbol("text/plain")}, plt::Plot) = show(io, plt)
@@ -258,25 +258,25 @@ function showjuno(io::IO, m, plt)
 
     scale = minimum(jsize[i] / sz[i] for i in 1:2)
     plt[:size] = [s * scale for s in sz]
-    plt[:dpi] = jratio * Plots.DPI
+    plt[:dpi] = jratio*Plots.DPI
     plt[:thickness_scaling] *= scale
 
     prepare_output(plt)
     try
-        _showjuno(io, m, plt)
+      _showjuno(io, m, plt)
     finally
-        plt[:size] = sz
-        plt[:dpi] = dpi
-        plt[:thickness_scaling] = thickness_scaling
+      plt[:size] = sz
+      plt[:dpi] = dpi
+      plt[:thickness_scaling] = thickness_scaling
     end
 end
 
 function _showjuno(io::IO, m::MIME"image/svg+xml", plt)
-    if Symbol(plt.attr[:html_output_format]) ≠ :svg
-        throw(MethodError(show, (typeof(m), typeof(plt))))
-    else
-        _show(io, m, plt)
-    end
+  if Symbol(plt.attr[:html_output_format]) ≠ :svg
+    throw(MethodError(show, (typeof(m), typeof(plt))))
+  else
+    _show(io, m, plt)
+  end
 end
 
 Base.showable(::MIME"application/prs.juno.plotpane+html", plt::Plot) = false

src/shorthands.jl

@@ -438,9 +438,8 @@ julia> plot(1:10)
 julia> annotate!([(7,3,"(7,3)"),(3,7,text("hey", 14, :left, :top, :green))])
 ```
 """
-annotate!(anns...; kw...)             = plot!(; annotation = anns, kw...)
-annotate!(anns::Tuple...; kw...)      = plot!(; annotation = collect(anns), kw...)
-annotate!(anns::AVec{<:Tuple}; kw...) = plot!(; annotation = anns, kw...)
+annotate!(anns...; kw...)                                        = plot!(; annotation = collect(anns), kw...)
+annotate!(anns::AVec{T}; kw...) where {T<:Tuple}                 = plot!(; annotation = anns, kw...)
 
 "Flip the current plots' x axis"
 xflip!(flip::Bool = true; kw...)                          = plot!(; xflip = flip, kw...)