Update news.md

disable precompilation for release

NEWS.md

@@ -9,8 +9,31 @@
     - `backports` branch is for Julia 0.4
 
 ---
+## (current master)
 
-## 0.12 (current master/dev)
+## 0.12.2
+
+- fix an issue with Juno/PlotlyJS compatibility on new installations
+- fix markers not showing up in seriesrecipes using :scatter
+- don't use pywrap in the pyplot backend
+- improve the bottom margin for the gr backend
+
+## 0.12.1
+
+- fix deprecation warnings
+- switch from FixedSizeArrays to StaticArrays.FixedSizeArrays
+- drop FactCheck in tests
+- remove julia 0.5 compliant uses of transpose operator
+- fix GR heatmap bugs
+- fix GR guide padding
+- improve legend markers in GR
+- add surface alpha for Plotly(JS)
+- add fillrange to Plotly(JS)
+- allow usage of Matplotlib 1.5 with PyPlot
+- fix GLVisualize for julia 0.6
+- conform to changes in InspectDR
+
+#### 0.12.0
 
 - 0.6 only
 

REQUIRE

@@ -4,10 +4,12 @@ RecipesBase 0.2.0
 PlotUtils 0.4.1
 PlotThemes 0.1.3
 Reexport
-FixedSizeArrays
+StaticArrays 0.5
 FixedPointNumbers 0.3
 Measures
 Showoff
 StatsBase 0.14.0
 JSON
 NaNMath
+Requires
+Contour

src/Plots.jl

@@ -3,7 +3,10 @@ __precompile__(false)
 module Plots
 
 using Reexport
-using FixedSizeArrays
+
+import StaticArrays
+using StaticArrays.FixedSizeArrays
+
 @reexport using RecipesBase
 import RecipesBase: plot, animate
 using Base.Meta
@@ -148,12 +151,11 @@ include("layouts.jl")
 include("subplots.jl")
 include("recipes.jl")
 include("animation.jl")
-include("output.jl")
 include("examples.jl")
 include("arg_desc.jl")
 include("plotattr.jl")
 include("backends.jl")
-
+include("output.jl")
 
 # ---------------------------------------------------------
 
@@ -241,10 +243,8 @@ end
 
 const CURRENT_BACKEND = CurrentBackend(:none)
 
-function __init__()
-    setup_ijulia()
-    setup_atom()
-
+# for compatibility with Requires.jl:
+@init begin
     if isdefined(Main, :PLOTS_DEFAULTS)
         for (k,v) in Main.PLOTS_DEFAULTS
             default(k, v)

src/args.jl

@@ -336,6 +336,12 @@ const _all_defaults = KW[
     _axis_defaults_byletter
 ]
 
+# to be able to reset font sizes to initial values
+const _initial_fontsizes = Dict(:titlefont  => _subplot_defaults[:titlefont].pointsize,
+                                :legendfont => _subplot_defaults[:legendfont].pointsize,
+                                :tickfont   => _axis_defaults[:tickfont].pointsize,
+                                :guidefont  => _axis_defaults[:guidefont].pointsize)
+
 const _all_args = sort(collect(union(map(keys, _all_defaults)...)))
 
 RecipesBase.is_key_supported(k::Symbol) = is_attr_supported(k)
@@ -522,7 +528,6 @@ function default(d::KW, k::Symbol)
 end
 
 
-
 # -----------------------------------------------------------------------------
 
 # if arg is a valid color value, then set d[csym] and return true
@@ -701,6 +706,9 @@ function preprocessArgs!(d::KW)
     delete!(d, :marker)
     if haskey(d, :markershape)
         d[:markershape] = _replace_markershape(d[:markershape])
+        if d[:markershape] == :none && d[:seriestype] in (:scatter, :scatterbins, :scatterhist, :scatter3d) #the default should be :auto, not :none, so that :none can be set explicitly and would be respected
+            d[:markershape] = :circle
+        end
     elseif anymarker
         d[:markershape_to_add] = :circle  # add it after _apply_recipe
     end

src/backends/glvisualize.jl

@@ -58,7 +58,7 @@ const _glvisualize_scale = [:identity, :ln, :log2, :log10]
 function _initialize_backend(::GLVisualizeBackend; kw...)
     @eval begin
         import GLVisualize, GeometryTypes, Reactive, GLAbstraction, GLWindow, Contour
-        import GeometryTypes: Point2f0, Point3f0, Vec2f0, Vec3f0, GLNormalMesh, SimpleRectangle
+        import GeometryTypes: Point2f0, Point3f0, Vec2f0, Vec3f0, GLNormalMesh, SimpleRectangle, Point, Vec
         import FileIO, Images
         export GLVisualize
         import Reactive: Signal
@@ -66,9 +66,8 @@ function _initialize_backend(::GLVisualizeBackend; kw...)
         import GLVisualize: visualize
         import Plots.GL
         import UnicodeFun
-        Plots.slice_arg(img::Images.AbstractImage, idx::Int) = img
+        Plots.slice_arg{C<:Colorant}(img::Matrix{C}, idx::Int) = img
         is_marker_supported(::GLVisualizeBackend, shape::GLVisualize.AllPrimitives) = true
-        is_marker_supported{Img<:Images.AbstractImage}(::GLVisualizeBackend, shape::Union{Vector{Img}, Img}) = true
         is_marker_supported{C<:Colorant}(::GLVisualizeBackend, shape::Union{Vector{Matrix{C}}, Matrix{C}}) = true
         is_marker_supported(::GLVisualizeBackend, shape::Shape) = true
         const GL = Plots
@@ -173,12 +172,12 @@ function gl_marker(shape)
     shape
 end
 function gl_marker(shape::Shape)
-    points = Point2f0[Vec{2,Float32}(p) for p in zip(shape.x, shape.y)]
+    points = Point2f0[GeometryTypes.Vec{2, Float32}(p) for p in zip(shape.x, shape.y)]
     bb = GeometryTypes.AABB(points)
     mini, maxi = minimum(bb), maximum(bb)
     w3 = maxi-mini
     origin, width = Point2f0(mini[1], mini[2]), Point2f0(w3[1], w3[2])
-    map!(p -> ((p - origin) ./ width) - 0.5f0, points) # normalize and center
+    map!(p -> ((p - origin) ./ width) - 0.5f0, points, points) # normalize and center
     GeometryTypes.GLNormalMesh(points)
 end
 # create a marker/shape type
@@ -212,13 +211,13 @@ function extract_limits(sp, d, kw_args)
     nothing
 end
 
-to_vec{T <: FixedVector}(::Type{T}, vec::T) = vec
-to_vec{T <: FixedVector}(::Type{T}, s::Number) = T(s)
+to_vec{T <: StaticArrays.StaticVector}(::Type{T}, vec::T) = vec
+to_vec{T <: StaticArrays.StaticVector}(::Type{T}, s::Number) = T(s)
 
-to_vec{T <: FixedVector{2}}(::Type{T}, vec::FixedVector{3}) = T(vec[1], vec[2])
-to_vec{T <: FixedVector{3}}(::Type{T}, vec::FixedVector{2}) = T(vec[1], vec[2], 0)
+to_vec{T <: StaticArrays.StaticVector{2}}(::Type{T}, vec::StaticArrays.StaticVector{3}) = T(vec[1], vec[2])
+to_vec{T <: StaticArrays.StaticVector{3}}(::Type{T}, vec::StaticArrays.StaticVector{2}) = T(vec[1], vec[2], 0)
 
