[AUTO] Format files using DocumentFormat

docs/make.jl

@@ -1,16 +1,16 @@
 using Documenter, IterableTables
 
 makedocs(
-	modules = [IterableTables],
+	modules=[IterableTables],
 	analytics="UA-132838790-1",
-	sitename = "IterableTables.jl",
-	pages = [
+	sitename="IterableTables.jl",
+	pages=[
 		"Introduction" => "index.md",
         "User Guide" => "userguide.md",
         "Integration Guide" => "integrationguide.md",
         "Developer Guide" => "developerguide.md"]
 )
 
 deploydocs(
-    repo = "github.com/queryverse/IterableTables.jl.git"
+    repo="github.com/queryverse/IterableTables.jl.git"
 )

src/IterableTables.jl

@@ -8,16 +8,16 @@ using DataValues
 include("integrations/generators.jl")
 
 function __init__()
-    @require DataFrames="a93c6f00-e57d-5684-b7b6-d8193f3e46c0" if !isdefined(DataFrames, :Tables)
+    @require DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" if !isdefined(DataFrames, :Tables)
         include("integrations/dataframes.jl")
     end
-    @require StatsModels="3eaba693-59b7-5ba5-a881-562e759f1c8d" if !isdefined(StatsModels, :Tables)
+    @require StatsModels = "3eaba693-59b7-5ba5-a881-562e759f1c8d" if !isdefined(StatsModels, :Tables)
         include("integrations/statsmodels.jl")
     end
-    @require TimeSeries="9e3dc215-6440-5c97-bce1-76c03772f85e" if !isdefined(TimeSeries, :Tables)
+    @require TimeSeries = "9e3dc215-6440-5c97-bce1-76c03772f85e" if !isdefined(TimeSeries, :Tables)
         include("integrations/timeseries.jl")
     end
-    @require Temporal="a110ec8f-48c8-5d59-8f7e-f91bc4cc0c3d" include("integrations/temporal.jl")
+    @require Temporal = "a110ec8f-48c8-5d59-8f7e-f91bc4cc0c3d" include("integrations/temporal.jl")
 end
 
 end # module

src/integrations/dataframes.jl

@@ -15,7 +15,7 @@ function _DataFrame(x)
     return DataFrames.DataFrame(cols, names)
 end
 
-DataFrames.DataFrame(x::AbstractVector{T}) where {T<:NamedTuple} = _DataFrame(x)
+DataFrames.DataFrame(x::AbstractVector{T}) where {T <: NamedTuple} = _DataFrame(x)
 
 function DataFrames.DataFrame(x)
     if TableTraits.isiterabletable(x)

src/integrations/generators.jl

@@ -1,4 +1,4 @@
-struct GeneratorWithElType{T, S}
+struct GeneratorWithElType{T,S}
     source::S
 end
 

src/integrations/juliadb.jl

@@ -1,39 +1,39 @@
 @require JuliaDB begin
-using TableTraits
-using JuliaDB: DTable
-import IndexedTables
+    using TableTraits
+    using JuliaDB: DTable
+    import IndexedTables
 
-TableTraits.isiterable(x::DTable) = true
-TableTraits.isiterabletable(x::DTable) = true
+    TableTraits.isiterable(x::DTable) = true
+    TableTraits.isiterabletable(x::DTable) = true
 
 # TODO Replace with something more efficient
-function TableTraits.getiterator{S<:DTable}(source::S)
-    it  = collect(source)
-    iter = getiterator(it)
+    function TableTraits.getiterator{S <: DTable}(source::S)
+        it  = collect(source)
+        iter = getiterator(it)
 
-    return iter
-end
+        return iter
+    end
 
 # TODO Replace with something more efficient
-function JuliaDB.distribute(source, rowgroups::AbstractArray; idxcols::Union{Void,Vector{Symbol}}=nothing, datacols::Union{Void,Vector{Symbol}}=nothing)
-    isiterabletable(source) || error()
+    function JuliaDB.distribute(source, rowgroups::AbstractArray; idxcols::Union{Void,Vector{Symbol}}=nothing, datacols::Union{Void,Vector{Symbol}}=nothing)
+        isiterabletable(source) || error()
 
-    it = IndexedTables.IndexedTable(source, idxcols=idxcols, datacols=datacols)
+        it = IndexedTables.IndexedTable(source, idxcols=idxcols, datacols=datacols)
 
-    dt = JuliaDB.distribute(it, rowgroups)
+        dt = JuliaDB.distribute(it, rowgroups)
 
-    return dt
-end
+        return dt
+    end
 
 # TODO Replace with something more efficient
-function JuliaDB.distribute(source, nchunks::Int=nworkers(); idxcols::Union{Void,Vector{Symbol}}=nothing, datacols::Union{Void,Vector{Symbol}}=nothing)
-    isiterabletable(source) || error()
+    function JuliaDB.distribute(source, nchunks::Int=nworkers(); idxcols::Union{Void,Vector{Symbol}}=nothing, datacols::Union{Void,Vector{Symbol}}=nothing)
+        isiterabletable(source) || error()
 
-    it = IndexedTables.IndexedTable(source, idxcols=idxcols, datacols=datacols)
+        it = IndexedTables.IndexedTable(source, idxcols=idxcols, datacols=datacols)
 
-    dt = JuliaDB.distribute(it, nchunks)
+        dt = JuliaDB.distribute(it, nchunks)
 
-    return dt
-end
+        return dt
+    end
 
 end

src/integrations/statsmodels.jl

@@ -3,8 +3,8 @@ function StatsModels.ModelFrame(f::StatsModels.Formula, d; kwargs...)
     StatsModels.ModelFrame(f, DataFrames.DataFrame(d); kwargs...)
 end
 
-function StatsModels.StatsBase.fit(::Type{T}, f::StatsModels.Formula, d, args...; contrasts::Dict = Dict(), kwargs...) where
-                       T<:Union{ StatsModels.StatsBase.StatisticalModel,  StatsModels.StatsBase.RegressionModel}
+function StatsModels.StatsBase.fit(::Type{T}, f::StatsModels.Formula, d, args...; contrasts::Dict=Dict(), kwargs...) where
+                       T <: Union{StatsModels.StatsBase.StatisticalModel,StatsModels.StatsBase.RegressionModel}
     TableTraits.isiterabletable(d) || error()
-    StatsModels.StatsBase.fit(T, f, DataFrames.DataFrame(d), args...; contrasts = contrasts, kwargs...)
+    StatsModels.StatsBase.fit(T, f, DataFrames.DataFrame(d), args...; contrasts=contrasts, kwargs...)
 end

src/integrations/temporal.jl

@@ -1,14 +1,14 @@
-struct TSIterator{T, S}
+struct TSIterator{T,S}
     source::S
 end
 
 IteratorInterfaceExtensions.isiterable(x::Temporal.TS) = true
 TableTraits.isiterabletable(x::Temporal.TS) = true
 
-function IteratorInterfaceExtensions.getiterator(ta::S) where {S<:Temporal.TS}
+function IteratorInterfaceExtensions.getiterator(ta::S) where {S <: Temporal.TS}
     etype = eltype(ta.values)
 
-    T = NamedTuple{(:Index, ta.fields...), Tuple{eltype(ta.index), fill(etype, length(ta.fields))...}}
+    T = NamedTuple{(:Index, ta.fields...),Tuple{eltype(ta.index),fill(etype, length(ta.fields))...}}
 
     return TSIterator{T,S}(ta)
 end
@@ -31,17 +31,17 @@ Base.eltype(::Type{TSIterator{T,TS}}) where {T,TS} = T
     # Add timestamp column
     push!(constructor_call.args[2].args, :(iter.source.index[i]))
 
-    for i in 1:fieldcount(T)-1
+    for i in 1:fieldcount(T) - 1
         push!(constructor_call.args[2].args, :(iter.source.values[i,$i]))
     end
 
     quote
-        if state>length(iter.source.index)
+        if state > length(iter.source.index)
             return nothing
         else
             i = state
             a = $constructor_call
-            return a, state+1
+            return a, state + 1
         end
     end
 end
@@ -55,23 +55,23 @@ function Temporal.TS(x; index_column::Symbol=:Index)
 
     et = eltype(iter)
 
-    if fieldcount(et)<2
+    if fieldcount(et) < 2
         error("Need at least two columns")
     end
 
     names = fieldnames(et)
 
     timestep_col_index = findfirst(isequal(index_column), names)
 
-    if timestep_col_index===nothing
+    if timestep_col_index === nothing
         error("No timestamp column found.")
     end
 
     timestep_col_index = something(timestep_col_index)
 
-    col_types = [fieldtype(et, i) for i=1:fieldcount(et)]
+    col_types = [fieldtype(et, i) for i = 1:fieldcount(et)]
 
-    data_columns = collect(Iterators.filter(i->i[2][1]!=index_column, enumerate(zip(names, col_types))))
+    data_columns = collect(Iterators.filter(i -> i[2][1] != index_column, enumerate(zip(names, col_types))))
 
     orig_data_type = data_columns[1][2][2]
 
@@ -81,14 +81,14 @@ function Temporal.TS(x; index_column::Symbol=:Index)
 
     timestep_type = orig_timestep_type <: DataValues.DataValue ? orig_timestep_type.parameters[1] : orig_timestep_type
 
-    if any(i->i[2][2]!=orig_data_type, data_columns)
+    if any(i -> i[2][2] != orig_data_type, data_columns)
         error("All data columns need to be of the same type.")
     end
 
-    t_column = Vector{timestep_type}(undef,0)
-    d_array = Vector{Vector{data_type}}(undef,0)
+    t_column = Vector{timestep_type}(undef, 0)
+    d_array = Vector{Vector{data_type}}(undef, 0)
     for i in data_columns
-        push!(d_array, Vector{data_type}(undef,0))
+        push!(d_array, Vector{data_type}(undef, 0))
     end
 
     for v in iter
@@ -99,18 +99,18 @@ function Temporal.TS(x; index_column::Symbol=:Index)
         end
 
         if orig_data_type <: DataValue
-            for (i,c) in enumerate(data_columns)
-                push!(d_array[i],get(v[c[1]]))
+            for (i, c) in enumerate(data_columns)
+                push!(d_array[i], get(v[c[1]]))
             end
         else
-            for (i,c) in enumerate(data_columns)
-                push!(d_array[i],v[c[1]])
+            for (i, c) in enumerate(data_columns)
+                push!(d_array[i], v[c[1]])
             end
         end
     end
 
     d_array = hcat(d_array...)
 
-    ta = Temporal.TS(d_array, t_column,[i[2][1] for i in data_columns])
+    ta = Temporal.TS(d_array, t_column, [i[2][1] for i in data_columns])
     return ta
 end

src/integrations/timeseries.jl

@@ -1,16 +1,16 @@
-struct TimeArrayIterator{T, S}
+struct TimeArrayIterator{T,S}
     source::S
 end
 
 IteratorInterfaceExtensions.isiterable(x::TimeSeries.TimeArray) = true
 TableTraits.isiterabletable(x::TimeSeries.TimeArray) = true
 
-function IteratorInterfaceExtensions.getiterator(ta::S) where {S<:TimeSeries.TimeArray}
+function IteratorInterfaceExtensions.getiterator(ta::S) where {S <: TimeSeries.TimeArray}
     etype = eltype(TimeSeries.values(ta))
 
-    T = NamedTuple{(:timestamp, Symbol.(TimeSeries.colnames(ta))...), Tuple{S.parameters[3], fill(etype, length(TimeSeries.colnames(ta)))...}}
+    T = NamedTuple{(:timestamp, Symbol.(TimeSeries.colnames(ta))...),Tuple{S.parameters[3],fill(etype, length(TimeSeries.colnames(ta)))...}}
 
-    return TimeArrayIterator{T, S}(ta)
+    return TimeArrayIterator{T,S}(ta)
 end
 
 function Base.length(iter::TimeArrayIterator)
@@ -31,17 +31,17 @@ Base.eltype(::Type{TimeArrayIterator{T,TS}}) where {T,TS} = T
     # Add timestamp column
     push!(constructor_call.args[2].args, :(TimeSeries.timestamp(iter.source)[i]))
 
-    for i in 1:fieldcount(T)-1
+    for i in 1:fieldcount(T) - 1
         push!(constructor_call.args[2].args, :(TimeSeries.values(iter.source)[i,$i]))
     end
 
     quote
-        if state>length(TimeSeries.timestamp(iter.source))
+        if state > length(TimeSeries.timestamp(iter.source))
             return nothing
         else
             i = state
             a = $constructor_call
-            return a, state+1
+            return a, state + 1
         end
     end
 end
@@ -55,23 +55,23 @@ function TimeSeries.TimeArray(x; timestamp_column::Symbol=:timestamp)
 
     et = eltype(iter)
 
-    if fieldcount(et)<2
+    if fieldcount(et) < 2
         error("Need at least two columns")
     end
 
     names = fieldnames(et)
 
     timestep_col_index = findfirst(isequal(timestamp_column), names)
 
-    if timestep_col_index===nothing
+    if timestep_col_index === nothing
         error("No timestamp column found.")
     end
 
     timestep_col_index = something(timestep_col_index)
 
-    col_types = [fieldtype(et, i) for i=1:fieldcount(et)]
+    col_types = [fieldtype(et, i) for i = 1:fieldcount(et)]
 
-    data_columns = collect(Iterators.filter(i->i[2][1]!=timestamp_column, enumerate(zip(names, col_types))))
+    data_columns = collect(Iterators.filter(i -> i[2][1] != timestamp_column, enumerate(zip(names, col_types))))
 
     orig_data_type = data_columns[1][2][2]
 
@@ -81,14 +81,14 @@ function TimeSeries.TimeArray(x; timestamp_column::Symbol=:timestamp)
 
     timestep_type = orig_timestep_type <: DataValues.DataValue ? orig_timestep_type.parameters[1] : orig_timestep_type
 
-    if any(i->i[2][2]!=orig_data_type, data_columns)
+    if any(i -> i[2][2] != orig_data_type, data_columns)
         error("All data columns need to be of the same type.")
     end
 
-    t_column = Vector{timestep_type}(undef,0)
-    d_array = Vector{Vector{data_type}}(undef,0)
+    t_column = Vector{timestep_type}(undef, 0)
+    d_array = Vector{Vector{data_type}}(undef, 0)
     for i in data_columns
-        push!(d_array, Vector{data_type}(undef,0))
+        push!(d_array, Vector{data_type}(undef, 0))
     end
 
     for v in iter
@@ -99,18 +99,18 @@ function TimeSeries.TimeArray(x; timestamp_column::Symbol=:timestamp)
         end
 
         if orig_data_type <: DataValue
-            for (i,c) in enumerate(data_columns)
-                push!(d_array[i],get(v[c[1]]))
+            for (i, c) in enumerate(data_columns)
+                push!(d_array[i], get(v[c[1]]))
             end
         else
-            for (i,c) in enumerate(data_columns)
-                push!(d_array[i],v[c[1]])
+            for (i, c) in enumerate(data_columns)
+                push!(d_array[i], v[c[1]])
             end
         end
     end
 
     d_array = hcat(d_array...)
 
-    ta = TimeSeries.TimeArray(t_column,d_array,[i[2][1] for i in data_columns])
+    ta = TimeSeries.TimeArray(t_column, d_array, [i[2][1] for i in data_columns])
     return ta
 end

test/runtests.jl

@@ -5,10 +5,10 @@ end
 
 @testset "IterableTables" begin
 
-include("test_integration_dataframes.jl")
-include("test_integration_statsmodels.jl")
-include("test_integration_timeseries.jl")
-include("test_integration_temporal.jl")
+    include("test_integration_dataframes.jl")
+    include("test_integration_statsmodels.jl")
+    include("test_integration_timeseries.jl")
+    include("test_integration_temporal.jl")
 # include("test_integration_juliadb.jl")
 # include("test_integration_gadfly.jl")