Deprecated some function (#71)

* deprecated some function

* code coverage did not work

* more fixes to get coverage running

Author: simonschoelly

.travis.yml

@@ -14,9 +14,9 @@ matrix:
 notifications:
   email: false
 # uncomment the following lines to override the default test script
-#script:
-#  - if [[ -a .git/shallow ]]; then git fetch --unshallow; fi
-#  - julia --check-bounds=yes -e 'Pkg.clone(pwd()); Pkg.build("GraphPlot"); Pkg.test("GraphPlot"; coverage=true)'
+script:
+  - if [[ -a .git/shallow ]]; then git fetch --unshallow; fi
+  - julia -e 'using Pkg; Pkg.clone(pwd()); Pkg.build("GraphPlot"); Pkg.test("GraphPlot"; coverage=true)'
 after_success:
   # push coverage results to Codecov
-  - julia -e 'cd(using Pkg; Pkg.dir("GraphPlot")); Pkg.add("Coverage"); using Coverage; Codecov.submit(Codecov.process_folder())'
+  - julia -e 'using Pkg; cd(Pkg.dir("GraphPlot")); Pkg.add("Coverage"); using Coverage; Codecov.submit(Codecov.process_folder())'

src/GraphPlot.jl

@@ -15,9 +15,9 @@ export
     spring_layout,
     spectral_layout,
     shell_layout,
-    stressmajorize_layout,
-    graphfamous,
-    readedgelist
+    stressmajorize_layout
+
+include("deprecations.jl")
 
 # layout algorithms
 include("layout.jl")
@@ -29,19 +29,4 @@ include("lines.jl")
 include("plot.jl")
 include("collapse_plot.jl")
 
-# read graph
-include("graphio.jl")
-
-
-# These functions are mappings to various graph packages.
-# Currently only LightGraphs is supported.
-_nv(g::LightGraphs.AbstractGraph) = LightGraphs.nv(g)
-_ne(g::LightGraphs.AbstractGraph) = LightGraphs.ne(g)
-_vertices(g::LightGraphs.AbstractGraph) = LightGraphs.vertices(g)
-_edges(g::LightGraphs.AbstractGraph) = LightGraphs.edges(g)
-_src_index(e::LightGraphs.Edge, g::LightGraphs.AbstractGraph) = LightGraphs.src(e)
-_dst_index(e::LightGraphs.Edge, g::LightGraphs.AbstractGraph) = LightGraphs.dst(e)
-_adjacency_matrix(g::LightGraphs.AbstractGraph) = LightGraphs.adjacency_matrix(g)
-_is_directed(g::LightGraphs.AbstractGraph) = LightGraphs.is_directed(g)
-_laplacian_matrix(g::LightGraphs.AbstractGraph) = LightGraphs.laplacian_matrix(g)
 end # module

src/collapse_plot.jl

@@ -1,21 +1,21 @@
 using GraphPlot
 
-function collapse_graph(g::AbstractGraph, membership::Vector{Int})
+function collapse_graph(g::AbstractGraph{T}, membership::Vector{Int}) where {T<:Integer}
     nb_comm = maximum(membership)
 
     collapsed_edge_weights = Vector{Dict{Int,Float64}}(undef, nb_comm)
     for i=1:nb_comm
         collapsed_edge_weights[i] = Dict{Int,Float64}()
     end
 
-    for e in _edges(g)
-        u = _src_index(e,g)
-        v = _dst_index(e,g)
+    for e in edges(g)
+        u = src(e)
+        v = dst(e)
         u_comm = membership[u]
         v_comm = membership[v]
 
         # for special case of undirected network
-        if !_is_directed(g)
+        if !is_directed(g)
             u_comm, v_comm = minmax(u_comm, v_comm)
         end
 
@@ -63,11 +63,11 @@ function community_layout(g::AbstractGraph, membership::Vector{Int})
     lx, ly
 end
 
-function collapse_layout(g::AbstractGraph, membership::Vector{Int})
-    lightg = LightGraphs.SimpleGraph(_nv(g))
-    for e in _edges(g)
-        u = _src_index(e, g)
-        v = _dst_index(e, g)
+function collapse_layout(g::AbstractGraph{T}, membership::Vector{Int}) where {T<:Integer}
+    lightg = LightGraphs.SimpleGraph(nv(g))
+    for e in edges(g)
+        u = src(e)
+        v = dst(e)
         LightGraphs.add_edge!(lightg, u, v)
     end
     N = length(membership)

src/deprecations.jl

@@ -0,0 +1,106 @@
+using Base: depwarn
+
+
+function _nv(g) 
+    depwarn("`GraphPlot._nv(g)` is deprectated. Use `LightGraphs.nv(g)` instead.", :_nv)  
+    return LightGraphs.nv(g)
+end
+
+function _ne(g) 
+    depwarn("`GraphPlot._ne(g)` is deprectated. Use `LightGraphs.ne(g)` instead.", :_ne)  
+    return LightGraphs.ne(g)
+end
+
+function _vertices(g) 
+    depwarn("`GraphPlot._vertices(g)` is deprectated. Use `LightGraphs.vertices(g)` instead.", :_vertices)  
+    return LightGraphs.vertices(g)
+end
+
+function _edges(g) 
+    depwarn("`GraphPlot._edges(g)` is deprectated. Use `LightGraphs.edges(g)` instead.", :_edges)  
+    return LightGraphs.edges(g)
+end
+
+function _src_index(e, g) 
+    depwarn("`GraphPlot._src_index(g)` is deprectated. Use `LightGraphs.src(e)` instead.", :_src_index)  
+    return LightGraphs.src(e)
+end
+
+function _dst_index(e, g) 
+    depwarn("`GraphPlot._dst_index(g)` is deprectated. Use `LightGraphs.dst(e)` instead.", :_dst_index)  
+    return LightGraphs.dst(e)
+end
+
+function _adjacency_matrix(g) 
+    depwarn("`GraphPlot._adjacency_matrix(g)` is deprectated. Use `LightGraphs.adjacency_matrix(g)` instead.", :_adjacency_matrix)  
+    return LightGraphs.adjacency_matrix(g)
+end
+
+function _is_directed(g) 
+    depwarn("`GraphPlot._is_directed(g)` is deprectated. Use `LightGraphs.is_directed(g)` instead.", :_is_directed)  
+    return LightGraphs.is_directed(g)
+end
+
+function _laplacian_matrix(g) 
+    depwarn("`GraphPlot._laplacian_matrix(g)` is deprectated. Use `LightGraphs.laplacian_matrix(g)` instead.", :_laplacian_matrix)  
+    return LightGraphs.laplacian_matrix(g)
+end
+
+
+"""
+read some famous graphs
+
+**Paramenters**
+
+*graphname*
+Currently, `graphname` can be one of ["karate", "football", "dolphins",
+"netscience", "polbooks", "power", "cond-mat"]
+
+**Return**
+a graph
+
+**Example**
+    julia> g = graphfamous("karate")
+"""
+function graphfamous(graphname::AbstractString)
+     depwarn("""
+             `graphfamous` has been deprecated and will be removed in the future. Consider the package `GraphIO.jl` for loading graphs.
+            """, :graphfamous)
+    file = joinpath(dirname(@__DIR__), "data", graphname*".dat")
+    readedgelist(file)
+end
+export graphfamous
+
+using DelimitedFiles: readdlm
+"""read graph from in edgelist format"""
+function readedgelist(filename; is_directed::Bool=false, start_index::Int=0, delim::Char=' ')
+    depwarn("""
+             `graphfamous` has been deprecated and will be removed in the future. Consider the package `GraphIO.jl` for loading graphs.
+            """, :graphfamous)
+    es = readdlm(filename, delim, Int)
+    es = unique(es, dims=1)
+    if start_index == 0
+        es = es .+ 1
+    end
+    N = maximum(es)
+    if is_directed
+        g = DiGraph(N)
+        for i=1:size(es,1)
+            add_edge!(g, es[i,1], es[i,2])
+        end
+        return g
+    else
+        for i=1:size(es,1)
+            if es[i,1] > es[i,2]
+                es[i,1], es[i,2] = es[i,2], es[i,1]
+            end
+        end
+        es = unique(es, dims=1)
+        g = Graph(N)
+        for i=1:size(es,1)
+            add_edge!(g, es[i,1], es[i,2])
+        end
+        return g
+    end
+end
+export readedgelist

src/graphio.jl

@@ -28,8 +28,8 @@ julia> loc_x, loc_y = random_layout(g)
 ```
 
 """
-function random_layout(G)
-    rand(_nv(G)), rand(_nv(G))
+function random_layout(g)
+    rand(nv(g)), rand(nv(g))
 end
 
 """
@@ -55,8 +55,8 @@ julia> g = simple_house_graph()
 julia> locs_x, locs_y = circular_layout(g)
 ```
 """
-function circular_layout(G)
-    if _nv(G) == 1
+function circular_layout(g)
+    if nv(g) == 1
         return [0.0], [0.0]
     else
         # Discard the extra angle since it matches 0 radians.
@@ -79,7 +79,7 @@ where C is a parameter we can adjust
 
 **Parameters**
 
-*G*
+*g*
 a graph
 
 *C*
@@ -97,11 +97,11 @@ julia> g = graphfamous("karate")
 julia> locs_x, locs_y = spring_layout(g)
 ```
 """
-function spring_layout(G, locs_x=2*rand(_nv(G)).-1.0, locs_y=2*rand(_nv(G)).-1.0; C=2.0, MAXITER=100, INITTEMP=2.0)
+function spring_layout(g::AbstractGraph{T}, locs_x=2*rand(nv(g)).-1.0, locs_y=2*rand(nv(g)).-1.0; C=2.0, MAXITER=100, INITTEMP=2.0) where {T<:Integer}
 
     #size(adj_matrix, 1) != size(adj_matrix, 2) && error("Adj. matrix must be square.")
-    N = _nv(G)
-    adj_matrix = _adjacency_matrix(G)
+    N = nv(g)
+    adj_matrix = adjacency_matrix(g)
 
     # The optimal distance bewteen vertices
     K = C * sqrt(4.0 / N)
@@ -218,7 +218,7 @@ Position nodes using the eigenvectors of the graph Laplacian.
 
 **Parameters**
 
-*G*
+*g*
 a graph
 
 *weight*
@@ -233,34 +233,34 @@ julia> weight = rand(num_edges(g))
 julia> locs_x, locs_y = spectral_layout(g, weight)
 ```
 """
-function spectral_layout(G, weight=nothing)
-    if _nv(G) == 1
+function spectral_layout(g::AbstractGraph{T}, weight=nothing) where {T<:Integer}
+    if nv(g) == 1
         return [0.0], [0.0]
-    elseif _nv(G) == 2
+    elseif nv(g) == 2
         return [0.0, 1.0], [0.0, 0.0]
     end
 
     if weight == nothing
-        weight = ones(length(_edges(G)))
+        weight = ones(length(edges(g)))
     end
-    if _nv(G) > 500
-        A = sparse(Int[_src_index(e, G) for e in _edges(G)],
-                   Int[_dst_index(e, G) for e in _edges(G)],
-                   weight, _nv(G), _nv(G))
-        if _is_directed(G)
-            A = A + A'
+    if nv(g) > 500
+        A = sparse(Int[src(e) for e in edges(g)],
+                   Int[dst(e) for e in edges(g)],
+                   weight, nv(g), nv(g))
+        if is_directed(g)
+            A = A + transpose(A)
         end
         return _spectral(A)
     else
-        L = _laplacian_matrix(G)
+        L = laplacian_matrix(g)
         return _spectral(Matrix(L))
     end
 end
 
 function _spectral(L::Matrix)
     eigenvalues, eigenvectors = eigen(L)
     index = sortperm(eigenvalues)[2:3]
-    eigenvectors[:, index[1]], eigenvectors[:, index[2]]
+    return eigenvectors[:, index[1]], eigenvectors[:, index[2]]
 end
 
 function _spectral(A::SparseMatrixCSC)
@@ -269,5 +269,5 @@ function _spectral(A::SparseMatrixCSC)
     L = D - A
     eigenvalues, eigenvectors = LightGraphs.LinAlg.eigs(L, nev=3, which=LR())
     index = sortperm(real(eigenvalues))[2:3]
-    real(eigenvectors[:, index[1]]), real(eigenvectors[:, index[2]])
+    return real(eigenvectors[:, index[1]]), real(eigenvectors[:, index[2]])
 end