-to_vec{T <: FixedVector}(::Type{T}, vecs::AbstractVector) = map(x-> to_vec(T, x), vecs)
+to_vec{T <: StaticArrays.StaticVector}(::Type{T}, vecs::AbstractVector) = map(x-> to_vec(T, x), vecs)
 
 function extract_marker(d, kw_args)
     dim = Plots.is3d(d) ? 3 : 2
@@ -274,7 +273,7 @@ function extract_surface(d)
     map(_extract_surface, (d[:x], d[:y], d[:z]))
 end
 function topoints{P}(::Type{P}, array)
-    P[x for x in zip(array...)]
+    [P(x) for x in zip(array...)]
 end
 function extract_points(d)
     dim = is3d(d) ? 3 : 2
@@ -576,8 +575,10 @@ end
 
 function align_offset(startpos, lastpos, atlas, rscale, font, align)
     xscale, yscale = GLVisualize.glyph_scale!('X', rscale)
-    xmove = (lastpos-startpos)[1]+xscale
-    if align == :top
+    xmove = (lastpos-startpos)[1] + xscale
+    if isa(align, GeometryTypes.Vec)
+        return -Vec2f0(xmove, yscale) .* align
+    elseif align == :top
         return -Vec2f0(xmove/2f0, yscale)
     elseif align == :right
         return -Vec2f0(xmove, yscale/2f0)
@@ -586,11 +587,6 @@ function align_offset(startpos, lastpos, atlas, rscale, font, align)
     end
 end
 
-function align_offset(startpos, lastpos, atlas, rscale, font, align::Vec)
-    xscale, yscale = GLVisualize.glyph_scale!('X', rscale)
-    xmove = (lastpos-startpos)[1] + xscale
-    return -Vec2f0(xmove, yscale) .* align
-end
 
 function alignment2num(x::Symbol)
     (x in (:hcenter, :vcenter)) && return 0.5
@@ -638,7 +634,7 @@ function draw_ticks(
         position = GLVisualize.calc_position(str, startpos, sz, font, atlas)
         offset = GLVisualize.calc_offset(str, sz, font, atlas)
         alignoff = align_offset(startpos, last(position), atlas, sz, font, align)
-        map!(position) do pos
+        map!(position, position) do pos
             pos .+ alignoff
         end
         append!(positions, position)
@@ -660,7 +656,7 @@ function glvisualize_text(position, text, kw_args)
     offset = GLVisualize.calc_offset(text.str, rscale, font, atlas)
     alignoff = align_offset(startpos, last(position), atlas, rscale, font, text_align)
 
-    map!(position) do pos
+    map!(position, position) do pos
         pos .+ alignoff
     end
     kw_args[:position] = position
@@ -792,7 +788,7 @@ function gl_bar(d, kw_args)
         fillto = 0
     end
     # create the bar shapes by adding x/y segments
-    positions, scales = Array(Point2f0, ny), Array(Vec2f0, ny)
+    positions, scales = Array{Point2f0}(ny), Array{Vec2f0}(ny)
     m = Reactive.value(kw_args[:model])
     sx, sy = m[1,1], m[2,2]
     for i=1:ny
@@ -943,7 +939,7 @@ function scale_for_annotations!(series::Series, scaletype::Symbol = :pixels)
         # we use baseshape to overwrite the markershape attribute
         # with a list of custom shapes for each
         msw, msh = anns.scalefactor
-        offsets = Array(Vec2f0, length(anns.strs))
+        offsets = Array{Vec2f0}(length(anns.strs))
         series[:markersize] = map(1:length(anns.strs)) do i
             str = _cycle(anns.strs, i)
             # get the width and height of the string (in mm)
@@ -1122,7 +1118,7 @@ function _display(plt::Plot{GLVisualizeBackend}, visible = true)
             anns = series[:series_annotations]
             for (x, y, str, font) in EachAnn(anns, d[:x], d[:y])
                 txt_args = Dict{Symbol, Any}(:model => eye(GLAbstraction.Mat4f0))
-                x, y = Reactive.value(model_m) * Vec{4, Float32}(x, y, 0, 1)
+                x, y = Reactive.value(model_m) * GeometryTypes.Vec{4, Float32}(x, y, 0, 1)
                 extract_font(font, txt_args)
                 t = glvisualize_text(Point2f0(x, y), PlotText(str, font), txt_args)
                 GLVisualize._view(t, sp_screen, camera = :perspective)
@@ -1148,10 +1144,7 @@ function _show(io::IO, ::MIME"image/png", plt::Plot{GLVisualizeBackend})
     GLWindow.render_frame(GLWindow.rootscreen(plt.o))
     GLWindow.swapbuffers(plt.o)
     buff = GLWindow.screenbuffer(plt.o)
-    png = Images.Image(map(RGB{U8}, buff),
-        colorspace = "sRGB",
-        spatialorder = ["y", "x"]
-    )
+    png = map(RGB{U8}, buff)
     FileIO.save(FileIO.Stream(FileIO.DataFormat{:PNG}, io), png)
 end
 
@@ -1309,8 +1302,8 @@ function gl_contour(x, y, z, kw_args)
     if kw_args[:fillrange] != nothing
 
         delete!(kw_args, :intensity)
-        I = GLVisualize.Intensity{1, Float32}
-        main = I[z[j,i] for i=1:size(z, 2), j=1:size(z, 1)]
+        I = GLVisualize.Intensity{Float32}
+        main = [I(z[j,i]) for i=1:size(z, 2), j=1:size(z, 1)]
         return visualize(main, Style(:default), kw_args)
 
     else
@@ -1342,7 +1335,7 @@ function gl_heatmap(x,y,z, kw_args)
     get!(kw_args, :color_norm, Vec2f0(ignorenan_extrema(z)))
     get!(kw_args, :color_map, Plots.make_gradient(cgrad()))
     delete!(kw_args, :intensity)
-    I = GLVisualize.Intensity{1, Float32}
+    I = GLVisualize.Intensity{Float32}
     heatmap = I[z[j,i] for i=1:size(z, 2), j=1:size(z, 1)]
     tex = GLAbstraction.Texture(heatmap, minfilter=:nearest)
     kw_args[:stroke_width] = 0f0

src/backends/gr.jl

@@ -272,6 +272,10 @@ function normalize_zvals(zv::AVec)
     end
 end
 
+
+gr_alpha(α::Void) = 1
+gr_alpha(α::Real) = α
+
 # ---------------------------------------------------------
 
 # draw ONE Shape
@@ -353,7 +357,7 @@ function gr_set_fill(c) #, a)
 end
 
 # this stores the conversion from a font pointsize to "percentage of window height" (which is what GR uses)
-const _gr_point_mult = zeros(1)
+const _gr_point_mult = 0.0018 * ones(1)
 
 # set the font attributes... assumes _gr_point_mult has been populated already
 function gr_set_font(f::Font; halign = f.halign, valign = f.valign,
@@ -384,7 +388,7 @@ end
 const viewport_plotarea = zeros(4)
 
 # the size of the current plot in pixels
-const gr_plot_size = zeros(2)
+const gr_plot_size = [600.0, 400.0]
 
 function gr_viewport_from_bbox(sp::Subplot{GRBackend}, bb::BoundingBox, w, h, viewport_canvas)
     viewport = zeros(4)
@@ -534,7 +538,35 @@ end
 
 
 function _update_min_padding!(sp::Subplot{GRBackend})
-    sp.minpad = (10mm,2mm,2mm,8mm)
+    leftpad   = 10mm
+    toppad    = 2mm
+    rightpad  = 2mm
+    bottompad = 6mm
+    if sp[:title] != ""
+        toppad += 5mm
+    end
+    if sp[:xaxis][:guide] != ""
+        xticks = axis_drawing_info(sp)[1]
+        if !(xticks in (nothing, false))
+            gr_set_font(sp[:xaxis][:tickfont],
+                        halign = (:left, :hcenter, :right)[sign(sp[:xaxis][:rotation]) + 2],
+                        valign = :top,
+                        color = sp[:xaxis][:foreground_color_axis],
+                        rotation = sp[:xaxis][:rotation])
+            h = 0
+            for (cv, dv) in zip(xticks...)
+                tbx, tby = gr_inqtext(0, 0, string(dv))
+                h = max(h, tby[2] - tby[1])
+            end
+            bottompad += 1mm + gr_plot_size[2] * h * px
+        else
+            bottompad += 4mm
+        end
+    end
+    if sp[:yaxis][:guide] != ""
+        leftpad += 4mm
+    end
+    sp.minpad = (leftpad, toppad, rightpad, bottompad)
 end
 
 
@@ -544,6 +576,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
     viewport_plotarea[:] = gr_viewport_from_bbox(sp, plotarea(sp), w, h, viewport_canvas)
     # get data limits
     data_lims = gr_xy_axislims(sp)
+    xy_lims = data_lims
 
     ratio = sp[:aspect_ratio]
     if ratio != :none
@@ -585,7 +618,8 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
         end
         if st == :heatmap
             outside_ticks = true
-            x, y = heatmap_edges(series[:x]), heatmap_edges(series[:y])
+            x, y = heatmap_edges(series[:x], sp[:xaxis][:scale]), heatmap_edges(series[:y], sp[:yaxis][:scale])
+            xy_lims = x[1], x[end], y[1], y[end]
             expand_extrema!(sp[:xaxis], x)
             expand_extrema!(sp[:yaxis], y)
             data_lims = gr_xy_axislims(sp)
@@ -851,7 +885,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
             # create the colorbar of contour levels
             if sp[:colorbar] != :none
                 gr_set_viewport_cmap(sp)
-                l = round(Int32, 1000 + (h - ignorenan_minimum(h)) / (ignorenan_maximum(h) - ignorenan_minimum(h)) * 255)
+                l = round.(Int32, 1000 + (h - ignorenan_minimum(h)) / (ignorenan_maximum(h) - ignorenan_minimum(h)) * 255)
                 GR.setwindow(xmin, xmax, zmin, zmax)
                 GR.cellarray(xmin, xmax, zmax, zmin, 1, length(l), l)
                 ztick = 0.5 * GR.tick(zmin, zmax)
@@ -873,6 +907,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
             cmap && gr_colorbar(sp)
 
         elseif st == :heatmap
+            xmin, xmax, ymin, ymax = xy_lims
             zmin, zmax = gr_lims(zaxis, true)
             clims = sp[:clims]
             if is_2tuple(clims)
@@ -886,7 +921,8 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
                                     round(Int,  blue(c) * 255) << 16 +
                                     round(Int, green(c) * 255) << 8  +
                                     round(Int,   red(c) * 255) ), colors)
