remove mkdir call in tests; closes #397

.travis.yml

@@ -4,11 +4,11 @@ os:
   - linux
   - osx
 julia:
-  # - release
+  - release
   - nightly
-# matrix:
-#   allow_failures:
-#     - julia: nightly
+matrix:
+  allow_failures:
+    - julia: nightly
 
 # # before install:
 # #   - if [[ "$TRAVIS_OS_NAME" == "osx" ]]; then brew update          ; fi

NEWS.md

@@ -3,46 +3,11 @@
 
 #### notes on release changes, ongoing development, and future planned work
 
-- All new development should target 0.9!
-- Minor version 0.8 is the last one to support Julia 0.4!!
-	- Critical bugfixes only
+- All new development should target 0.7!
 
 ---
 
-## 0.9 (current master/dev)
-
-#### 0.9.0
-
-- fixes to cycle
-- add back single function recipe: `plot!(cos)`
-- new axis formatter attribute... accepts functions to convert numbers to strings
-- fix for inset plots
-- GR:
-	- fillrange fix
-	- annotations fix
-	- force double buffering in display
-
----
-
-## 0.8
-
-#### 0.8.2 (backported bug fixes for julia 0.4)
-
-- plotly ticks fix
-- unicodeplots size fix
-- remove mkdir call in tests
-
-#### 0.8.1
-
-- manual drawing of axes/ticks/labels
-- get_ticks uses optimize_ticks and Showoff
-- changed PLOTS_DEFAULTS to be a global variable, not ENV key
-- parameterized Segments for pushing tuples
-- fix to axis extrema for Bool/nothing
-- GR:
-	- manually draw 2D axes... fixes several issues and missing features
-	- fontsize fix
-- PGFPlots: pass axis syle
+## 0.8 (current master/dev)
 
 #### 0.8.0
 

REQUIRE

@@ -1,4 +1,4 @@
-julia 0.5-
+julia 0.4
 
 RecipesBase
 PlotUtils

src/Plots.jl

@@ -3,7 +3,7 @@ __precompile__()
 
 module Plots
 
-# using Compat
+using Compat
 using Reexport
 # @reexport using Colors
 # using Requires
@@ -34,7 +34,6 @@ export
 
     plot,
     plot!,
-    update!,
 
     current,
     default,

src/animation.jl

@@ -1,12 +1,12 @@
 
 immutable Animation
-  dir::String
-  frames::Vector{String}
+  dir::Compat.ASCIIString
+  frames::Vector{Compat.ASCIIString}
 end
 
 function Animation()
-  tmpdir = convert(String, mktempdir())
-  Animation(tmpdir, String[])
+  tmpdir = convert(Compat.ASCIIString, mktempdir())
+  Animation(tmpdir, Compat.ASCIIString[])
 end
 
 function frame{P<:AbstractPlot}(anim::Animation, plt::P=current())
@@ -21,7 +21,7 @@ end
 
 "Wraps the location of an animated gif so that it can be displayed"
 immutable AnimatedGif
-  filename::String
+  filename::Compat.ASCIIString
 end
 
 function gif(anim::Animation, fn = (isijulia() ? "tmp.gif" : tempname()*".gif"); fps::Integer = 20)
@@ -55,7 +55,7 @@ end
 
 
 # write out html to view the gif... note the rand call which is a hack so the image doesn't get cached
-function Base.show(io::IO, ::MIME"text/html", agif::AnimatedGif)
+function Base.writemime(io::IO, ::MIME"text/html", agif::AnimatedGif)
     write(io, "<img src=\"$(relpath(agif.filename))?$(rand())>\" />")
 end
 

src/arg_desc.jl

