From 4a78820801f0560b2564f1ed1a1915e2a150e7da Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Mon, 17 Feb 2020 22:39:42 +0000 Subject: [PATCH] Format files using DocumentFormat --- docs/make.jl | 2 +- src/TableTraitsUtils.jl | 16 ++-- src/collect1.jl | 104 +++++++++++------------ test/runtests.jl | 130 ++++++++++++++--------------- test/test_source_without_length.jl | 12 +-- 5 files changed, 132 insertions(+), 132 deletions(-) diff --git a/docs/make.jl b/docs/make.jl index 3a9d0ac..0c5683a 100644 --- a/docs/make.jl +++ b/docs/make.jl @@ -3,7 +3,7 @@ using Documenter, TableTraitsUtils makedocs( modules = [TableTraitsUtils], sitename = "TableTraitsUtils.jl", - analytics="UA-132838790-1", + analytics = "UA-132838790-1", pages = [ "Introduction" => "index.md" ] diff --git a/src/TableTraitsUtils.jl b/src/TableTraitsUtils.jl index 346ad06..dc6eba9 100644 --- a/src/TableTraitsUtils.jl +++ b/src/TableTraitsUtils.jl @@ -6,7 +6,7 @@ export create_tableiterator, create_columns_from_iterabletable # T is the type of the elements produced # TS is a tuple type that stores the columns of the table -struct TableIterator{T, TS} +struct TableIterator{T,TS} columns::TS end @@ -19,19 +19,19 @@ function create_tableiterator(columns, names::Vector{Symbol}) push!(field_types, i) end end - return TableIterator{NamedTuple{(names...,), Tuple{field_types...}}, Tuple{typeof.(columns)...}}((columns...,)) + return TableIterator{NamedTuple{(names...,),Tuple{field_types...}},Tuple{typeof.(columns)...}}((columns...,)) end function Base.length(iter::TableIterator{T,TS}) where {T,TS} - return length(iter.columns)==0 ? 0 : length(iter.columns[1]) + return length(iter.columns) == 0 ? 0 : length(iter.columns[1]) end Base.eltype(::Type{TableIterator{T,TS}}) where {T,TS} = T -@generated function Base.iterate(iter::TableIterator{T,TS}, state=1) where {T,TS} +@generated function Base.iterate(iter::TableIterator{T,TS}, state = 1) where {T,TS} columns = map(1:length(TS.parameters)) do i - if fieldtype(T,i) <: DataValue && eltype(TS.parameters[i]) >: Missing - return :($(fieldtype(T,i))(iter.columns[$i][state])) + if fieldtype(T, i) <: DataValue && eltype(TS.parameters[i]) >: Missing + return :($(fieldtype(T, i))(iter.columns[$i][state])) else return :(iter.columns[$i][state]) end @@ -39,8 +39,8 @@ Base.eltype(::Type{TableIterator{T,TS}}) where {T,TS} = T return quote if state > length(iter) return nothing - else - return $(T)(($(columns...),)), state+1 + else + return $(T)(($(columns...),)), state + 1 end end end diff --git a/src/collect1.jl b/src/collect1.jl index 399902c..7f3240d 100644 --- a/src/collect1.jl +++ b/src/collect1.jl @@ -1,33 +1,33 @@ # Main entry point -function create_columns_from_iterabletable(itr; sel_cols=:all, na_representation=:datavalue, errorhandling=:error) +function create_columns_from_iterabletable(itr; sel_cols = :all, na_representation = :datavalue, errorhandling = :error) in(errorhandling, (:error, :returnvalue)) || throw(ArgumentError("'$errorhandling' is not a valid argument for errorhandling.")) in(na_representation, (:datavalue, :missing)) || throw(ArgumentError("'$na_representation' is not a valid argument for na_representation.")) - if TableTraits.isiterabletable(itr)===false - if errorhandling==:error + if TableTraits.isiterabletable(itr) === false + if errorhandling == :error throw(ArgumentError("itr is not a table.")) - elseif errorhandling==:returnvalue + elseif errorhandling == :returnvalue return nothing end else - array_factory = if na_representation==:datavalue - (t,rows) -> begin - if t <: DataValue - return DataValueArray{eltype(t)}(rows) - else - return Array{t}(undef, rows) - end + array_factory = if na_representation == :datavalue + (t, rows)->begin + if t <: DataValue + return DataValueArray{eltype(t)}(rows) + else + return Array{t}(undef, rows) end - elseif na_representation==:missing - (t,rows) -> begin - if t <: DataValue - return Array{Union{eltype(t),Missing}}(undef, rows) - else - return Array{t}(undef, rows) - end + end + elseif na_representation == :missing + (t, rows)->begin + if t <: DataValue + return Array{Union{eltype(t),Missing}}(undef, rows) + else + return Array{t}(undef, rows) end end + end itr2 = IteratorInterfaceExtensions.getiterator(itr) return _collect_columns(itr2, Base.IteratorSize(itr2), array_factory, sel_cols, errorhandling) @@ -37,41 +37,41 @@ end function collect_empty_columns(itr::T, ::Base.EltypeUnknown, array_factory, sel_cols, errorhandling) where {T} S = Core.Compiler.return_type(first, Tuple{T}) if S == Union{} || !(S <: NamedTuple) - if errorhandling==:error + if errorhandling == :error throw(ArgumentError("itr is not a table.")) - elseif errorhandling==:returnvalue + elseif errorhandling == :returnvalue return nothing end end - dest = getdest(S,0, array_factory, sel_cols) + dest = getdest(S, 0, array_factory, sel_cols) return collect(values(dest)), collect(keys(dest)) end function collect_empty_columns(itr::T, ::Base.HasEltype, array_factory, sel_cols, errorhandling) where {T} if eltype(itr) <: NamedTuple - dest = getdest(eltype(itr),0, array_factory, sel_cols) + dest = getdest(eltype(itr), 0, array_factory, sel_cols) return collect(values(dest)), collect(keys(dest)) else - if errorhandling==:error + if errorhandling == :error throw(ArgumentError("itr is not a table.")) - elseif errorhandling==:returnvalue + elseif errorhandling == :returnvalue return nothing end end end function getdest(T, n, array_factory, sel_cols) - if sel_cols==:all - return NamedTuple{fieldnames(T)}(tuple((array_factory(fieldtype(T,i),n) for i in 1:length(fieldnames(T)))...)) + if sel_cols == :all + return NamedTuple{fieldnames(T)}(tuple((array_factory(fieldtype(T, i), n) for i in 1:length(fieldnames(T)))...)) else - return NamedTuple{fieldnames(T)}(tuple((i in sel_cols ? array_factory(fieldtype(T,i),n) : nothing for i in 1:length(fieldnames(T)))...)) + return NamedTuple{fieldnames(T)}(tuple((i in sel_cols ? array_factory(fieldtype(T, i), n) : nothing for i in 1:length(fieldnames(T)))...)) end end @generated function _setrow(dest::NamedTuple{NAMES,TYPES}, i, el::T) where {T,NAMES,TYPES} push_exprs = Expr(:block) for col_idx in 1:length(fieldnames(T)) - if fieldtype(TYPES, col_idx)!==Nothing + if fieldtype(TYPES, col_idx) !== Nothing if fieldtype(TYPES, col_idx) == Array{Any,1} && fieldtype(T, col_idx) == DataValue{Any} ex = :( dest[$col_idx][i] = get(el[$col_idx], missing) ) else @@ -87,7 +87,7 @@ end @generated function _pushrow(dest::NamedTuple{NAMES,TYPES}, el::T) where {T,NAMES,TYPES} push_exprs = Expr(:block) for col_idx in 1:length(fieldnames(T)) - if fieldtype(TYPES, col_idx)!==Nothing + if fieldtype(TYPES, col_idx) !== Nothing if fieldtype(TYPES, col_idx) == Array{Any,1} && fieldtype(T, col_idx) == DataValue{Any} ex = :( push!(dest[$col_idx], get(el[$col_idx], missing)) ) else @@ -100,38 +100,38 @@ end return push_exprs end -function _collect_columns(itr, ::Union{Base.HasShape, Base.HasLength}, array_factory, sel_cols, errorhandling) +function _collect_columns(itr, ::Union{Base.HasShape,Base.HasLength}, array_factory, sel_cols, errorhandling) y = iterate(itr) - y===nothing && return collect_empty_columns(itr, Base.IteratorEltype(itr), array_factory, sel_cols, errorhandling) + y === nothing && return collect_empty_columns(itr, Base.IteratorEltype(itr), array_factory, sel_cols, errorhandling) - if !(typeof(y[1])<:NamedTuple) - if errorhandling==:error + if !(typeof(y[1]) <: NamedTuple) + if errorhandling == :error throw(ArgumentError("itr is not a table.")) - elseif errorhandling==:returnvalue + elseif errorhandling == :returnvalue return nothing end end dest = getdest(typeof(y[1]), length(itr), array_factory, sel_cols) - _setrow(dest,1,y[1]) + _setrow(dest, 1, y[1]) _collect_to_columns!(dest, itr, 2, y[2], sel_cols, errorhandling) end -function _collect_to_columns!(dest::T, itr, offs, st, sel_cols, errorhandling) where {T<:NamedTuple} +function _collect_to_columns!(dest::T, itr, offs, st, sel_cols, errorhandling) where {T <: NamedTuple} i = offs - y = iterate(itr,st) - while y!==nothing - _setrow(dest,i,y[1]) + y = iterate(itr, st) + while y !== nothing + _setrow(dest, i, y[1]) i += 1 - y = iterate(itr,y[2]) + y = iterate(itr, y[2]) end - if sel_cols==:all + if sel_cols == :all return collect(values(dest)), collect(keys(dest)) else - names_to_use = tuple((fieldname(T,i) for i in sel_cols)...) + names_to_use = tuple((fieldname(T, i) for i in sel_cols)...) r = NamedTuple{names_to_use}(dest) return collect(values(r)), collect(keys(r)) end @@ -139,34 +139,34 @@ end function _collect_columns(itr, ::Base.SizeUnknown, array_factory, sel_cols, errorhandling) y = iterate(itr) - y===nothing && return collect_empty_columns(itr, Base.IteratorEltype(itr), array_factory, sel_cols, errorhandling) + y === nothing && return collect_empty_columns(itr, Base.IteratorEltype(itr), array_factory, sel_cols, errorhandling) - if !(typeof(y[1])<:NamedTuple) - if errorhandling==:error + if !(typeof(y[1]) <: NamedTuple) + if errorhandling == :error throw(ArgumentError("itr is not a table.")) - elseif errorhandling==:returnvalue + elseif errorhandling == :returnvalue return nothing end end dest = getdest(typeof(y[1]), 1, array_factory, sel_cols) - _setrow(dest,1,y[1]) + _setrow(dest, 1, y[1]) _grow_to_columns!(dest, itr, y[2], sel_cols, errorhandling) end -function _grow_to_columns!(dest::T, itr, st, sel_cols, errorhandling) where {T<:NamedTuple} +function _grow_to_columns!(dest::T, itr, st, sel_cols, errorhandling) where {T <: NamedTuple} y = iterate(itr, st) - while y!==nothing + while y !== nothing _pushrow(dest, y[1]) - y = iterate(itr,y[2]) + y = iterate(itr, y[2]) end - if sel_cols==:all + if sel_cols == :all return collect(values(dest)), collect(keys(dest)) else - names_to_use = tuple((fieldname(T,i) for i in sel_cols)...) + names_to_use = tuple((fieldname(T, i) for i in sel_cols)...) r = NamedTuple{names_to_use}(dest) return collect(values(r)), collect(keys(r)) end diff --git a/test/runtests.jl b/test/runtests.jl index 888e1ac..b650425 100644 --- a/test/runtests.jl +++ b/test/runtests.jl @@ -6,98 +6,98 @@ include("test_source_without_length.jl") @testset "TableTraitsUtils" begin -@test_throws ArgumentError TableTraitsUtils.create_columns_from_iterabletable(nothing) -@test_throws ArgumentError TableTraitsUtils.create_columns_from_iterabletable(nothing, errorhandling=:error) -@test TableTraitsUtils.create_columns_from_iterabletable(nothing, errorhandling=:returnvalue)===nothing + @test_throws ArgumentError TableTraitsUtils.create_columns_from_iterabletable(nothing) + @test_throws ArgumentError TableTraitsUtils.create_columns_from_iterabletable(nothing, errorhandling = :error) + @test TableTraitsUtils.create_columns_from_iterabletable(nothing, errorhandling = :returnvalue) === nothing -@test_throws ArgumentError TableTraitsUtils.create_columns_from_iterabletable([1,2,3]) -@test_throws ArgumentError TableTraitsUtils.create_columns_from_iterabletable([1,2,3], errorhandling=:error) -@test TableTraitsUtils.create_columns_from_iterabletable([1,2,3], errorhandling=:returnvalue)===nothing + @test_throws ArgumentError TableTraitsUtils.create_columns_from_iterabletable([1,2,3]) + @test_throws ArgumentError TableTraitsUtils.create_columns_from_iterabletable([1,2,3], errorhandling = :error) + @test TableTraitsUtils.create_columns_from_iterabletable([1,2,3], errorhandling = :returnvalue) === nothing -@test_throws ArgumentError TableTraitsUtils.create_columns_from_iterabletable(Iterators.filter(i->true, [1,2,3])) -@test_throws ArgumentError TableTraitsUtils.create_columns_from_iterabletable(Iterators.filter(i->true, [1,2,3]), errorhandling=:error) -@test TableTraitsUtils.create_columns_from_iterabletable(Iterators.filter(i->true, [1,2,3]), errorhandling=:returnvalue)===nothing + @test_throws ArgumentError TableTraitsUtils.create_columns_from_iterabletable(Iterators.filter(i->true, [1,2,3])) + @test_throws ArgumentError TableTraitsUtils.create_columns_from_iterabletable(Iterators.filter(i->true, [1,2,3]), errorhandling = :error) + @test TableTraitsUtils.create_columns_from_iterabletable(Iterators.filter(i->true, [1,2,3]), errorhandling = :returnvalue) === nothing -@test create_columns_from_iterabletable(NamedTuple{(:a,:b),Tuple{Int,String}}[]) == (Any[Int[],String[]], [:a,:b]) -@test create_columns_from_iterabletable((i for i in NamedTuple{(:a,:b),Tuple{Int,String}}[])) == (Any[Int[],String[]], [:a,:b]) + @test create_columns_from_iterabletable(NamedTuple{(:a, :b),Tuple{Int,String}}[]) == (Any[Int[],String[]], [:a,:b]) + @test create_columns_from_iterabletable((i for i in NamedTuple{(:a, :b),Tuple{Int,String}}[])) == (Any[Int[],String[]], [:a,:b]) -@test_throws ArgumentError create_columns_from_iterabletable(Int[]) -@test_throws ArgumentError create_columns_from_iterabletable(Int[], errorhandling=:error) -@test create_columns_from_iterabletable(Int[], errorhandling=:returnvalue) === nothing -@test_throws ArgumentError create_columns_from_iterabletable((i for i in Int[])) -@test_throws ArgumentError create_columns_from_iterabletable((i for i in Int[]), errorhandling=:error) -@test create_columns_from_iterabletable((i for i in Int[]), errorhandling=:returnvalue) === nothing + @test_throws ArgumentError create_columns_from_iterabletable(Int[]) + @test_throws ArgumentError create_columns_from_iterabletable(Int[], errorhandling = :error) + @test create_columns_from_iterabletable(Int[], errorhandling = :returnvalue) === nothing + @test_throws ArgumentError create_columns_from_iterabletable((i for i in Int[])) + @test_throws ArgumentError create_columns_from_iterabletable((i for i in Int[]), errorhandling = :error) + @test create_columns_from_iterabletable((i for i in Int[]), errorhandling = :returnvalue) === nothing -columns = (Int[1,2,3], Float64[1.,2.,3.], String["John", "Sally", "Drew"]) -names = [:children, :age, :name] + columns = (Int[1,2,3], Float64[1.,2.,3.], String["John", "Sally", "Drew"]) + names = [:children, :age, :name] -it = TableTraitsUtils.create_tableiterator(columns, names) + it = TableTraitsUtils.create_tableiterator(columns, names) -columns2, names2 = TableTraitsUtils.create_columns_from_iterabletable(it) + columns2, names2 = TableTraitsUtils.create_columns_from_iterabletable(it) -columns3, names3 = TableTraitsUtils.create_columns_from_iterabletable(it, sel_cols=:all) + columns3, names3 = TableTraitsUtils.create_columns_from_iterabletable(it, sel_cols = :all) -columns23, names23 = TableTraitsUtils.create_columns_from_iterabletable(it, sel_cols=[2,3]) + columns23, names23 = TableTraitsUtils.create_columns_from_iterabletable(it, sel_cols = [2,3]) -@test columns[1] == columns2[1] == columns3[1] -@test columns[2] == columns2[2] == columns3[2] -@test columns[3] == columns2[3] == columns3[3] -@test length(columns) == length(columns2) == length(columns3) -@test columns[2] == columns23[1] -@test columns[3] == columns23[2] -@test length(columns23) == 2 + @test columns[1] == columns2[1] == columns3[1] + @test columns[2] == columns2[2] == columns3[2] + @test columns[3] == columns2[3] == columns3[3] + @test length(columns) == length(columns2) == length(columns3) + @test columns[2] == columns23[1] + @test columns[3] == columns23[2] + @test length(columns23) == 2 -@test names == names2 == names3 -@test names[2:3] == names23 + @test names == names2 == names3 + @test names[2:3] == names23 -@test isequal(create_columns_from_iterabletable([(a=DataValue{Any}(), b=DataValue{Int}())], na_representation=:missing), + @test isequal(create_columns_from_iterabletable([(a = DataValue{Any}(), b = DataValue{Int}())], na_representation = :missing), ([Any[missing], Union{Missing,Int}[missing]], [:a, :b]) ) -@test create_columns_from_iterabletable([(a=DataValue{Any}(), b=DataValue{Int}())], na_representation=:datavalue) == + @test create_columns_from_iterabletable([(a = DataValue{Any}(), b = DataValue{Int}())], na_representation = :datavalue) == ([DataValue{Any}[NA], DataValue{Int}[NA]], [:a, :b]) -it2 = TestSourceWithoutLength() + it2 = TestSourceWithoutLength() -columns4, names4 = TableTraitsUtils.create_columns_from_iterabletable(it2) -@test columns4[1] == [1,2] -@test columns4[2] == [1.,2.] -@test names4 == [:a, :b] + columns4, names4 = TableTraitsUtils.create_columns_from_iterabletable(it2) + @test columns4[1] == [1,2] + @test columns4[2] == [1.,2.] + @test names4 == [:a, :b] -columns5, names5 = TableTraitsUtils.create_columns_from_iterabletable(it2, sel_cols=:all) -@test columns5[1] == [1,2] -@test columns5[2] == [1.,2.] -@test names5 == [:a, :b] + columns5, names5 = TableTraitsUtils.create_columns_from_iterabletable(it2, sel_cols = :all) + @test columns5[1] == [1,2] + @test columns5[2] == [1.,2.] + @test names5 == [:a, :b] -columns6, names6 = TableTraitsUtils.create_columns_from_iterabletable(it2, sel_cols=[2]) -@test columns6[1] == [1.,2.] -@test names6 == [:b] + columns6, names6 = TableTraitsUtils.create_columns_from_iterabletable(it2, sel_cols = [2]) + @test columns6[1] == [1.,2.] + @test names6 == [:b] -columns_with_nulls = (Union{Int,Missing}[3, 2, missing], Float64[2.,5.,9.], Union{String,Missing}["a", missing, "b"]) -it3 = TableTraitsUtils.create_tableiterator(columns_with_nulls, names) + columns_with_nulls = (Union{Int,Missing}[3, 2, missing], Float64[2.,5.,9.], Union{String,Missing}["a", missing, "b"]) + it3 = TableTraitsUtils.create_tableiterator(columns_with_nulls, names) -columns7, names7 = TableTraitsUtils.create_columns_from_iterabletable(it3) + columns7, names7 = TableTraitsUtils.create_columns_from_iterabletable(it3) -@test columns7[1] == [3,2,NA] -@test columns7[2] == [2.,5.,9.] -@test columns7[3] == ["a",NA,"b"] -@test length(columns7) == 3 -@test names7 == names + @test columns7[1] == [3,2,NA] + @test columns7[2] == [2.,5.,9.] + @test columns7[3] == ["a",NA,"b"] + @test length(columns7) == 3 + @test names7 == names -columns_with_DV = ([3, 2, NA], [2.,5.,9.], ["a", NA, "b"]) -it4 = TableTraitsUtils.create_tableiterator(columns_with_DV, names) + columns_with_DV = ([3, 2, NA], [2.,5.,9.], ["a", NA, "b"]) + it4 = TableTraitsUtils.create_tableiterator(columns_with_DV, names) -columns8, names8 = TableTraitsUtils.create_columns_from_iterabletable(it4) + columns8, names8 = TableTraitsUtils.create_columns_from_iterabletable(it4) -@test columns8[1] == [3,2,NA] -@test columns8[2] == [2.,5.,9.] -@test columns8[3] == ["a",NA,"b"] -@test length(columns8) == 3 -@test names8 == names + @test columns8[1] == [3,2,NA] + @test columns8[2] == [2.,5.,9.] + @test columns8[3] == ["a",NA,"b"] + @test length(columns8) == 3 + @test names8 == names -it = TableTraitsUtils.create_tableiterator(Any[], Symbol[]) + it = TableTraitsUtils.create_tableiterator(Any[], Symbol[]) -@test length(it)==0 -@test iterate(it)===nothing + @test length(it) == 0 + @test iterate(it) === nothing end diff --git a/test/test_source_without_length.jl b/test/test_source_without_length.jl index 5750d42..6a623f9 100644 --- a/test/test_source_without_length.jl +++ b/test/test_source_without_length.jl @@ -2,16 +2,16 @@ struct TestSourceWithoutLength end function Base.eltype(iter::TestSourceWithoutLength) - return NamedTuple{(:a, :b), Tuple{Int, Float64}} + return NamedTuple{(:a, :b),Tuple{Int,Float64}} end Base.IteratorSize(::Type{T}) where {T <: TestSourceWithoutLength} = Base.SizeUnknown() -function Base.iterate(iter::TestSourceWithoutLength, state=1) - if state==1 - return (a=1, b=1.), 2 - elseif state==2 - return (a=2, b=2.), 3 +function Base.iterate(iter::TestSourceWithoutLength, state = 1) + if state == 1 + return (a = 1, b = 1.), 2 + elseif state == 2 + return (a = 2, b = 2.), 3 else return nothing end