-            GR.drawimage(xmin, xmax, ymax, ymin, length(x), length(y), rgba)
+            w, h = length(x), length(y)
+            GR.drawimage(xmin, xmax, ymax, ymin, w, h, rgba)
             cmap && gr_colorbar(sp)
 
         elseif st in (:path3d, :scatter3d)
@@ -1038,6 +1074,7 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
             if sp[:legendtitle] != nothing
                 GR.settextalign(GR.TEXT_HALIGN_CENTER, GR.TEXT_VALIGN_HALF)
                 gr_set_textcolor(sp[:foreground_color_legend])
+                GR.settransparency(1)
                 gr_text(xpos - 0.03 + 0.5*w, ypos, string(sp[:legendtitle]))
                 ypos -= dy
             end
@@ -1045,16 +1082,26 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
                 should_add_to_legend(series) || continue
                 st = series[:seriestype]
                 gr_set_line(series[:linewidth], series[:linestyle], series[:linecolor]) #, series[:linealpha])
-                if st == :path && series[:fillrange] == nothing
-                    GR.polyline([xpos - 0.07, xpos - 0.01], [ypos, ypos])
-                elseif st == :shape || series[:fillrange] != nothing
+
+                if st == :shape || series[:fillrange] != nothing
                     gr_set_fill(series[:fillcolor]) #, series[:fillalpha])
                     l, r = xpos-0.07, xpos-0.01
                     b, t = ypos-0.4dy, ypos+0.4dy
                     x = [l, r, r, l, l]
                     y = [b, b, t, t, b]
+                    GR.settransparency(gr_alpha(series[:fillalpha]))
                     gr_polyline(x, y, GR.fillarea)
-                    gr_polyline(x, y)
+                    GR.settransparency(gr_alpha(series[:linealpha]))
+                    st == :shape && gr_polyline(x, y)
+                end
+
+                if st == :path
+                    GR.settransparency(gr_alpha(series[:linealpha]))
+                    if series[:fillrange] == nothing || series[:ribbon] != nothing
+                        GR.polyline([xpos - 0.07, xpos - 0.01], [ypos, ypos])
+                    else
+                        GR.polyline([xpos - 0.07, xpos - 0.01], [ypos+0.4dy, ypos+0.4dy])
+                    end
                 end
 
                 if series[:markershape] != :none

src/backends/inspectdr.jl

@@ -362,30 +362,29 @@ function _inspectdr_setupsubplot(sp::Subplot{InspectDRBackend})
         a.xlabel = xaxis[:guide]; a.ylabels = [yaxis[:guide]]
 
     l = plot.layout