@@ -100,7 +100,6 @@ const _arg_desc = KW(
 :scale     				  => "Symbol. Scale of the axis: `:none`, `:ln`, `:log2`, `:log10`",
 :rotation  				  => "Number. Degrees rotation of tick labels.",
 :flip      				  => "Bool.  Should we flip (reverse) the axis?",
-:formatter 				  => "Function, :scientific, or :auto. A method which converts a number to a string for tick labeling.",
 :tickfont  				  => "Font. Font of axis tick labels.",
 :guidefont 				  => "Font. Font of axis guide (label).",
 :foreground_color_axis    => "Color Type or `:match` (matches `:foreground_color_subplot`). Color of axis ticks.",

src/args.jl

@@ -39,7 +39,7 @@ const _allTypes = vcat([
     :contour, :pie, :shape, :image
 ], _3dTypes)
 
-const _typeAliases = Dict{Symbol,Symbol}(
+@compat const _typeAliases = Dict{Symbol,Symbol}(
     :n             => :none,
     :no            => :none,
     :l             => :line,
@@ -92,7 +92,7 @@ ispolar(series::Series) = ispolar(series.d[:subplot])
 # ------------------------------------------------------------
 
 const _allStyles = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
-const _styleAliases = Dict{Symbol,Symbol}(
+@compat const _styleAliases = Dict{Symbol,Symbol}(
     :a    => :auto,
     :s    => :solid,
     :d    => :dash,
@@ -101,7 +101,7 @@ const _styleAliases = Dict{Symbol,Symbol}(
 )
 
 const _allMarkers = vcat(:none, :auto, _shape_keys) #sort(collect(keys(_shapes))))
-const _markerAliases = Dict{Symbol,Symbol}(
+@compat const _markerAliases = Dict{Symbol,Symbol}(
     :n            => :none,
     :no           => :none,
     :a            => :auto,
@@ -143,7 +143,7 @@ const _markerAliases = Dict{Symbol,Symbol}(
 )
 
 const _allScales = [:identity, :ln, :log2, :log10, :asinh, :sqrt]
-const _scaleAliases = Dict{Symbol,Symbol}(
+@compat const _scaleAliases = Dict{Symbol,Symbol}(
     :none => :identity,
     :log  => :log10,
 )
@@ -265,7 +265,6 @@ const _axis_defaults = KW(
     :foreground_color_text   => :match,            # tick text color,
     :foreground_color_guide  => :match,            # guide text color,
     :discrete_values => [],
-    :formatter => :auto,
 )
 
 const _suppress_warnings = Set{Symbol}([
@@ -299,8 +298,7 @@ for letter in (:x,:y,:z)
                 :foreground_color_border,
                 :foreground_color_text,
                 :foreground_color_guide,
-                :discrete_values,
-                :formatter,
+                :discrete_values
             )
         _axis_defaults_byletter[Symbol(letter,k)] = :match
 

src/axes.jl

@@ -73,9 +73,6 @@ function process_axis_arg!(d::KW, arg, letter = "")
     elseif typeof(arg) <: Number
         d[Symbol(letter,:rotation)] = arg
 
-    elseif typeof(arg) <: Function
-        d[Symbol(letter,:formatter)] = arg
-
     else
         warn("Skipped $(letter)axis arg $arg")
 
@@ -132,12 +129,6 @@ const _inv_scale_funcs = Dict{Symbol,Function}(
     :ln => exp,
 )
 
-# const _label_func = Dict{Symbol,Function}(
-#     :log10 => x -> "10^$x",
-#     :log2 => x -> "2^$x",
-#     :ln => x -> "e^$x",
-# )
-
 const _label_func = Dict{Symbol,Function}(
     :log10 => x -> "10^$x",
     :log2 => x -> "2^$x",
@@ -150,44 +141,41 @@ invscalefunc(scale::Symbol) = x -> get(_inv_scale_funcs, scale, identity)(Float6
 labelfunc(scale::Symbol, backend::AbstractBackend) = get(_label_func, scale, string)
 
 function optimal_ticks_and_labels(axis::Axis, ticks = nothing)
-    amin,amax = axis_limits(axis)
+    lims = axis_limits(axis)
 
     # scale the limits
     scale = axis[:scale]
-    sf = scalefunc(scale)
+    scaled_lims = map(scalefunc(scale), lims)
+    # @show lims scaled_lims
 
     # get a list of well-laid-out ticks
-    scaled_ticks = if ticks == nothing
-        optimize_ticks(
-            sf(amin),
-            sf(amax);
+    cv = if ticks == nothing
+        optimize_ticks(scaled_lims...,
             k_min = 5, # minimum number of ticks
             k_max = 8, # maximum number of ticks
+            # span_buffer = 0.0 # padding buffer in case nice ticks are closeby
         )[1]
     else
-        map(sf, ticks)
+        ticks
     end
-    unscaled_ticks = map(invscalefunc(scale), scaled_ticks)
 
-    labels = if any(isfinite, unscaled_ticks)
-        formatter = axis[:formatter]
-        if formatter == :auto
-            # the default behavior is to make strings of the scaled values and then apply the labelfunc
-            map(labelfunc(scale, backend()), Showoff.showoff(scaled_ticks, :plain))
-        elseif formatter == :scientific
-            Showoff.showoff(unscaled_ticks, :scientific)
-        else
-            # there was an override for the formatter... use that on the unscaled ticks
-            map(formatter, unscaled_ticks)
-        end
+    # # expand to ensure we see all the ticks
+    # expand_extrema!(axis, cv)
+
+    # rescale and return values and labels
+    # @show cv
+    ticklabels = if any(isfinite, cv)
+        map(labelfunc(scale, backend()), Showoff.showoff(cv, :plain))
     else
-        # no finite ticks to show...
-        String[]
+        UTF8String[]
     end
 
-    # @show unscaled_ticks labels
-    # labels = Showoff.showoff(unscaled_ticks, scale == :log10 ? :scientific : :auto)
-    unscaled_ticks, labels
+    tickvals = map(invscalefunc(scale), cv)
+    # @show tickvals ticklabels
+    # ticklabels = Showoff.showoff(tickvals, scale == :log10 ? :scientific : :auto)
+    tickvals, ticklabels
+    # basestr = scale == :log10 ? "10^" : scale == :log2 ? "2^" : scale == :ln ? "e^" : ""
+    # tickvals, ["$basestr$cvi" for cvi in cv]
 end
 
 # return (continuous_values, discrete_values) for the ticks on this axis

src/backends/bokeh.jl

@@ -194,7 +194,7 @@ end
 
 # ----------------------------------------------------------------
 
-function Base.show(io::IO, ::MIME"image/png", plt::AbstractPlot{BokehBackend})
+function Base.writemime(io::IO, ::MIME"image/png", plt::AbstractPlot{BokehBackend})
   # TODO: write a png to io
   warn("mime png not implemented")
 end

src/backends/gadfly.jl

@@ -244,7 +244,7 @@ function addToGadflyLegend(plt::Plot, d::KW)
 
         # add the legend if needed
         if all(g -> !isa(g, Gadfly.Guide.ManualColorKey), gplt.guides)
-            unshift!(gplt.guides, Gadfly.Guide.manual_color_key("", AbstractString[], Color[]))
+            unshift!(gplt.guides, Gadfly.Guide.manual_color_key("", @compat(AbstractString)[], Color[]))
         end
 
         # now add the series to the legend
@@ -456,7 +456,7 @@ function updateGadflyAxisFlips(gplt, d::KW, xlims, ylims, xfunc, yfunc)
 end
 
 
-function findGuideAndSet(gplt, t::DataType, args...; kw...)
+function findGuideAndSet(gplt, t::DataType, args...; kw...) #s::@compat(AbstractString))
     for (i,guide) in enumerate(gplt.guides)
         if isa(guide, t)
             gplt.guides[i] = t(args...; kw...)
@@ -537,7 +537,7 @@ end
 # ----------------------------------------------------------------
 
 
-function createGadflyAnnotationObject(x, y, val::AbstractString)
+function createGadflyAnnotationObject(x, y, val::@compat(AbstractString))
     Gadfly.Guide.annotation(Compose.compose(
                               Compose.context(),
                               Compose.text(x, y, val)
@@ -558,7 +558,7 @@ function createGadflyAnnotationObject(x, y, txt::PlotText)
                             ))
 end
 
-function _add_annotations{X,Y,V}(plt::Plot{GadflyBackend}, anns::AVec{Tuple{X,Y,V}})
+function _add_annotations{X,Y,V}(plt::Plot{GadflyBackend}, anns::AVec{@compat(Tuple{X,Y,V})})
     for ann in anns
         push!(plt.o.guides, createGadflyAnnotationObject(ann...))
     end
@@ -677,7 +677,7 @@ setGadflyDisplaySize(plt::Plot) = setGadflyDisplaySize(plt.attr[:size]...)
 # -------------------------------------------------------------------------
 
 
-function doshow{P<:Union{GadflyBackend,ImmerseBackend}}(io::IO, func, plt::AbstractPlot{P})
+function dowritemime{P<:Union{GadflyBackend,ImmerseBackend}}(io::IO, func, plt::AbstractPlot{P})
     gplt = getGadflyContext(plt)
     setGadflyDisplaySize(plt)
     Gadfly.draw(func(io, Compose.default_graphic_width, Compose.default_graphic_height), gplt)
@@ -692,9 +692,9 @@ getGadflyWriteFunc(::MIME"application/x-tex") = Gadfly.PGF
 getGadflyWriteFunc(m::MIME) = error("Unsupported in Gadfly/Immerse: ", m)
 
 for mime in (MIME"image/png", MIME"image/svg+xml", MIME"application/pdf", MIME"application/postscript", MIME"application/x-tex")
-    @eval function Base.show{P<:Union{GadflyBackend,ImmerseBackend}}(io::IO, ::$mime, plt::AbstractPlot{P})
+    @eval function Base.writemime{P<:Union{GadflyBackend,ImmerseBackend}}(io::IO, ::$mime, plt::AbstractPlot{P})
         func = getGadflyWriteFunc($mime())
-        doshow(io, func, plt)
+        dowritemime(io, func, plt)
     end
 end
 

src/backends/glvisualize.jl

@@ -311,7 +311,7 @@ function _update_plot_object(plt::Plot{GLVisualizeBackend})
     gl_display(plt)
 end
 
-# function _show(io::IO, ::MIME"image/png", plt::AbstractPlot{GLVisualizeBackend})
+# function _writemime(io::IO, ::MIME"image/png", plt::AbstractPlot{GLVisualizeBackend})
 #     # TODO: write a png to io
 # end
 

src/backends/gr.jl

@@ -660,7 +660,6 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
 
         GR.savestate()
 
-
         # update the bounding window
         if ispolar(sp)
             gr_set_viewport_polar()
@@ -676,9 +675,14 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
 
         # recompute data
         if typeof(z) <: Surface
-            if st == :heatmap
+            if st == :heatmap #&& size(z.surf) == (length(y), length(x))
                 expand_extrema!(sp[:xaxis], (x[1]-0.5*(x[2]-x[1]), x[end]+0.5*(x[end]-x[end-1])))
                 expand_extrema!(sp[:yaxis], (y[1]-0.5*(y[2]-y[1]), y[end]+0.5*(y[end]-y[end-1])))
+            #     # coords are centers... turn into edges
+            #     xd = diff(x)
+            #     x = vcat(x[1]-0.5xd[1], x[1]+xd, x[end]+0.5xd[end])
+            #     yd = diff(y)
+            #     y = vcat(y[1]-0.5yd[1], y[1]+yd, y[end]+0.5yd[end])
             end
             z = vec(transpose_z(series, z.surf, false))
         elseif ispolar(sp)
@@ -690,19 +694,21 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
 
         if st in (:path, :scatter)
             if length(x) > 1
+
                 # do area fill
                 if frng != nothing
+                    gr_set_fillcolor(series[:fillcolor]) #, series[:fillalpha])
                     GR.setfillintstyle(GR.INTSTYLE_SOLID)
-                    fr_from, fr_to = (is_2tuple(frng) ? frng : (y, frng))
-                    for (i,rng) in enumerate(iter_segments(series[:x], series[:y]))
-                        if length(rng) > 1
-                            gr_set_fillcolor(cycle(series[:fillcolor], i))
-                            fx = cycle(x, vcat(rng, reverse(rng)))
-                            fy = vcat(cycle(fr_from,rng), cycle(fr_to,reverse(rng)))
-                            # @show i rng fx fy
-                            GR.fillarea(fx, fy)
-                        end
+                    frng = isa(frng, Number) ? Float64[frng] : frng
+                    nx, ny, nf = length(x), length(y), length(frng)
+                    n = max(nx, ny)
+                    fx, fy = zeros(2n), zeros(2n)
+                    for i=1:n
+                        fx[i] = fx[end-i+1] = cycle(x,i)
+                        fy[i] = cycle(y,i)
+                        fy[end-i+1] = cycle(frng,i)
                     end
+                    GR.fillarea(fx, fy)
                 end
 
                 # draw the line(s)
@@ -934,22 +940,9 @@ function gr_display(sp::Subplot{GRBackend}, w, h, viewport_canvas)
 
     # add annotations
     GR.savestate()
-    # update the bounding window
-    if ispolar(sp)
-        gr_set_viewport_polar()
-    else
-        xmin, xmax, ymin, ymax = data_lims
-        if xmax > xmin && ymax > ymin
-            GR.setwindow(xmin, xmax, ymin, ymax)
-        end
-    end
     for ann in sp[:annotations]
         x, y, val = ann
-        x, y = if is3d(sp)
-            # GR.wc3towc(x, y, z)
-        else
-            GR.wctondc(x, y)
-        end
+        x, y = GR.wctondc(x, y)
         gr_set_font(val.font)
         gr_text(x, y, val.str)
     end
@@ -968,7 +961,7 @@ const _gr_mimeformats = Dict(
 
 
 for (mime, fmt) in _gr_mimeformats
-    @eval function _show(io::IO, ::MIME{Symbol($mime)}, plt::Plot{GRBackend})
+    @eval function _writemime(io::IO, ::MIME{Symbol($mime)}, plt::Plot{GRBackend})
         GR.emergencyclosegks()
         wstype = haskey(ENV, "GKS_WSTYPE") ? ENV["GKS_WSTYPE"] : "0"
         filepath = tempname() * "." * $fmt
@@ -976,7 +969,7 @@ for (mime, fmt) in _gr_mimeformats
         ENV["GKS_FILEPATH"] = filepath
         gr_display(plt)
         GR.emergencyclosegks()
-        write(io, readstring(filepath))
+        write(io, readall(filepath))
         ENV["GKS_WSTYPE"] = wstype
         rm(filepath)
     end
@@ -994,7 +987,6 @@ function _display(plt::Plot{GRBackend})
         println(content)
         rm(filepath)
     else
-        ENV["GKS_DOUBLE_BUF"] = "true"
         gr_display(plt)
     end
 end

src/backends/immerse.jl

@@ -61,7 +61,7 @@ end
 
 # ----------------------------------------------------------------
 
-function _add_annotations{X,Y,V}(plt::Plot{ImmerseBackend}, anns::AVec{Tuple{X,Y,V}})
+function _add_annotations{X,Y,V}(plt::Plot{ImmerseBackend}, anns::AVec{@compat(Tuple{X,Y,V})})
   for ann in anns
     push!(getGadflyContext(plt).guides, createGadflyAnnotationObject(ann...))
   end

src/backends/pgfplots.jl

@@ -288,12 +288,12 @@ function _make_pgf_plot!(plt::Plot)
 end
 
 
-function _show(io::IO, mime::MIME"image/svg+xml", plt::Plot{PGFPlotsBackend})
+function _writemime(io::IO, mime::MIME"image/svg+xml", plt::Plot{PGFPlotsBackend})
     _make_pgf_plot!(plt)
-    show(io, mime, plt.o)
+    writemime(io, mime, plt.o)
 end
 
-function _show(io::IO, mime::MIME"application/pdf", plt::Plot{PGFPlotsBackend})
+function _writemime(io::IO, mime::MIME"application/pdf", plt::Plot{PGFPlotsBackend})
     _make_pgf_plot!(plt)
 
     # prepare the object

src/backends/plotly.jl

@@ -53,7 +53,7 @@ function _initialize_backend(::PlotlyBackend; kw...)
     JSON._print(io::IO, state::JSON.State, dt::Union{Date,DateTime}) = print(io, '"', dt, '"')
 
     _js_path = Pkg.dir("Plots", "deps", "plotly-latest.min.js")
-    _js_code = open(readstring, _js_path, "r")
+    _js_code = open(@compat(readstring), _js_path, "r")
 
     # borrowed from https://github.com/plotly/plotly.py/blob/2594076e29584ede2d09f2aa40a8a195b3f3fc66/plotly/offline/offline.py#L64-L71 c/o @spencerlyon2
     _js_script = """
@@ -567,11 +567,11 @@ end
 # ----------------------------------------------------------------
 
 
-function _show(io::IO, ::MIME"image/png", plt::Plot{PlotlyBackend})
-    show_png_from_html(io, plt)
+function _writemime(io::IO, ::MIME"image/png", plt::Plot{PlotlyBackend})
+    writemime_png_from_html(io, plt)
 end
 
-function _show(io::IO, ::MIME"image/svg+xml", plt::Plot{PlotlyBackend})
+function _writemime(io::IO, ::MIME"image/svg+xml", plt::Plot{PlotlyBackend})
     write(io, html_head(plt) * html_body(plt))
 end
 

src/backends/plotlyjs.jl

@@ -63,11 +63,11 @@ end
 
 # ----------------------------------------------------------------
 
-function _show(io::IO, ::MIME"image/svg+xml", plt::Plot{PlotlyJSBackend})
-    show(io, MIME("text/html"), plt.o)
+function _writemime(io::IO, ::MIME"image/svg+xml", plt::Plot{PlotlyJSBackend})
+    writemime(io, MIME("text/html"), plt.o)
 end
 
-function _show(io::IO, ::MIME"image/png", plt::Plot{PlotlyJSBackend})
+function _writemime(io::IO, ::MIME"image/png", plt::Plot{PlotlyJSBackend})
     tmpfn = tempname() * ".png"
     PlotlyJS.savefig(plt.o, tmpfn)
     write(io, read(open(tmpfn)))

src/backends/pyplot.jl

@@ -1184,14 +1184,14 @@ const _pyplot_mimeformats = Dict(
 
 
 for (mime, fmt) in _pyplot_mimeformats
-    @eval function _show(io::IO, ::MIME{Symbol($mime)}, plt::Plot{PyPlotBackend})
+    @eval function _writemime(io::IO, ::MIME{Symbol($mime)}, plt::Plot{PyPlotBackend})
         fig = plt.o
-        fig[:canvas][:print_figure](
+        fig.o[:canvas][:print_figure](
             io,
             format=$fmt,
             # bbox_inches = "tight",
             # figsize = map(px2inch, plt[:size]),
-            facecolor = fig[:get_facecolor](),
+            facecolor = fig.o[:get_facecolor](),
             edgecolor = "none",
             dpi = plt[:dpi]
         )

src/backends/qwt.jl

@@ -39,7 +39,7 @@ end
 
 # -------------------------------
 
-const _qwtAliases = KW(
+@compat const _qwtAliases = KW(
     :bins => :heatmap_n,
     :fillrange => :fillto,
     :linewidth => :width,
@@ -133,7 +133,7 @@ function updateLimsAndTicks(plt::Plot{QwtBackend}, d::KW, isx::Bool)
   w = plt.o.widget
   axisid = Qwt.QWT.QwtPlot[isx ? :xBottom : :yLeft]
 
-  if typeof(lims) <: Union{Tuple,AVec} && length(lims) == 2
+  if typeof(lims) <: @compat(Union{Tuple,AVec}) && length(lims) == 2
     if isx
       plt.o.autoscale_x = false
     else
@@ -211,14 +211,14 @@ function createQwtAnnotation(plt::Plot, x, y, val::PlotText)
   marker[:attach](plt.o.widget)
 end
 
-function createQwtAnnotation(plt::Plot, x, y, val::AbstractString)
+function createQwtAnnotation(plt::Plot, x, y, val::@compat(AbstractString))
   marker = Qwt.QWT.QwtPlotMarker()
   marker[:setValue](x, y)
   marker[:setLabel](Qwt.QWT.QwtText(val))
   marker[:attach](plt.o.widget)
 end
 
-function _add_annotations{X,Y,V}(plt::Plot{QwtBackend}, anns::AVec{Tuple{X,Y,V}})
+function _add_annotations{X,Y,V}(plt::Plot{QwtBackend}, anns::AVec{@compat(Tuple{X,Y,V})})
   for ann in anns
     createQwtAnnotation(plt, ann...)
   end
@@ -242,6 +242,8 @@ end
 
 # -------------------------------
 
+# savepng(::QwtBackend, plt::AbstractPlot, fn::@compat(AbstractString), args...) = Qwt.savepng(plt.o, fn)
+
 # -------------------------------
 
 # # create the underlying object (each backend will do this differently)
@@ -280,13 +282,13 @@ end
 
 # ----------------------------------------------------------------
 
-function Base.show(io::IO, ::MIME"image/png", plt::Plot{QwtBackend})
+function Base.writemime(io::IO, ::MIME"image/png", plt::Plot{QwtBackend})
   Qwt.refresh(plt.o)
   Qwt.savepng(plt.o, "/tmp/dfskjdhfkh.png")
   write(io, readall("/tmp/dfskjdhfkh.png"))
 end
 
-# function Base.show(io::IO, ::MIME"image/png", subplt::Subplot{QwtBackend})
+# function Base.writemime(io::IO, ::MIME"image/png", subplt::Subplot{QwtBackend})
 #   for plt in subplt.plts
 #     Qwt.refresh(plt.o)
 #   end

src/backends/template.jl

@@ -67,7 +67,7 @@ end
     # "image/png"               => "png",
     # "application/postscript"  => "ps",
     # "image/svg+xml"           => "svg"
-function _show(io::IO, ::MIME"image/png", plt::Plot{[PkgName]Backend})
+function _writemime(io::IO, ::MIME"image/png", plt::Plot{[PkgName]Backend})
 end
 
 # Display/show the plot (open a GUI window, or browser page, for example).

src/backends/unicodeplots.jl

@@ -112,7 +112,7 @@ end
 
 # -------------------------------
 
-# since this is such a hack, it's only callable using `png`... should error during normal `show`
+# since this is such a hack, it's only callable using `png`... should error during normal `writemime`
 function png(plt::AbstractPlot{UnicodePlotsBackend}, fn::AbstractString)
     fn = addExtension(fn, "png")
 
@@ -121,7 +121,7 @@ function png(plt::AbstractPlot{UnicodePlotsBackend}, fn::AbstractString)
     gui(plt)
 
     # @osx_only begin
-    @static if is_apple()
+    @compat @static if is_apple()
         # BEGIN HACK
 
         # wait while the plot gets drawn
@@ -148,7 +148,7 @@ function unicodeplots_rebuild(plt::Plot{UnicodePlotsBackend})
     rebuildUnicodePlot!(plt, div(w, 10), div(h, 20))
 end
 
-function _show(io::IO, ::MIME"text/plain", plt::Plot{UnicodePlotsBackend})
+function _writemime(io::IO, ::MIME"text/plain", plt::Plot{UnicodePlotsBackend})
     unicodeplots_rebuild(plt)
     map(show, plt.o)
     nothing

src/backends/web.jl

@@ -20,13 +20,13 @@ function standalone_html(plt::AbstractPlot; title::AbstractString = get(plt.attr
 end
 
 function open_browser_window(filename::AbstractString)
-    @static if is_apple()
+    @compat @static if is_apple()
         return run(`open $(filename)`)
     end
-    @static if is_linux()
+    @compat @static if is_linux()
         return run(`xdg-open $(filename)`)
     end
-    @static if is_windows()
+    @compat @static if is_windows()
         return run(`$(ENV["COMSPEC"]) /c start $(filename)`)
     end
     warn("Unknown OS... cannot open browser window.")
@@ -51,7 +51,7 @@ function html_to_png(html_fn, png_fn, w, h)
     run(`wkhtmltoimage -f png -q --width $w --height $h --disable-smart-width $html_fn $png_fn`)
 end
 
-function show_png_from_html(io::IO, plt::AbstractPlot)
+function writemime_png_from_html(io::IO, plt::AbstractPlot)
     # write html to a temporary file
     html_fn = write_temp_html(plt)
 

src/backends/winston.jl

@@ -44,13 +44,13 @@ end
 
 
 ## dictionaries for conversion of Plots.jl names to Winston ones.
-const winston_linestyle =  KW(:solid=>"solid",
+@compat const winston_linestyle =  KW(:solid=>"solid",
                                 :dash=>"dash",
                                 :dot=>"dotted",
                                 :dashdot=>"dotdashed"
                                )
 
-const winston_marker = KW(:none=>".",
+@compat const winston_marker = KW(:none=>".",
                             :rect => "square",
                             :circle=>"circle",
                             :diamond=>"diamond",
@@ -185,7 +185,7 @@ end
 
 # ----------------------------------------------------------------
 
-const _winstonNames = KW(
+@compat const _winstonNames = KW(
     :xlims => :xrange,
     :ylims => :yrange,
     :xscale => :xlog,
@@ -213,11 +213,11 @@ end
 
 # ----------------------------------------------------------------
 
-function createWinstonAnnotationObject(plt::Plot{WinstonBackend}, x, y, val::AbstractString)
+function createWinstonAnnotationObject(plt::Plot{WinstonBackend}, x, y, val::@compat(AbstractString))
   Winston.text(x, y, val)
 end
 
-function _add_annotations{X,Y,V}(plt::Plot{WinstonBackend}, anns::AVec{Tuple{X,Y,V}})
+function _add_annotations{X,Y,V}(plt::Plot{WinstonBackend}, anns::AVec{@compat(Tuple{X,Y,V})})
   for ann in anns
     createWinstonAnnotationObject(plt, ann...)
   end
@@ -238,10 +238,10 @@ function addWinstonLegend(plt::Plot, wplt)
   end
 end
 
-function Base.show(io::IO, ::MIME"image/png", plt::AbstractPlot{WinstonBackend})
+function Base.writemime(io::IO, ::MIME"image/png", plt::AbstractPlot{WinstonBackend})
   window, canvas, wplt = getWinstonItems(plt)
   addWinstonLegend(plt, wplt)
-  show(io, "image/png", wplt)
+  writemime(io, "image/png", wplt)
 end
 
 

src/components.jl

@@ -47,7 +47,7 @@ end
 
 "get an array of tuples of points on a circle with radius `r`"
 function partialcircle(start_θ, end_θ, n = 20, r=1)
-    Tuple{Float64,Float64}[(r*cos(u),r*sin(u)) for u in linspace(start_θ, end_θ, n)]
+  @compat(Tuple{Float64,Float64})[(r*cos(u),r*sin(u)) for u in linspace(start_θ, end_θ, n)]
 end
 
 "interleave 2 vectors into each other (like a zipper's teeth)"
@@ -472,7 +472,7 @@ type BezierCurve{T <: FixedSizeArrays.Vec}
   control_points::Vector{T}
 end
 
-function (bc::BezierCurve)(t::Real)
+@compat function (bc::BezierCurve)(t::Real)
   p = zero(P2)
   n = length(bc.control_points)-1
   for i in 0:n

src/layouts.jl

@@ -9,10 +9,10 @@ to_pixels(m::AbsoluteLength) = m.value / 0.254
 
 const _cbar_width = 5mm
 
-Base.:.*(m::Measure, n::Number) = m * n
-Base.:.*(n::Number, m::Measure) = m * n
-Base.:-(m::Measure, a::AbstractArray) = map(ai -> m - ai, a)
-Base.:-(a::AbstractArray, m::Measure) = map(ai -> ai - m, a)
+@compat Base.:.*(m::Measure, n::Number) = m * n
+@compat Base.:.*(n::Number, m::Measure) = m * n
+@compat Base.:-(m::Measure, a::AbstractArray) = map(ai -> m - ai, a)
+@compat Base.:-(a::AbstractArray, m::Measure) = map(ai -> ai - m, a)
 Base.zero(::Type{typeof(mm)}) = 0mm
 Base.one(::Type{typeof(mm)}) = 1mm
 Base.typemin(::typeof(mm)) = -Inf*mm
@@ -20,15 +20,15 @@ Base.typemax(::typeof(mm)) = Inf*mm
 Base.convert{F<:AbstractFloat}(::Type{F}, l::AbsoluteLength) = convert(F, l.value)
 
 # TODO: these are unintuitive and may cause tricky bugs
-# Base.:+(m1::AbsoluteLength, m2::Length{:pct}) = AbsoluteLength(m1.value * (1 + m2.value))
-# Base.:+(m1::Length{:pct}, m2::AbsoluteLength) = AbsoluteLength(m2.value * (1 + m1.value))
-# Base.:-(m1::AbsoluteLength, m2::Length{:pct}) = AbsoluteLength(m1.value * (1 - m2.value))
-# Base.:-(m1::Length{:pct}, m2::AbsoluteLength) = AbsoluteLength(m2.value * (m1.value - 1))
+# @compat Base.:+(m1::AbsoluteLength, m2::Length{:pct}) = AbsoluteLength(m1.value * (1 + m2.value))
+# @compat Base.:+(m1::Length{:pct}, m2::AbsoluteLength) = AbsoluteLength(m2.value * (1 + m1.value))
+# @compat Base.:-(m1::AbsoluteLength, m2::Length{:pct}) = AbsoluteLength(m1.value * (1 - m2.value))
+# @compat Base.:-(m1::Length{:pct}, m2::AbsoluteLength) = AbsoluteLength(m2.value * (m1.value - 1))
 
-Base.:*(m1::AbsoluteLength, m2::Length{:pct}) = AbsoluteLength(m1.value * m2.value)
-Base.:*(m1::Length{:pct}, m2::AbsoluteLength) = AbsoluteLength(m2.value * m1.value)
-Base.:/(m1::AbsoluteLength, m2::Length{:pct}) = AbsoluteLength(m1.value / m2.value)
-Base.:/(m1::Length{:pct}, m2::AbsoluteLength) = AbsoluteLength(m2.value / m1.value)
+@compat Base.:*(m1::AbsoluteLength, m2::Length{:pct}) = AbsoluteLength(m1.value * m2.value)
+@compat Base.:*(m1::Length{:pct}, m2::AbsoluteLength) = AbsoluteLength(m2.value * m1.value)
+@compat Base.:/(m1::AbsoluteLength, m2::Length{:pct}) = AbsoluteLength(m1.value / m2.value)
+@compat Base.:/(m1::Length{:pct}, m2::AbsoluteLength) = AbsoluteLength(m2.value / m1.value)
 
 
 Base.zero(::Type{typeof(pct)}) = 0pct
@@ -44,11 +44,11 @@ right(bbox::BoundingBox) = left(bbox) + width(bbox)
 bottom(bbox::BoundingBox) = top(bbox) + height(bbox)
 Base.size(bbox::BoundingBox) = (width(bbox), height(bbox))
 
-# Base.:*{T,N}(m1::Length{T,N}, m2::Length{T,N}) = Length{T,N}(m1.value * m2.value)
+# @compat Base.:*{T,N}(m1::Length{T,N}, m2::Length{T,N}) = Length{T,N}(m1.value * m2.value)
 ispositive(m::Measure) = m.value > 0
 
 # union together bounding boxes
-function Base.:+(bb1::BoundingBox, bb2::BoundingBox)
+@compat function Base.:+(bb1::BoundingBox, bb2::BoundingBox)
     # empty boxes don't change the union
     ispositive(width(bb1))  || return bb2
     ispositive(height(bb1)) || return bb2

src/output.jl

@@ -5,7 +5,7 @@ defaultOutputFormat(plt::Plot) = "png"
 function png(plt::Plot, fn::AbstractString)
   fn = addExtension(fn, "png")
   io = open(fn, "w")
-  show(io, MIME("image/png"), plt)
+  writemime(io, MIME("image/png"), plt)
   close(io)
 end
 png(fn::AbstractString) = png(current(), fn)
@@ -13,7 +13,7 @@ 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)
+  writemime(io, MIME("image/svg+xml"), plt)
   close(io)
 end
 svg(fn::AbstractString) = svg(current(), fn)
@@ -22,7 +22,7 @@ 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)
+  writemime(io, MIME("application/pdf"), plt)
   close(io)
 end
 pdf(fn::AbstractString) = pdf(current(), fn)
@@ -31,7 +31,7 @@ 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)
+  writemime(io, MIME("application/postscript"), plt)
   close(io)
 end
 ps(fn::AbstractString) = ps(current(), fn)
@@ -40,7 +40,7 @@ ps(fn::AbstractString) = ps(current(), fn)
 function tex(plt::Plot, fn::AbstractString)
   fn = addExtension(fn, "tex")
   io = open(fn, "w")
-  show(io, MIME("application/x-tex"), plt)
+  writemime(io, MIME("application/x-tex"), plt)
   close(io)
 end
 tex(fn::AbstractString) = tex(current(), fn)
@@ -49,7 +49,7 @@ tex(fn::AbstractString) = tex(current(), fn)
 # ----------------------------------------------------------------
 
 
-const _savemap = Dict(
+@compat const _savemap = Dict(
     "png" => png,
     "svg" => svg,
     "pdf" => pdf,
@@ -129,26 +129,26 @@ const _best_html_output_type = KW(
 )
 
 # a backup for html... passes to svg or png depending on the html_output_format arg
-function Base.show(io::IO, ::MIME"text/html", plt::Plot)
+function Base.writemime(io::IO, ::MIME"text/html", plt::Plot)
     output_type = Symbol(plt.attr[:html_output_format])
     if output_type == :auto
         output_type = get(_best_html_output_type, backend_name(plt.backend), :svg)
     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(writemime, MIME("image/png"), plt), "\" />")
     elseif output_type == :svg
         # info("writing svg to html output")
-        show(io, MIME("image/svg+xml"), plt)
+        writemime(io, MIME("image/svg+xml"), plt)
     elseif output_type == :txt
-        show(io, MIME("text/plain"), plt)
+        writemime(io, MIME("text/plain"), plt)
     else
         error("only png or svg allowed. got: $output_type")
     end
 end
 
-function _show(io::IO, m, plt::Plot)
-    warn("_show is not defined for this backend. m=", string(m))
+function _writemime(io::IO, m, plt::Plot)
+    warn("_writemime is not defined for this backend. m=", string(m))
 end
 function _display(plt::Plot)
     warn("_display is not defined for this backend.")
@@ -156,9 +156,9 @@ end
 
 # for writing to io streams... first prepare, then callback
 for mime in keys(_mimeformats)
-    @eval function Base.show(io::IO, m::MIME{Symbol($mime)}, plt::Plot)
+    @eval function Base.writemime(io::IO, m::MIME{Symbol($mime)}, plt::Plot)
         prepare_output(plt)
-        _show(io, m, plt)
+        _writemime(io, m, plt)
     end
 end
 
@@ -168,7 +168,7 @@ end
 
 if is_installed("FileIO")
     @eval import FileIO
-    function _show(io::IO, ::MIME"image/png", plt::Plot)
+    function _writemime(io::IO, ::MIME"image/png", plt::Plot)
         fn = tempname()
 
         # first save a pdf file
@@ -192,12 +192,12 @@ end
 
 # function html_output_format(fmt)
 #     if fmt == "png"
-#         @eval function Base.show(io::IO, ::MIME"text/html", plt::Plot)
-#             print(io, "<img src=\"data:image/png;base64,", base64(show, MIME("image/png"), plt), "\" />")
+#         @eval function Base.writemime(io::IO, ::MIME"text/html", plt::Plot)
+#             print(io, "<img src=\"data:image/png;base64,", base64(writemime, MIME("image/png"), plt), "\" />")
 #         end
 #     elseif fmt == "svg"
-#         @eval function Base.show(io::IO, ::MIME"text/html", plt::Plot)
-#             show(io, MIME("image/svg+xml"), plt)
+#         @eval function Base.writemime(io::IO, ::MIME"text/html", plt::Plot)
+#             writemime(io, MIME("image/svg+xml"), plt)
 #         end
 #     else
 #         error("only png or svg allowed. got: $fmt")
@@ -210,7 +210,7 @@ end
 # IJulia
 # ---------------------------------------------------------
 
-const _ijulia_output = String["text/html"]
+const _ijulia_output = Compat.ASCIIString["text/html"]
 
 function setup_ijulia()
     # override IJulia inline display
@@ -225,12 +225,12 @@ function setup_ijulia()
             end
             function IJulia.display_dict(plt::Plot)
                 global _ijulia_output
-                Dict{String, String}(_ijulia_output[1] => sprint(show, _ijulia_output[1], plt))
+                Dict{Compat.ASCIIString, ByteString}(_ijulia_output[1] => sprint(writemime, _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)
+            function Base.writemime(io::IO, m::MIME"text/plain", plt::Plot)
+                writemime(io, MIME("text/html"), plt)
             end
         end
         set_ijulia_output("text/html")
@@ -264,8 +264,8 @@ function setup_atom()
         end
 
         # # force text/plain to output to the PlotPane
-        # function Base.show(io::IO, ::MIME"text/plain", plt::Plot)
-        #     # show(io::IO, MIME("text/html"), plt)
+        # function Base.writemime(io::IO, ::MIME"text/plain", plt::Plot)
+        #     # writemime(io::IO, MIME("text/html"), plt)
         #     Atom.Media.render(pane)
         # end
 

src/pipeline.jl

@@ -13,7 +13,7 @@ function _expand_seriestype_array(d::KW, args)
         delete!(d, :seriestype)
         RecipeData[begin
             dc = copy(d)
-            dc[:seriestype] = sts[r:r,:]
+            dc[:seriestype] = sts[r,:]
             RecipeData(dc, args)
         end for r=1:size(sts,1)]
     else
@@ -248,7 +248,6 @@ function _plot_setup(plt::Plot, d::KW, kw_list::Vector{KW})
             push!(plt.inset_subplots, sp)
         end
     end
-    plt[:inset_subplots] = nothing
 end
 
 function _subplot_setup(plt::Plot, d::KW, kw_list::Vector{KW})

src/plot.jl

@@ -148,7 +148,7 @@ end
 # a list of series KW dicts.
 # note: at entry, we only have those preprocessed args which were passed in... no default values yet
 function _plot!(plt::Plot, d::KW, args::Tuple)
-    d[:plot_object] = plt
+    # d[:plot_object] = plt
 
     # --------------------------------
     # "USER RECIPES"
@@ -156,9 +156,6 @@ function _plot!(plt::Plot, d::KW, args::Tuple)
 
     kw_list = _process_userrecipes(plt, d, args)
 
-    # info(1)
-    # map(DD, kw_list)
-
 
     # --------------------------------
     # "PLOT RECIPES"
@@ -175,9 +172,6 @@ function _plot!(plt::Plot, d::KW, args::Tuple)
         _process_plotrecipe(plt, next_kw, kw_list, still_to_process)
     end
 
-    # info(2)
-    # map(DD, kw_list)
-
     # --------------------------------
     # Plot/Subplot/Layout setup
     # --------------------------------
@@ -190,9 +184,6 @@ function _plot!(plt::Plot, d::KW, args::Tuple)
     # --------------------------------
     # "SERIES RECIPES"
     # --------------------------------
-
-    # info(3)
-    # map(DD, kw_list)
     
     for kw in kw_list
         sp::Subplot = kw[:subplot]

src/precompile.jl

@@ -9,7 +9,7 @@ function _precompile_()
     precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Base.LinSpace{Float64},))
     precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, DataFrames.DataFrame,))
     precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Array{Int64, 1},))
-    precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Array{Union{String, ASCIIString}, 1},))
+    precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Array{Union{UTF8String, ASCIIString}, 1},))
     precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Array{Function, 1},))
     precompile(Plots._plot!, (Plots.Plot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Array{ASCIIString, 1},))
     precompile(Plots._plot!, (Plots.Plot{Plots.UnicodePlotsBackend}, Base.Dict{Symbol, Any},))
@@ -81,13 +81,13 @@ function _precompile_()
     precompile(Plots._update_subplot_args, (Array{Any, 1}, Plots.Plot{Plots.UnicodePlotsBackend}, Plots.Subplot{Plots.UnicodePlotsBackend}, Base.Dict{Symbol, Any}, Int64,))
     precompile(Plots.call, (Array{Any, 1}, Type{Plots.Subplot}, Plots.PyPlotBackend,))
     precompile(Plots._update_subplot_args, (Array{Any, 1}, Plots.Plot{Plots.PyPlotBackend}, Plots.Subplot{Plots.PyPlotBackend}, Base.Dict{Symbol, Any}, Int64,))
-    precompile(Plots.extractGroupArgs, (Array{Union{String, ASCIIString}, 1},))
+    precompile(Plots.extractGroupArgs, (Array{Union{UTF8String, ASCIIString}, 1},))
     precompile(Plots.bbox_to_pcts, (Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}}, Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}, Bool,))
     precompile(Plots.plot, (Array{Any, 1}, Array{Float64, 1},))
     precompile(Plots.py_marker, (Plots.Shape,))
     precompile(Plots.getindex, (Plots.Subplot{Plots.UnicodePlotsBackend}, Symbol,))
     precompile(Plots.getindex, (Plots.Subplot{Plots.PyPlotBackend}, Symbol,))
-    precompile(Plots.discrete_value!, (Plots.Axis, Array{Union{String, ASCIIString}, 1},))
+    precompile(Plots.discrete_value!, (Plots.Axis, Array{Union{UTF8String, ASCIIString}, 1},))
     precompile(Plots.prepare_output, (Plots.Plot{Plots.PyPlotBackend},))
     precompile(Plots.update_inset_bboxes!, (Plots.Plot{Plots.PyPlotBackend},))
     precompile(Plots.add_layout_pct!, (Base.Dict{Symbol, Any}, Expr, Int64, Int64,))
@@ -121,11 +121,11 @@ function _precompile_()
     precompile(Plots.plot!, (Array{Any, 1}, Plots.Plot{Plots.PyPlotBackend}, Base.LinSpace{Float64},))
     precompile(Plots.plot!, (Array{Any, 1}, Base.LinSpace{Float64}, Array{Float64, 1},))
     precompile(Plots.get_zvalues, (Int64,))
-    precompile(Plots.plot, (Array{Any, 1}, Array{Union{String, ASCIIString}, 1}, Array{Union{String, ASCIIString}, 1},))
+    precompile(Plots.plot, (Array{Any, 1}, Array{Union{UTF8String, ASCIIString}, 1}, Array{Union{UTF8String, ASCIIString}, 1},))
     precompile(Plots.histogram, (Array{Any, 1}, Array{Float64, 1},))
     precompile(Plots.hline!, (Array{Any, 1}, Array{Float64, 2},))
     precompile(Plots.layout_args, (Base.Dict{Symbol, Any}, Int64,))
-    precompile(Plots.heatmap, (Array{Any, 1}, Array{Union{String, ASCIIString}, 1},))
+    precompile(Plots.heatmap, (Array{Any, 1}, Array{Union{UTF8String, ASCIIString}, 1},))
     precompile(Plots._replace_linewidth, (Base.Dict{Symbol, Any},))
     precompile(Plots.plot!, (Array{Any, 1}, Array{Float64, 1}, Array{Float64, 1},))
     precompile(Plots.plot!, (Array{Any, 1}, Plots.Plot{Plots.PyPlotBackend}, Array{Float64, 2},))
@@ -156,7 +156,7 @@ function _precompile_()
     precompile(Plots.call, (Type{Plots.Plot},))
     precompile(Plots.call, (Type{Plots.ColorGradient}, Array{ColorTypes.RGBA{Float64}, 1},))
     precompile(Plots.plot!, (Array{Any, 1}, Array{Int64, 1},))
-    precompile(Plots.getExtension, (String,))
+    precompile(Plots.getExtension, (UTF8String,))
     precompile(Plots.call, (Array{Any, 1}, Type{Plots.EmptyLayout},))
     precompile(Plots.update!, (Array{Any, 1}, Plots.Axis,))
     precompile(Plots.frame, (Plots.Animation, Plots.Plot{Plots.PyPlotBackend},))
@@ -250,7 +250,7 @@ function _precompile_()
     precompile(Plots.allShapes, (Plots.Stroke,))
     precompile(Plots.replaceAliases!, (Base.Dict{Symbol, Any}, Base.Dict{Symbol, Any},))
     precompile(Plots._create_backend_figure, (Plots.Plot{Plots.PyPlotBackend},))
-    precompile(Plots.png, (Plots.Plot{Plots.PyPlotBackend}, String,))
+    precompile(Plots.png, (Plots.Plot{Plots.PyPlotBackend}, UTF8String,))
     precompile(Plots.processFillArg, (Base.Dict{Symbol, Any}, Symbol,))
     precompile(Plots.allShapes, (Plots.Shape,))
     precompile(Plots.handleColors!, (Base.Dict{Symbol, Any}, Plots.Stroke, Symbol,))
@@ -300,7 +300,7 @@ function _precompile_()
     precompile(Plots.plotarea!, (Plots.Subplot{Plots.PyPlotBackend}, Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}},))
     precompile(Plots.like_surface, (Symbol,))
     precompile(Plots.build_layout, (Base.Dict{Symbol, Any},))
-    precompile(Plots.compute_xyz, (Array{Union{String, ASCIIString}, 1}, Array{Union{String, ASCIIString}, 1}, Plots.Surface{Array{Float64, 2}},))
+    precompile(Plots.compute_xyz, (Array{Union{UTF8String, ASCIIString}, 1}, Array{Union{UTF8String, ASCIIString}, 1}, Plots.Surface{Array{Float64, 2}},))
     precompile(Plots.py_linestyle, (Symbol, Symbol,))
     precompile(Plots.plot!, (Array{Float64, 2},))
     precompile(Plots.plot!, (Plots.Plot{Plots.PyPlotBackend}, Array{Float64, 2},))
@@ -309,7 +309,7 @@ function _precompile_()
     precompile(Plots.yaxis!, (ASCIIString, Symbol,))
     precompile(Plots.compute_xyz, (Base.LinSpace{Float64}, Array{Float64, 1}, Void,))
     precompile(Plots.isijulia, ())
-    precompile(Plots.addExtension, (String, ASCIIString,))
+    precompile(Plots.addExtension, (UTF8String, ASCIIString,))
     precompile(Plots.call, (Type{Plots.ColorGradient}, Array{ColorTypes.RGBA{Float64}, 1}, Array{Float64, 1},))
     precompile(Plots.expand_extrema!, (Plots.Subplot{Plots.PyPlotBackend}, Float64, Float64, Float64, Float64,))
     precompile(Plots.plotarea!, (Plots.GridLayout, Measures.BoundingBox{Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}, Tuple{Measures.Length{:mm, Float64}, Measures.Length{:mm, Float64}}},))

src/recipes.jl

@@ -202,7 +202,6 @@ end
 
 function make_steps(x, y, st)
     n = length(x)
-    n == 0 && return zeros(0),zeros(0)
     newx, newy = zeros(2n-1), zeros(2n-1)
     for i=1:n
         idx = 2i-1

src/series.jl

@@ -6,12 +6,12 @@
 # This should cut down on boilerplate code and allow more focused dispatch on type
 # note: returns meta information... mainly for use with automatic labeling from DataFrames for now
 
-typealias FuncOrFuncs Union{Function, AVec{Function}}
+typealias FuncOrFuncs @compat(Union{Function, AVec{Function}})
 
 all3D(d::KW) = trueOrAllTrue(st -> st in (:contour, :contourf, :heatmap, :surface, :wireframe, :contour3d, :image), get(d, :seriestype, :none))
 
 # missing
-convertToAnyVector(v::Void, d::KW) = Any[nothing], nothing
+convertToAnyVector(v::@compat(Void), d::KW) = Any[nothing], nothing
 
 # fixed number of blank series
 convertToAnyVector(n::Integer, d::KW) = Any[zeros(0) for i in 1:n], nothing
@@ -20,7 +20,7 @@ convertToAnyVector(n::Integer, d::KW) = Any[zeros(0) for i in 1:n], nothing
 convertToAnyVector{T<:Number}(v::AVec{T}, d::KW) = Any[v], nothing
 
 # string vector
-convertToAnyVector{T<:AbstractString}(v::AVec{T}, d::KW) = Any[v], nothing
+convertToAnyVector{T<:@compat(AbstractString)}(v::AVec{T}, d::KW) = Any[v], nothing
 
 function convertToAnyVector(v::AMat, d::KW)
     if all3D(d)
@@ -210,7 +210,7 @@ end
 # # 1 argument
 # # --------------------------------------------------------------------
 
-@recipe f(n::Integer) = is3d(get(d,:seriestype,:path)) ? (SliceIt, n, n, n) : (SliceIt, n, n, nothing)
+@recipe f(n::Integer) = n, n, n
 
 # return a surface if this is a 3d plot, otherwise let it be sliced up
 @recipe function f{T<:Number}(mat::AMat{T})
@@ -273,15 +273,14 @@ end
     end
 end
 
+#
+#
+# # function without range... use the current range of the x-axis
 
-
-# function without range... use the current range of the x-axis
-
-@recipe function f(f::FuncOrFuncs)
-    plt = d[:plot_object]
-    xmin,xmax = axis_limits(plt[1][:xaxis])
-    f, xmin, xmax
-end
+# @recipe function f(f::FuncOrFuncs)
+#     plt = d[:plot_object]
+#     f, xmin(plt), xmax(plt)
+# end
 
 #
 # # --------------------------------------------------------------------

src/utils.jl

@@ -243,17 +243,16 @@ Base.cycle(v, idx::Int)       = v
 
 Base.cycle(v::AVec, indices::AVec{Int}) = map(i -> cycle(v,i), indices)
 Base.cycle(v::AMat, indices::AVec{Int}) = map(i -> cycle(v,i), indices)
-Base.cycle(v, indices::AVec{Int})       = fill(v, length(indices))
+Base.cycle(v, idx::AVec{Int})       = v
 
 Base.cycle(grad::ColorGradient, idx::Int) = cycle(grad.colors, idx)
-Base.cycle(grad::ColorGradient, indices::AVec{Int}) = cycle(grad.colors, indices)
 
 makevec(v::AVec) = v
 makevec{T}(v::T) = T[v]
 
 "duplicate a single value, or pass the 2-tuple through"
 maketuple(x::Real)                     = (x,x)
-maketuple{T,S}(x::Tuple{T,S}) = x
+maketuple{T,S}(x::@compat(Tuple{T,S})) = x
 
 mapFuncOrFuncs(f::Function, u::AVec)        = map(f, u)
 mapFuncOrFuncs(fs::AVec{Function}, u::AVec) = [map(f, u) for f in fs]
@@ -387,12 +386,13 @@ isvertical(d::KW) = get(d, :orientation, :vertical) in (:vertical, :v, :vert)
 isvertical(series::Series) = isvertical(series.d)
 
 
+# ticksType{T<:Real,S<:Real}(ticks::@compat(Tuple{T,S})) = :limits
 ticksType{T<:Real}(ticks::AVec{T})                      = :ticks
 ticksType{T<:AbstractString}(ticks::AVec{T})            = :labels
-ticksType{T<:AVec,S<:AVec}(ticks::Tuple{T,S})  = :ticks_and_labels
+ticksType{T<:AVec,S<:AVec}(ticks::@compat(Tuple{T,S}))  = :ticks_and_labels
 ticksType(ticks)                                        = :invalid
 
-limsType{T<:Real,S<:Real}(lims::Tuple{T,S})    = :limits
+limsType{T<:Real,S<:Real}(lims::@compat(Tuple{T,S}))    = :limits
 limsType(lims::Symbol)                                  = lims == :auto ? :auto : :invalid
 limsType(lims)                                          = :invalid
 
@@ -476,7 +476,7 @@ end
 
 # ---------------------------------------------------------------
 
-wraptuple(x::Tuple) = x
+wraptuple(x::@compat(Tuple)) = x
 wraptuple(x) = (x,)
 
 trueOrAllTrue(f::Function, x::AbstractArray) = all(f, x)
@@ -667,64 +667,6 @@ end
 Base.setindex!{X,Y}(plt::Plot, xy::Tuple{X,Y}, i::Integer) = setxy!(plt, xy, i)
 Base.setindex!{X,Y,Z}(plt::Plot, xyz::Tuple{X,Y,Z}, i::Integer) = setxyz!(plt, xyz, i)
 
-# -------------------------------------------------------
-
-# operate on individual series
-
-function push_x!(series::Series, xi)
-    push!(series[:x], xi)
-    expand_extrema!(series[:subplot][:xaxis], xi)
-    return
-end
-function push_y!(series::Series, yi)
-    push!(series[:y], yi)
-    expand_extrema!(series[:subplot][:yaxis], yi)
-    return
-end
-function push_z!(series::Series, zi)
-    push!(series[:z], zi)
-    expand_extrema!(series[:subplot][:zaxis], zi)
-    return
-end
-
-function Base.push!(series::Series, yi)
-    x = extendSeriesByOne(series[:x])
-    expand_extrema!(series[:subplot][:xaxis], x[end])
-    series[:x] = x
-    push_y!(series, yi)
-end
-Base.push!(series::Series, xi, yi) = (push_x!(series,xi); push_y!(series,yi))
-Base.push!(series::Series, xi, yi, zi) = (push_x!(series,xi); push_y!(series,yi); push_z!(series,zi))
-
-# -------------------------------------------------------
-
-function update!(series::Series; kw...)
-    d = KW(kw)
-    preprocessArgs!(d)
-    for (k,v) in d
-        if haskey(_series_defaults, k)
-            series[k] = v
-        else
-            warn("unused key $k in series update")
-        end
-    end
-    _series_updated(series[:subplot].plt, series)
-    series
-end
-
-function update!(sp::Subplot; kw...)
-    d = KW(kw)
-    preprocessArgs!(d)
-    for (k,v) in d
-        if haskey(_subplot_defaults, k)
-            sp[k] = v
-        else
-            warn("unused key $k in subplot update")
-        end
-    end
-    sp
-end
-
 # -------------------------------------------------------
 # push/append for one series
 

test/REQUIRE

@@ -1,9 +1,17 @@
+julia 0.4
+
+RecipesBase
+PlotUtils
 StatPlots
+Reexport
+Measures
+Showoff
 FactCheck
 Images
 ImageMagick
 @osx QuartzImageIO
 GR
+DataFrames
 RDatasets
 VisualRegressionTests
 UnicodePlots

test/imgcomp.jl

@@ -24,7 +24,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.9.0"
+const _current_plots_version = v"0.8.1"
 
 
 function image_comparison_tests(pkg::Symbol, idx::Int; debug = false, popup = isinteractive(), sigma = [1,1], eps = 1e-2)