removed compat; added series update methods

src/Plots.jl

@@ -3,7 +3,7 @@ __precompile__()
 
 module Plots
 
-using Compat
+# using Compat
 using Reexport
 # @reexport using Colors
 # using Requires

src/animation.jl

@@ -1,12 +1,12 @@
 
 immutable Animation
-  dir::Compat.ASCIIString
+  dir::String
-  frames::Vector{Compat.ASCIIString}
+  frames::Vector{String}
 end
 
 function Animation()
-  tmpdir = convert(Compat.ASCIIString, mktempdir())
+  tmpdir = convert(String, mktempdir())
-  Animation(tmpdir, Compat.ASCIIString[])
+  Animation(tmpdir, String[])
 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::Compat.ASCIIString
+  filename::String
 end
 
 function gif(anim::Animation, fn = (isijulia() ? "tmp.gif" : tempname()*".gif"); fps::Integer = 20)

src/args.jl

@@ -39,7 +39,7 @@ const _allTypes = vcat([
     :contour, :pie, :shape, :image
 ], _3dTypes)
 
-@compat const _typeAliases = Dict{Symbol,Symbol}(
+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]
-@compat const _styleAliases = Dict{Symbol,Symbol}(
+const _styleAliases = Dict{Symbol,Symbol}(
     :a    => :auto,
     :s    => :solid,
     :d    => :dash,
@@ -101,7 +101,7 @@ const _allStyles = [:auto, :solid, :dash, :dot, :dashdot, :dashdotdot]
 )
 
 const _allMarkers = vcat(:none, :auto, _shape_keys) #sort(collect(keys(_shapes))))
-@compat const _markerAliases = Dict{Symbol,Symbol}(
+const _markerAliases = Dict{Symbol,Symbol}(
     :n            => :none,
     :no           => :none,
     :a            => :auto,
@@ -143,7 +143,7 @@ const _allMarkers = vcat(:none, :auto, _shape_keys) #sort(collect(keys(_shapes))
 )
 
 const _allScales = [:identity, :ln, :log2, :log10, :asinh, :sqrt]
-@compat const _scaleAliases = Dict{Symbol,Symbol}(
+const _scaleAliases = Dict{Symbol,Symbol}(
     :none => :identity,
     :log  => :log10,
 )

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("", @compat(AbstractString)[], Color[]))
+            unshift!(gplt.guides, Gadfly.Guide.manual_color_key("", 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...) #s::@compat(AbstractString))
+function findGuideAndSet(gplt, t::DataType, args...; kw...)
     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::@compat(AbstractString))
+function createGadflyAnnotationObject(x, y, val::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{@compat(Tuple{X,Y,V})})
+function _add_annotations{X,Y,V}(plt::Plot{GadflyBackend}, anns::AVec{Tuple{X,Y,V}})
     for ann in anns
         push!(plt.o.guides, createGadflyAnnotationObject(ann...))
     end

src/backends/immerse.jl

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

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(@compat(readstring), _js_path, "r")
+    _js_code = open(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 = """

src/backends/pyplot.jl

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

src/backends/qwt.jl

@@ -39,7 +39,7 @@ end
 
 # -------------------------------
 
-@compat const _qwtAliases = KW(
+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) <: @compat(Union{Tuple,AVec}) && length(lims) == 2
+  if typeof(lims) <: 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::@compat(AbstractString))
+function createQwtAnnotation(plt::Plot, x, y, val::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{@compat(Tuple{X,Y,V})})
+function _add_annotations{X,Y,V}(plt::Plot{QwtBackend}, anns::AVec{Tuple{X,Y,V}})
   for ann in anns
     createQwtAnnotation(plt, ann...)
   end
@@ -242,8 +242,6 @@ end
 
 # -------------------------------
 
-# savepng(::QwtBackend, plt::AbstractPlot, fn::@compat(AbstractString), args...) = Qwt.savepng(plt.o, fn)
-
 # -------------------------------
 
 # # create the underlying object (each backend will do this differently)

src/backends/unicodeplots.jl

@@ -122,7 +122,7 @@ function png(plt::AbstractPlot{UnicodePlotsBackend}, fn::AbstractString)
     gui(plt)
 
     # @osx_only begin
-    @compat @static if is_apple()
+    @static if is_apple()
         # BEGIN HACK
 
         # wait while the plot gets drawn

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)
-    @compat @static if is_apple()
+    @static if is_apple()
         return run(`open $(filename)`)
     end
-    @compat @static if is_linux()
+    @static if is_linux()
         return run(`xdg-open $(filename)`)
     end
-    @compat @static if is_windows()
+    @static if is_windows()
         return run(`$(ENV["COMSPEC"]) /c start $(filename)`)
     end
     warn("Unknown OS... cannot open browser window.")

src/backends/winston.jl

@@ -44,13 +44,13 @@ end
 
 
 ## dictionaries for conversion of Plots.jl names to Winston ones.
-@compat const winston_linestyle =  KW(:solid=>"solid",
+const winston_linestyle =  KW(:solid=>"solid",
                                 :dash=>"dash",
                                 :dot=>"dotted",
                                 :dashdot=>"dotdashed"
                                )
 
-@compat const winston_marker = KW(:none=>".",
+const winston_marker = KW(:none=>".",
                             :rect => "square",
                             :circle=>"circle",
                             :diamond=>"diamond",
@@ -185,7 +185,7 @@ end
 
 # ----------------------------------------------------------------
 
-@compat const _winstonNames = KW(
+const _winstonNames = KW(
     :xlims => :xrange,
     :ylims => :yrange,
     :xscale => :xlog,
@@ -213,11 +213,11 @@ end
 
 # ----------------------------------------------------------------
 
-function createWinstonAnnotationObject(plt::Plot{WinstonBackend}, x, y, val::@compat(AbstractString))
+function createWinstonAnnotationObject(plt::Plot{WinstonBackend}, x, y, val::AbstractString)
   Winston.text(x, y, val)
 end
 
-function _add_annotations{X,Y,V}(plt::Plot{WinstonBackend}, anns::AVec{@compat(Tuple{X,Y,V})})
+function _add_annotations{X,Y,V}(plt::Plot{WinstonBackend}, anns::AVec{Tuple{X,Y,V}})
   for ann in anns
     createWinstonAnnotationObject(plt, ann...)
   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)
-  @compat(Tuple{Float64,Float64})[(r*cos(u),r*sin(u)) for u in linspace(start_θ, end_θ, n)]
+    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
 
-@compat function (bc::BezierCurve)(t::Real)
+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
 
-@compat Base.:.*(m::Measure, n::Number) = m * n
+Base.:.*(m::Measure, n::Number) = m * n
-@compat Base.:.*(n::Number, m::Measure) = m * n
+Base.:.*(n::Number, m::Measure) = m * n
-@compat Base.:-(m::Measure, a::AbstractArray) = map(ai -> m - ai, a)
+Base.:-(m::Measure, a::AbstractArray) = map(ai -> m - ai, a)
-@compat Base.:-(a::AbstractArray, m::Measure) = map(ai -> ai - m, a)
+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
-# @compat Base.:+(m1::AbsoluteLength, m2::Length{:pct}) = AbsoluteLength(m1.value * (1 + m2.value))
+# 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))
+# 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))
+# 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::Length{:pct}, m2::AbsoluteLength) = AbsoluteLength(m2.value * (m1.value - 1))
 
-@compat Base.:*(m1::AbsoluteLength, m2::Length{:pct}) = AbsoluteLength(m1.value * m2.value)
+Base.:*(m1::AbsoluteLength, m2::Length{:pct}) = AbsoluteLength(m1.value * m2.value)
-@compat Base.:*(m1::Length{:pct}, m2::AbsoluteLength) = AbsoluteLength(m2.value * m1.value)
+Base.:*(m1::Length{:pct}, m2::AbsoluteLength) = AbsoluteLength(m2.value * m1.value)
-@compat Base.:/(m1::AbsoluteLength, m2::Length{:pct}) = AbsoluteLength(m1.value / m2.value)
+Base.:/(m1::AbsoluteLength, m2::Length{:pct}) = AbsoluteLength(m1.value / m2.value)
-@compat Base.:/(m1::Length{:pct}, m2::AbsoluteLength) = AbsoluteLength(m2.value / m1.value)
+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))
 
-# @compat Base.:*{T,N}(m1::Length{T,N}, m2::Length{T,N}) = Length{T,N}(m1.value * m2.value)
+# 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
-@compat function Base.:+(bb1::BoundingBox, bb2::BoundingBox)
+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

@@ -49,7 +49,7 @@ tex(fn::AbstractString) = tex(current(), fn)
 # ----------------------------------------------------------------
 
 
-@compat const _savemap = Dict(
+const _savemap = Dict(
     "png" => png,
     "svg" => svg,
     "pdf" => pdf,
@@ -210,7 +210,7 @@ end
 # IJulia
 # ---------------------------------------------------------
 
-const _ijulia_output = Compat.ASCIIString["text/html"]
+const _ijulia_output = String["text/html"]
 
 function setup_ijulia()
     # override IJulia inline display
@@ -225,7 +225,7 @@ function setup_ijulia()
             end
             function IJulia.display_dict(plt::Plot)
                 global _ijulia_output
-                Dict{Compat.ASCIIString, ByteString}(_ijulia_output[1] => sprint(show, _ijulia_output[1], plt))
+                Dict{String, String}(_ijulia_output[1] => sprint(show, _ijulia_output[1], plt))
             end
 
             # default text/plain passes to html... handles Interact issues

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,:]
+            dc[:seriestype] = sts[r:r,:]
             RecipeData(dc, args)
         end for r=1:size(sts,1)]
     else

src/plot.jl

@@ -156,6 +156,9 @@ function _plot!(plt::Plot, d::KW, args::Tuple)
 
     kw_list = _process_userrecipes(plt, d, args)
 
+    # info(1)
+    # map(DD, kw_list)
+
 
     # --------------------------------
     # "PLOT RECIPES"
@@ -172,6 +175,9 @@ 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
     # --------------------------------
@@ -185,6 +191,9 @@ 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]
         # idx = get_subplot_index(plt, sp)

src/recipes.jl

@@ -202,6 +202,7 @@ 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 @compat(Union{Function, AVec{Function}})
+typealias FuncOrFuncs 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::@compat(Void), d::KW) = Any[nothing], nothing
+convertToAnyVector(v::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<:@compat(AbstractString)}(v::AVec{T}, d::KW) = Any[v], nothing
+convertToAnyVector{T<: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) = n, n, n
+@recipe f(n::Integer) = is3d(get(d,:seriestype,:path)) ? (SliceIt, n, n, n) : (SliceIt, n, n, nothing)
 
 # return a surface if this is a 3d plot, otherwise let it be sliced up
 @recipe function f{T<:Number}(mat::AMat{T})

src/utils.jl

@@ -252,7 +252,7 @@ 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::@compat(Tuple{T,S})) = x
+maketuple{T,S}(x::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]
@@ -386,13 +386,12 @@ 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::@compat(Tuple{T,S}))  = :ticks_and_labels
+ticksType{T<:AVec,S<:AVec}(ticks::Tuple{T,S})  = :ticks_and_labels
 ticksType(ticks)                                        = :invalid
 
-limsType{T<:Real,S<:Real}(lims::@compat(Tuple{T,S}))    = :limits
+limsType{T<:Real,S<:Real}(lims::Tuple{T,S})    = :limits
 limsType(lims::Symbol)                                  = lims == :auto ? :auto : :invalid
 limsType(lims)                                          = :invalid
 
@@ -476,7 +475,7 @@ end
 
 # ---------------------------------------------------------------
 
-wraptuple(x::@compat(Tuple)) = x
+wraptuple(x::Tuple) = x
 wraptuple(x) = (x,)
 
 trueOrAllTrue(f::Function, x::AbstractArray) = all(f, x)
@@ -667,6 +666,42 @@ 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
+
+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)
+end
+
 # -------------------------------------------------------
 # push/append for one series
 

test/REQUIRE

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