-        l.frame.fillcolor = _inspectdr_mapcolor(sp[:background_color_subplot])
-        l.framedata.fillcolor = _inspectdr_mapcolor(sp[:background_color_inside])
-        l.framedata.line.color = _inspectdr_mapcolor(xaxis[:foreground_color_axis])
-        l.fnttitle = InspectDR.Font(sp[:titlefont].family,
+        l[:frame_canvas].fillcolor = _inspectdr_mapcolor(sp[:background_color_subplot])
+        l[:frame_data].fillcolor = _inspectdr_mapcolor(sp[:background_color_inside])
+        l[:frame_data].line.color = _inspectdr_mapcolor(xaxis[:foreground_color_axis])
+        l[:font_title] = InspectDR.Font(sp[:titlefont].family,
             _inspectdr_mapptsize(sp[:titlefont].pointsize),
             color = _inspectdr_mapcolor(sp[:foreground_color_title])
         )
         #Cannot independently control fonts of axes with InspectDR:
-        l.fntaxlabel = InspectDR.Font(xaxis[:guidefont].family,
+        l[:font_axislabel] = InspectDR.Font(xaxis[:guidefont].family,
             _inspectdr_mapptsize(xaxis[:guidefont].pointsize),
             color = _inspectdr_mapcolor(xaxis[:foreground_color_guide])
         )
-        l.fntticklabel = InspectDR.Font(xaxis[:tickfont].family,
+        l[:font_ticklabel] = InspectDR.Font(xaxis[:tickfont].family,
             _inspectdr_mapptsize(xaxis[:tickfont].pointsize),
             color = _inspectdr_mapcolor(xaxis[:foreground_color_text])
         )
-    leg = l.legend
-        leg.enabled = (sp[:legend] != :none)
-        #leg.width = 150 #TODO: compute???
-        leg.font = InspectDR.Font(sp[:legendfont].family,
+        l[:enable_legend] = (sp[:legend] != :none)
+        #l[:halloc_legend] = 150 #TODO: compute???
+        l[:font_legend] = InspectDR.Font(sp[:legendfont].family,
             _inspectdr_mapptsize(sp[:legendfont].pointsize),
             color = _inspectdr_mapcolor(sp[:foreground_color_legend])
         )
-        leg.frame.fillcolor = _inspectdr_mapcolor(sp[:background_color_legend])
+        l[:frame_legend].fillcolor = _inspectdr_mapcolor(sp[:background_color_legend])
 end
 
 # called just before updating layout bounding boxes... in case you need to prep
@@ -399,7 +398,7 @@ function _before_layout_calcs(plt::Plot{InspectDRBackend})
         #Don't use window_title... probably not what you want.
         #mplot.title = plt[:window_title]
     end
-    mplot.frame.fillcolor = _inspectdr_mapcolor(plt[:background_color_outside])
+    mplot.layout[:frame].fillcolor = _inspectdr_mapcolor(plt[:background_color_outside])
 
     resize!(mplot.subplots, length(plt.subplots))
     nsubplots = length(plt.subplots)
@@ -421,15 +420,15 @@ function _before_layout_calcs(plt::Plot{InspectDRBackend})
     #Do not yet support absolute plot positionning.
     #Just try to make things look more-or less ok:
     if nsubplots <= 1
-        mplot.ncolumns = 1
+        mplot.layout[:ncolumns] = 1
     elseif nsubplots <= 4
-        mplot.ncolumns = 2
+        mplot.layout[:ncolumns] = 2
     elseif nsubplots <= 6
-        mplot.ncolumns = 3
+        mplot.layout[:ncolumns] = 3
     elseif nsubplots <= 12
-        mplot.ncolumns = 4
+        mplot.layout[:ncolumns] = 4
     else
-        mplot.ncolumns = 5
+        mplot.layout[:ncolumns] = 5
     end
 
     for series in plt.series_list
@@ -446,7 +445,7 @@ function _update_min_padding!(sp::Subplot{InspectDRBackend})
     plot = sp.o
     if !isa(plot, InspectDR.Plot2D); return sp.minpad; end
     #Computing plotbounds with 0-BoundingBox returns required padding:
-    bb = InspectDR.plotbounds(plot.layout, InspectDR.BoundingBox(0,0,0,0))
+    bb = InspectDR.plotbounds(plot.layout.values, InspectDR.BoundingBox(0,0,0,0))
     #NOTE: plotbounds always pads for titles, legends, etc. even if not in use.
     #TODO: possibly zero-out items not in use??
 
@@ -468,7 +467,7 @@ function _update_plot_object(plt::Plot{InspectDRBackend})
     for (i, sp) in enumerate(plt.subplots)
         graphbb = _inspectdr_to_pixels(plotarea(sp))
         plot = mplot.subplots[i]
-        plot.plotbb = InspectDR.plotbounds(plot.layout, graphbb)
+        plot.plotbb = InspectDR.plotbounds(plot.layout.values, graphbb)
     end
 
     gplot = _inspectdr_getgui(plt.o)

src/backends/plotly.jl

@@ -435,6 +435,7 @@ function plotly_series(plt::Plot, series::Series)
     isscatter = st in (:scatter, :scatter3d, :scattergl)
     hasmarker = isscatter || series[:markershape] != :none
     hasline = st in (:path, :path3d)
+    hasfillrange = st in (:path, :scatter, :scattergl) && isa(series[:fillrange], AbstractVector)
 
     # for surface types, set the data
     if st in (:heatmap, :contour, :surface, :wireframe)
@@ -461,8 +462,11 @@ function plotly_series(plt::Plot, series::Series)
         if series[:fillrange] == true || series[:fillrange] == 0
             d_out[:fill] = "tozeroy"
             d_out[:fillcolor] = rgba_string(series[:fillcolor])
+        elseif isa(series[:fillrange], AbstractVector)
+            d_out[:fill] = "tonexty"
+            d_out[:fillcolor] = rgba_string(series[:fillcolor])
         elseif !(series[:fillrange] in (false, nothing))
-            warn("fillrange ignored... plotly only supports filling to zero. fillrange: $(series[:fillrange])")
+            warn("fillrange ignored... plotly only supports filling to zero and to a vector of values. fillrange: $(series[:fillrange])")
         end
         d_out[:x], d_out[:y] = x, y
 
@@ -479,6 +483,7 @@ function plotly_series(plt::Plot, series::Series)
         d_out[:type] = "heatmap"
         # d_out[:x], d_out[:y], d_out[:z] = series[:x], series[:y], transpose_z(series, series[:z].surf, false)
         d_out[:colorscale] = plotly_colorscale(series[:fillcolor], series[:fillalpha])
+        d_out[:showscale] = sp[:legend] != :none
 
     elseif st == :contour
         d_out[:type] = "contour"
@@ -487,6 +492,7 @@ function plotly_series(plt::Plot, series::Series)
         d_out[:ncontours] = series[:levels]
         d_out[:contours] = KW(:coloring => series[:fillrange] != nothing ? "fill" : "lines")
         d_out[:colorscale] = plotly_colorscale(series[:linecolor], series[:linealpha])
+        d_out[:showscale] = sp[:legend] != :none
 
     elseif st in (:surface, :wireframe)
         d_out[:type] = "surface"
@@ -499,11 +505,14 @@ function plotly_series(plt::Plot, series::Series)
                 :highlightwidth => series[:linewidth],
             )
             d_out[:contours] = KW(:x => wirelines, :y => wirelines, :z => wirelines)
+            d_out[:showscale] = false
         else
             d_out[:colorscale] = plotly_colorscale(series[:fillcolor], series[:fillalpha])
+            d_out[:opacity] = series[:fillalpha]
             if series[:fill_z] != nothing
                 d_out[:surfacecolor] = plotly_surface_data(series, series[:fill_z])
             end
+            d_out[:showscale] = sp[:legend] != :none
         end
 
     elseif st == :pie
@@ -572,7 +581,19 @@ function plotly_series(plt::Plot, series::Series)
     plotly_polar!(d_out, series)
     plotly_hover!(d_out, series[:hover])
 
-    [d_out]
+    if hasfillrange
+        # if hasfillrange is true, return two dictionaries (one for original
+        # series, one for series being filled to) instead of one
+        d_out_fillrange = copy(d_out)
+        d_out_fillrange[:y] = series[:fillrange]
+        d_out_fillrange[:showlegend] = false
+        delete!(d_out_fillrange, :fill)
+        delete!(d_out_fillrange, :fillcolor)
+
+        return [d_out_fillrange, d_out]
+    else
+        return [d_out]
+    end
 end
 
 function plotly_series_shapes(plt::Plot, series::Series)

src/backends/pyplot.jl

@@ -70,18 +70,26 @@ function _initialize_backend(::PyPlotBackend)
         append!(Base.Multimedia.displays, otherdisplays)
 
         export PyPlot
-        const pycolors = PyPlot.pywrap(PyPlot.pyimport("matplotlib.colors"))
-        const pypath = PyPlot.pywrap(PyPlot.pyimport("matplotlib.path"))
-        const mplot3d = PyPlot.pywrap(PyPlot.pyimport("mpl_toolkits.mplot3d"))
-        const pypatches = PyPlot.pywrap(PyPlot.pyimport("matplotlib.patches"))
-        const pyfont = PyPlot.pywrap(PyPlot.pyimport("matplotlib.font_manager"))
-        const pyticker = PyPlot.pywrap(PyPlot.pyimport("matplotlib.ticker"))
-        const pycmap = PyPlot.pywrap(PyPlot.pyimport("matplotlib.cm"))
-        const pynp = PyPlot.pywrap(PyPlot.pyimport("numpy"))
-        pynp.seterr(invalid="ignore")
-        const pytransforms = PyPlot.pywrap(PyPlot.pyimport("matplotlib.transforms"))
-        const pycollections = PyPlot.pywrap(PyPlot.pyimport("matplotlib.collections"))
-        const pyart3d = PyPlot.pywrap(PyPlot.pyimport("mpl_toolkits.mplot3d.art3d"))
+        const pycolors = PyPlot.pyimport("matplotlib.colors")
+        const pypath = PyPlot.pyimport("matplotlib.path")
+        const mplot3d = PyPlot.pyimport("mpl_toolkits.mplot3d")
+        const pypatches = PyPlot.pyimport("matplotlib.patches")
+        const pyfont = PyPlot.pyimport("matplotlib.font_manager")
+        const pyticker = PyPlot.pyimport("matplotlib.ticker")
+        const pycmap = PyPlot.pyimport("matplotlib.cm")
+        const pynp = PyPlot.pyimport("numpy")
+        pynp["seterr"](invalid="ignore")
+        const pytransforms = PyPlot.pyimport("matplotlib.transforms")
+        const pycollections = PyPlot.pyimport("matplotlib.collections")
+        const pyart3d = PyPlot.pyimport("mpl_toolkits.mplot3d.art3d")
+
+        # "support" matplotlib v1.5
+        const set_facecolor_sym = if PyPlot.version < v"2"
+            warn("You are using Matplotlib $(PyPlot.version), which is no longer officialy supported by the Plots community. To ensure smooth Plots.jl integration update your Matplotlib library to a version >= 2.0.0")
+            :set_axis_bgcolor
+        else
+            :set_facecolor
+        end
 
         # we don't want every command to update the figure
         PyPlot.ioff()
@@ -101,7 +109,7 @@ end
 
 # function py_colormap(c::ColorGradient, α=nothing)
 #     pyvals = [(v, py_color(getColorZ(c, v), α)) for v in c.values]
-#     pycolors.pymember("LinearSegmentedColormap")[:from_list]("tmp", pyvals)
+#     pycolors["LinearSegmentedColormap"][:from_list]("tmp", pyvals)
 # end
 
 # # convert vectors and ColorVectors to standard ColorGradients
@@ -118,7 +126,7 @@ py_color(grad::ColorGradient) = py_color(grad.colors)
 
 function py_colormap(grad::ColorGradient)
     pyvals = [(z, py_color(grad[z])) for z in grad.values]
-    cm = pycolors.LinearSegmentedColormap[:from_list]("tmp", pyvals)
+    cm = pycolors["LinearSegmentedColormap"][:from_list]("tmp", pyvals)
     cm[:set_bad](color=(0,0,0,0.0), alpha=0.0)
     cm
 end
@@ -127,7 +135,7 @@ py_colormap(c) = py_colormap(cgrad())
 
 function py_shading(c, z)
     cmap = py_colormap(c)
-    ls = pycolors.pymember("LightSource")(270,45)
+    ls = pycolors["LightSource"](270,45)
     ls[:shade](z, cmap, vert_exag=0.1, blend_mode="soft")
 end
 
@@ -151,7 +159,7 @@ function py_marker(marker::Shape)
         mat[i,2] = y[i]
     end
     mat[n+1,:] = mat[1,:]
-    pypath.pymember("Path")(mat)
+    pypath["Path"](mat)
 end
 
 const _path_MOVETO = UInt8(1)
@@ -177,7 +185,7 @@ const _path_CLOSEPOLY = UInt8(79)
 #         lastnan = nan
 #     end
 #     codes[n+1] = _path_CLOSEPOLY
-#     pypath.pymember("Path")(mat, codes)
+#     pypath["Path"](mat, codes)
 # end
 
 # get the marker shape
@@ -227,14 +235,14 @@ end
 
 # # untested... return a FontProperties object from a Plots.Font
 # function py_font(font::Font)
-#     pyfont.pymember("FontProperties")(
+#     pyfont["FontProperties"](
 #         family = font.family,
 #         size = font.size
 #     )
 # end
 
 function get_locator_and_formatter(vals::AVec)
-    pyticker.pymember("FixedLocator")(1:length(vals)), pyticker.pymember("FixedFormatter")(vals)
+    pyticker["FixedLocator"](1:length(vals)), pyticker["FixedFormatter"](vals)
 end
 
 function add_pyfixedformatter(cbar, vals::AVec)
@@ -256,9 +264,9 @@ function labelfunc(scale::Symbol, backend::PyPlotBackend)
 end
 
 function py_mask_nans(z)
-    # PyPlot.pywrap(pynp.ma[:masked_invalid](PyPlot.pywrap(z)))
-    PyCall.pycall(pynp.ma[:masked_invalid], Any, z)
-    # pynp.ma[:masked_where](pynp.isnan(z),z)
+    # pynp["ma"][:masked_invalid](z)))
+    PyCall.pycall(pynp["ma"][:masked_invalid], Any, z)
+    # pynp["ma"][:masked_where](pynp["isnan"](z),z)
 end
 
 # ---------------------------------------------------------------------------
@@ -489,7 +497,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                     extrakw = KW()
                     isfinite(clims[1]) && (extrakw[:vmin] = clims[1])
                     isfinite(clims[2]) && (extrakw[:vmax] = clims[2])
-                    kw[:norm] = pycolors.Normalize(; extrakw...)
+                    kw[:norm] = pycolors["Normalize"](; extrakw...)
                 end
                 lz = collect(series[:line_z])
                 handle = if is3d(st)
@@ -500,7 +508,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                     # for i=1:n
                     #     segments[i] = [(_cycle(x,i), _cycle(y,i), _cycle(z,i)), (_cycle(x,i+1), _cycle(y,i+1), _cycle(z,i+1))]
                     # end
-                    lc = pyart3d.Line3DCollection(segments; kw...)
+                    lc = pyart3d["Line3DCollection"](segments; kw...)
                     lc[:set_array](lz)
                     ax[:add_collection3d](lc, zs=z) #, zdir='y')
                     lc
@@ -512,7 +520,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
                     # for i=1:n
                     #     segments[i] = [(_cycle(x,i), _cycle(y,i)), (_cycle(x,i+1), _cycle(y,i+1))]
                     # end
-                    lc = pycollections.LineCollection(segments; kw...)
+                    lc = pycollections["LineCollection"](segments; kw...)
                     lc[:set_array](lz)
                     ax[:add_collection](lc)
                     lc
@@ -768,7 +776,7 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
     end
 
     if st == :heatmap
-        x, y, z = heatmap_edges(x), heatmap_edges(y), transpose_z(series, z.surf)
+        x, y, z = heatmap_edges(x, sp[:xaxis][:scale]), heatmap_edges(y, sp[:yaxis][:scale]), transpose_z(series, z.surf)
 
         expand_extrema!(sp[:xaxis], x)
         expand_extrema!(sp[:yaxis], y)
@@ -797,8 +805,8 @@ function py_add_series(plt::Plot{PyPlotBackend}, series::Series)
         handle = []
         for (i,rng) in enumerate(iter_segments(x, y))
             if length(rng) > 1
-                path = pypath.pymember("Path")(hcat(x[rng], y[rng]))
-                patches = pypatches.pymember("PathPatch")(
+                path = pypath["Path"](hcat(x[rng], y[rng]))
+                patches = pypatches["PathPatch"](
                     path;
                     label = series[:label],
                     zorder = series[:series_plotindex],
@@ -926,7 +934,7 @@ function py_compute_axis_minval(axis::Axis)
         for series in series_list(sp)
             v = series.d[axis[:letter]]
             if !isempty(v)
-                minval = NaNMath.min(minval, ignorenan_minimum(abs(v)))
+                minval = NaNMath.min(minval, ignorenan_minimum(abs.(v)))
             end
         end
     end
@@ -985,7 +993,7 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
     fig[:clear]()
     dpi = plt[:dpi]
     fig[:set_size_inches](w/dpi, h/dpi, forward = true)
-    fig[:set_facecolor](py_color(plt[:background_color_outside]))
+    fig[set_facecolor_sym](py_color(plt[:background_color_outside]))
     fig[:set_dpi](dpi)
 
     # resize the window
@@ -1074,7 +1082,7 @@ function _before_layout_calcs(plt::Plot{PyPlotBackend})
         py_add_legend(plt, sp, ax)
 
         # this sets the bg color inside the grid
-        ax[:set_facecolor](py_color(sp[:background_color_inside]))
+        ax[set_facecolor_sym](py_color(sp[:background_color_inside]))
     end
     py_drawfig(fig)
 end
@@ -1196,7 +1204,7 @@ function py_add_legend(plt::Plot, sp::Subplot, ax)
 
             # set some legend properties
             frame = leg[:get_frame]()
-            frame[:set_facecolor](py_color(sp[:background_color_legend]))
+            frame[set_facecolor_sym](py_color(sp[:background_color_legend]))
             frame[:set_edgecolor](fgcolor)
         end
     end
@@ -1220,7 +1228,8 @@ function _update_plot_object(plt::Plot{PyPlotBackend})
         if haskey(sp.attr, :cbar_ax)
             cbw = sp.attr[:cbar_width]
             # this is the bounding box of just the colors of the colorbar (not labels)
-            cb_bbox = BoundingBox(right(sp.bbox)-cbw+1mm, top(sp.bbox)+2mm, _cbar_width-1mm, height(sp.bbox)-4mm)
+            has_toplabel = sp[:zaxis][:extrema].emax >= 1e7
+            cb_bbox = BoundingBox(right(sp.bbox)-cbw+1mm, top(sp.bbox) +  (has_toplabel ? 4mm : 2mm), _cbar_width-1mm, height(sp.bbox) - (has_toplabel ? 6mm : 4mm))
             pcts = bbox_to_pcts(cb_bbox, figw, figh)
             sp.attr[:cbar_ax][:set_position](pcts)
         end

src/components.jl

@@ -297,12 +297,33 @@ function scalefontsize(k::Symbol, factor::Number)
     f.pointsize = round(Int, factor * f.pointsize)
     default(k, f)
 end
+
+"""
+    scalefontsizes(factor::Number)
+
+Scales all **current** font sizes by `factor`. For example `scalefontsizes(1.1)` increases all current font sizes by 10%. To reset to initial sizes, use `scalefontsizes()`
+"""
 function scalefontsizes(factor::Number)
     for k in (:titlefont, :guidefont, :tickfont, :legendfont)
         scalefontsize(k, factor)
     end
 end
 
+"""
+    scalefontsizes()
+
+Resets font sizes to initial default values.
+"""
+function scalefontsizes()
+  for k in (:titlefont, :guidefont, :tickfont, :legendfont)
+      f = default(k)
+      if k in keys(_initial_fontsizes)
+        factor = f.pointsize / _initial_fontsizes[k]
+        scalefontsize(k, 1.0/factor)
+      end
+  end
+end
+
 "Wrap a string with font info"
 immutable PlotText
   str::AbstractString

src/examples.jl

@@ -66,8 +66,8 @@ PlotExample("Global",
 PlotExample("Images",
     "Plot an image.  y-axis is set to flipped",
     [:(begin
-        import Images
-        img = Images.load(Pkg.dir("PlotReferenceImages","Plots","pyplot","0.7.0","ref1.png"))
+        import FileIO
+        img = FileIO.load(Pkg.dir("PlotReferenceImages","Plots","pyplot","0.7.0","ref1.png"))
         plot(img)
     end)]
 ),

src/output.jl

@@ -220,14 +220,10 @@ if is_installed("FileIO")
         FileIO.save(pngfn, s)
 
         # now write from the file
-        write(io, readall(open(pngfn)))
+        write(io, readstring(open(pngfn)))
     end
 end
 
-
-
-
-
 # function html_output_format(fmt)
 #     if fmt == "png"
 #         @eval function Base.show(io::IO, ::MIME"text/html", plt::Plot)
@@ -250,76 +246,75 @@ end
 
 const _ijulia_output = String["text/html"]
 
-function setup_ijulia()
-    # override IJulia inline display
-    if isijulia()
-        @eval begin
-            import IJulia
-            export set_ijulia_output
-            function set_ijulia_output(mimestr::AbstractString)
-                # info("Setting IJulia output format to $mimestr")
-                global _ijulia_output
-                _ijulia_output[1] = mimestr
-            end
-            function IJulia.display_dict(plt::Plot)
-                global _ijulia_output
-                Dict{String, String}(_ijulia_output[1] => sprint(show, _ijulia_output[1], plt))
-            end
+using Requires
+@require IJulia begin
+    if IJulia.inited
+        export set_ijulia_output
 
-            # default text/plain passes to html... handles Interact issues
-            function Base.show(io::IO, m::MIME"text/plain", plt::Plot)
-                show(io, MIME("text/html"), plt)
-            end
+        function set_ijulia_output(mimestr::AbstractString)
+            # info("Setting IJulia output format to $mimestr")
+            global _ijulia_output
+            _ijulia_output[1] = mimestr
         end
-        @eval set_ijulia_output("text/html")
+        function IJulia.display_dict(plt::Plot)
+            global _ijulia_output
+            Dict{String, String}(_ijulia_output[1] => sprint(show, _ijulia_output[1], plt))
+        end
+
+        # default text/plain passes to html... handles Interact issues
+        function Base.show(io::IO, m::MIME"text/plain", plt::Plot)
+            show(io, MIME("text/html"), plt)
+        end
+
+        set_ijulia_output("text/html")
     end
 end
 
 # ---------------------------------------------------------
 # Atom PlotPane
 # ---------------------------------------------------------
+@require Juno begin
+    import Hiccup, Media
 
-function setup_atom()
-    if isatom()
-        @eval import Atom, Media
+    if Juno.isactive()
         Media.media(Plot, Media.Plot)
 
-        # default text/plain so it doesn't complain
-        function Base.show{B}(io::IO, ::MIME"text/plain", plt::Plot{B})
-            print(io, "Plot{$B}()")
-        end
 
-        function Media.render(e::Atom.Editor, plt::Plot)
-            Media.render(e, nothing)
+        _show{B}(io::IO, m::MIME"text/plain", plt::Plot{B}) = print(io, "Plot{$B}()")
+
+        function Juno.render(e::Juno.Editor, plt::Plot)
+            Juno.render(e, nothing)
         end
 
         if get(ENV, "PLOTS_USE_ATOM_PLOTPANE", true) in (true, 1, "1", "true", "yes")
-            # this is like "display"... sends an html div with the plot to the PlotPane
-            function Media.render(pane::Atom.PlotPane, plt::Plot)
+            function Juno.render(pane::Juno.PlotPane, plt::Plot)
                 # temporarily overwrite size to be Atom.plotsize
                 sz = plt[:size]
-                plt[:size] = Juno.plotsize()
-                Media.render(pane, Atom.div(".fill", Atom.HTML(stringmime(MIME("text/html"), plt))))
+                jsize = Juno.plotsize()
+                jsize[1] == 0 && (jsize[1] = 400)
+                jsize[2] == 0 && (jsize[2] = 500)
+
+                plt[:size] = jsize
+                Juno.render(pane, HTML(stringmime(MIME("text/html"), plt)))
                 plt[:size] = sz
             end
             # special handling for PlotlyJS
-            function Media.render(pane::Atom.PlotPane, plt::Plot{PlotlyJSBackend})
+            function Juno.render(pane::Juno.PlotPane, plt::Plot{PlotlyJSBackend})
                 display(Plots.PlotsDisplay(), plt)
             end
         else
-            #
-            function Media.render(pane::Atom.PlotPane, plt::Plot)
+            function Juno.render(pane::Juno.PlotPane, plt::Plot)
                 display(Plots.PlotsDisplay(), plt)
                 s = "PlotPane turned off.  Unset ENV[\"PLOTS_USE_ATOM_PLOTPANE\"] and restart Julia to enable it."
-                Media.render(pane, Atom.div(Atom.HTML(s)))
+                Juno.render(pane, HTML(s))
             end
         end
 
         # special handling for plotly... use PlotsDisplay
-        function Media.render(pane::Atom.PlotPane, plt::Plot{PlotlyBackend})
+        function Juno.render(pane::Juno.PlotPane, plt::Plot{PlotlyBackend})
             display(Plots.PlotsDisplay(), plt)
             s = "PlotPane turned off.  The plotly backend cannot render in the PlotPane due to javascript issues. Plotlyjs is similar to plotly and is compatible with the plot pane."
-            Media.render(pane, Atom.div(Atom.HTML(s)))
+            Juno.render(pane, HTML(s))
         end
     end
 end

src/recipes.jl

@@ -703,7 +703,7 @@ end
 
 function error_coords(xorig, yorig, ebar)
     # init empty x/y, and zip errors if passed Tuple{Vector,Vector}
-    x, y = Array(float_extended_type(xorig), 0), Array(Float64, 0)
+    x, y = Array{float_extended_type(xorig)}(0), Array{Float64}(0)
     # for each point, create a line segment from the bottom to the top of the errorbar
     for i = 1:max(length(xorig), length(yorig))
         xi = _cycle(xorig, i)
@@ -970,11 +970,11 @@ abline!(args...; kw...) = abline!(current(), args...; kw...)
 # -------------------------------------------------
 # Dates
 
-dateformatter(dt) = string(convert(Date, dt))
-datetimeformatter(dt) = string(convert(DateTime, dt))
+dateformatter(dt) = string(Date(Dates.UTD(dt)))
+datetimeformatter(dt) = string(DateTime(Dates.UTM(dt)))
 
-@recipe f(::Type{Date}, dt::Date) = (dt -> convert(Int, dt), dateformatter)
-@recipe f(::Type{DateTime}, dt::DateTime) = (dt -> convert(Int, dt), datetimeformatter)
+@recipe f(::Type{Date}, dt::Date) = (dt -> Dates.value(dt), dateformatter)
+@recipe f(::Type{DateTime}, dt::DateTime) = (dt -> Dates.value(dt), datetimeformatter)
 
 # -------------------------------------------------
 # Complex Numbers

src/utils.jl

@@ -332,11 +332,24 @@ Base.first(x::Symbol) = x
 
 sortedkeys(d::Dict) = sort(collect(keys(d)))
 
+
+const _scale_base = Dict{Symbol, Real}(
+    :log10 => 10,
+    :log2 => 2,
+    :ln => e,
+)
+
 "create an (n+1) list of the outsides of heatmap rectangles"
-function heatmap_edges(v::AVec)
+function heatmap_edges(v::AVec, scale::Symbol = :identity)
   vmin, vmax = ignorenan_extrema(v)
-  extra = 0.5 * (vmax-vmin) / (length(v)-1)
-  vcat(vmin-extra, 0.5 * (v[1:end-1] + v[2:end]), vmax+extra)
+  extra_min = extra_max = 0.5 * (vmax-vmin) / (length(v)-1)
+  if scale in _logScales
+      vmin > 0 || error("The axis values must be positive for a $scale scale")
+      while vmin - extra_min <= 0
+          extra_min /= _scale_base[scale]
+      end
+  end
+  vcat(vmin-extra_min, 0.5 * (v[1:end-1] + v[2:end]), vmax+extra_max)
 end
 
 
@@ -480,7 +493,7 @@ function make_fillrange_from_ribbon(kw::KW)
     y, rib = kw[:y], kw[:ribbon]
     rib = wraptuple(rib)
     rib1, rib2 = -first(rib), last(rib)
-    kw[:ribbon] = nothing
+    # kw[:ribbon] = nothing
     kw[:fillrange] = make_fillrange_side(y, rib1), make_fillrange_side(y, rib2)
 end
 

test/REQUIRE

@@ -1,5 +1,4 @@
 StatPlots
-FactCheck
 Images
 ImageMagick
 @osx QuartzImageIO
@@ -7,4 +6,3 @@ GR
 RDatasets
 VisualRegressionTests
 UnicodePlots
-Glob

test/imgcomp.jl

@@ -15,8 +15,7 @@ end
 
 using Plots
 using StatPlots
-using FactCheck
-using Glob
+using Base.Test
 
 default(size=(500,300))
 
@@ -24,7 +23,7 @@ default(size=(500,300))
 # TODO: use julia's Condition type and the wait() and notify() functions to initialize a Window, then wait() on a condition that
 #       is referenced in a button press callback (the button clicked callback will call notify() on that condition)
 
-const _current_plots_version = v"0.12.0"
+const _current_plots_version = v"0.12.1"
 
 
 function image_comparison_tests(pkg::Symbol, idx::Int; debug = false, popup = isinteractive(), sigma = [1,1], eps = 1e-2)
@@ -43,11 +42,7 @@ function image_comparison_tests(pkg::Symbol, idx::Int; debug = false, popup = is
     fn = "ref$idx.png"
 
     # firgure out version info
-    G = glob(joinpath(relpath(refdir), "*"))
-    # @show refdir fn G
-    slash = (@static is_windows() ? "\\" : "/")
-    versions = map(fn -> VersionNumber(split(fn, slash)[end]), G)
-    versions = reverse(sort(versions))
+    versions = sort(VersionNumber.(readdir(refdir)), rev = true)
     versions = filter(v -> v <= _current_plots_version, versions)
     # @show refdir fn versions
 
@@ -99,7 +94,7 @@ function image_comparison_facts(pkg::Symbol;
   for i in 1:length(Plots._examples)
     i in skip && continue
     if only == nothing || i in only
-      @fact @eval(image_comparison_tests(Symbol(String(Symbol($pkg))[7:end]), $i, debug=$debug, sigma=$sigma, eps=$eps)) |> success --> true
+      @test image_comparison_tests(pkg, i, debug=debug, sigma=sigma, eps=eps) |> success == true
     end
   end
 end

test/install_wkhtmltoimage.sh

@@ -6,8 +6,8 @@ sudo apt-get -qq update
 # sudo apt-get install -y wkhtmltopdf
 
 sudo apt-get install -y xfonts-75dpi xfonts-base
-wget https://downloads.wkhtmltopdf.org/0.12/0.12.2/wkhtmltox-0.12.2_linux-precise-amd64.deb
-sudo dpkg -i wkhtmltox-0.12.2_linux-precise-amd64.deb
+wget https://github.com/wkhtmltopdf/wkhtmltopdf/releases/download/0.12.2.1/wkhtmltox-0.12.2.1_linux-precise-amd64.deb
+sudo dpkg -i wkhtmltox-0.12.2.1_linux-precise-amd64.deb
 # wget http://download.gna.org/wkhtmltopdf/0.12/0.12.2/wkhtmltox-0.12.2_linux-trusty-amd64.deb
 # sudo dpkg -i wkhtmltox-0.12.2_linux-trusty-amd64.deb
 wkhtmltoimage http://www.google.com test.png

test/runtests.jl

@@ -7,35 +7,35 @@ srand(1234)
 default(show=false, reuse=true)
 img_eps = isinteractive() ? 1e-2 : 10e-2
 
-facts("GR") do
-    @fact gr() --> Plots.GRBackend()
-    @fact backend() --> Plots.GRBackend()
+@testset "GR" begin
+    @test gr() == Plots.GRBackend()
+    @test backend() == Plots.GRBackend()
 
     image_comparison_facts(:gr, eps=img_eps)
 end
 
 
-facts("PyPlot") do
-    @fact pyplot() --> Plots.PyPlotBackend()
-    @fact backend() --> Plots.PyPlotBackend()
+@testset "PyPlot" begin
+    @test pyplot() == Plots.PyPlotBackend()
+    @test backend() == Plots.PyPlotBackend()
 
     image_comparison_facts(:pyplot, eps=img_eps)
 end
 
-facts("UnicodePlots") do
-    @fact unicodeplots() --> Plots.UnicodePlotsBackend()
-    @fact backend() --> Plots.UnicodePlotsBackend()
+@testset "UnicodePlots" begin
+    @test unicodeplots() == Plots.UnicodePlotsBackend()
+    @test backend() == Plots.UnicodePlotsBackend()
 
     # lets just make sure it runs without error
-    @fact isa(plot(rand(10)), Plots.Plot) --> true
+    @test isa(plot(rand(10)), Plots.Plot) == true
 end
 
 # The plotlyjs testimages return a connection error on travis:
 # connect: connection refused (ECONNREFUSED)
 
-# facts("PlotlyJS") do
-#     @fact plotlyjs() --> Plots.PlotlyJSBackend()
-#     @fact backend() --> Plots.PlotlyJSBackend()
+# @testset "PlotlyJS" begin
+#     @test plotlyjs() == Plots.PlotlyJSBackend()
+#     @test backend() == Plots.PlotlyJSBackend()
 #
 #     if is_linux() && isinteractive()
 #         image_comparison_facts(:plotlyjs,
@@ -53,9 +53,9 @@ end
 # ERROR: LoadError: InitError: Cannot open display:
 #  in Gtk.GLib.GError(::Gtk.##229#230) at /home/travis/.julia/v0.5/Gtk/src/GLib/gerror.jl:17
 
-# facts("InspectDR") do
-#     @fact inspectdr() --> Plots.InspectDRBackend()
-#     @fact backend() --> Plots.InspectDRBackend()
+# @testset "InspectDR" begin
+#     @test inspectdr() == Plots.InspectDRBackend()
+#     @test backend() == Plots.InspectDRBackend()
 #
 #     image_comparison_facts(:inspectdr,
 #         skip=[
@@ -72,41 +72,41 @@ end
 # end
 
 
-# facts("Plotly") do
-#     @fact plotly() --> Plots.PlotlyBackend()
-#     @fact backend() --> Plots.PlotlyBackend()
+# @testset "Plotly" begin
+#     @test plotly() == Plots.PlotlyBackend()
+#     @test backend() == Plots.PlotlyBackend()
 #
 #     # # until png generation is reliable on OSX, just test on linux
 #     # @static is_linux() && image_comparison_facts(:plotly, only=[1,3,4,7,8,9,10,11,12,14,15,20,22,23,27], eps=img_eps)
 # end
 
 
-# facts("Immerse") do
-#     @fact immerse() --> Plots.ImmerseBackend()
-#     @fact backend() --> Plots.ImmerseBackend()
+# @testset "Immerse" begin
+#     @test immerse() == Plots.ImmerseBackend()
+#     @test backend() == Plots.ImmerseBackend()
 #
 #     # as long as we can plot anything without error, it should be the same as Gadfly
 #     image_comparison_facts(:immerse, only=[1], eps=img_eps)
 # end
 
 
-# facts("PlotlyJS") do
-#     @fact plotlyjs() --> Plots.PlotlyJSBackend()
-#     @fact backend() --> Plots.PlotlyJSBackend()
+# @testset "PlotlyJS" begin
+#     @test plotlyjs() == Plots.PlotlyJSBackend()
+#     @test backend() == Plots.PlotlyJSBackend()
 #
 #     # as long as we can plot anything without error, it should be the same as Plotly
 #     image_comparison_facts(:plotlyjs, only=[1], eps=img_eps)
 # end
 
 
-# facts("Gadfly") do
-#     @fact gadfly() --> Plots.GadflyBackend()
-#     @fact backend() --> Plots.GadflyBackend()
+# @testset "Gadfly" begin
+#     @test gadfly() == Plots.GadflyBackend()
+#     @test backend() == Plots.GadflyBackend()
 #
-#     @fact typeof(plot(1:10)) --> Plots.Plot{Plots.GadflyBackend}
-#     @fact plot(Int[1,2,3], rand(3)) --> not(nothing)
-#     @fact plot(sort(rand(10)), rand(Int, 10, 3)) --> not(nothing)
-#     @fact plot!(rand(10,3), rand(10,3)) --> not(nothing)
+#     @test typeof(plot(1:10)) == Plots.Plot{Plots.GadflyBackend}
+#     @test plot(Int[1,2,3], rand(3)) == not(nothing)
+#     @test plot(sort(rand(10)), rand(Int, 10, 3)) == not(nothing)
+#     @test plot!(rand(10,3), rand(10,3)) == not(nothing)
 #
 #     image_comparison_facts(:gadfly, skip=[4,6,23,24,27], eps=img_eps)
 # end
@@ -114,24 +114,24 @@ end
 
 
 
-facts("Axes") do
+@testset "Axes" begin
     p = plot()
     axis = p.subplots[1][:xaxis]
-    @fact typeof(axis) --> Plots.Axis
-    @fact Plots.discrete_value!(axis, "HI") --> (0.5, 1)
-    @fact Plots.discrete_value!(axis, :yo) --> (1.5, 2)
-    @fact Plots.ignorenan_extrema(axis) --> (0.5,1.5)
-    @fact axis[:discrete_map] --> Dict{Any,Any}(:yo  => 2, "HI" => 1)
+    @test typeof(axis) == Plots.Axis
+    @test Plots.discrete_value!(axis, "HI") == (0.5, 1)
+    @test Plots.discrete_value!(axis, :yo) == (1.5, 2)
+    @test Plots.ignorenan_extrema(axis) == (0.5,1.5)
+    @test axis[:discrete_map] == Dict{Any,Any}(:yo  => 2, "HI" => 1)
 
     Plots.discrete_value!(axis, ["x$i" for i=1:5])
     Plots.discrete_value!(axis, ["x$i" for i=0:2])
-    @fact Plots.ignorenan_extrema(axis) --> (0.5, 7.5)
+    @test Plots.ignorenan_extrema(axis) == (0.5, 7.5)
 end
 
 
 # tests for preprocessing recipes
 
-# facts("recipes") do
+# @testset "recipes" begin
 
     # user recipe
 
@@ -168,6 +168,4 @@ end
 # end
 
 
-
-FactCheck.exitstatus()
 end # module