🤖 Format .jl files

Author: juliohm

docs/make.jl

@@ -3,8 +3,11 @@ using DocumenterTools: Themes
 
 using TransformsBase
 
-Themes.compile(joinpath(@__DIR__,"src/assets/light.scss"), joinpath(@__DIR__,"src/assets/themes/documenter-light.css"))
-Themes.compile(joinpath(@__DIR__,"src/assets/dark.scss"), joinpath(@__DIR__,"src/assets/themes/documenter-dark.css"))
+Themes.compile(
+  joinpath(@__DIR__, "src/assets/light.scss"),
+  joinpath(@__DIR__, "src/assets/themes/documenter-light.css")
+)
+Themes.compile(joinpath(@__DIR__, "src/assets/dark.scss"), joinpath(@__DIR__, "src/assets/themes/documenter-dark.css"))
 
 DocMeta.setdocmeta!(TableTransforms, :DocTestSetup, :(using TableTransforms); recursive=true)
 
@@ -19,17 +22,12 @@ makedocs(;
   format=Documenter.HTML(;
     prettyurls=get(ENV, "CI", "false") == "true",
     canonical="https://JuliaML.github.io/TableTransforms.jl",
-    assets=["assets/favicon.ico", asset("https://fonts.googleapis.com/css?family=Montserrat|Source+Code+Pro&display=swap", class=:css)]
+    assets=[
+      "assets/favicon.ico",
+      asset("https://fonts.googleapis.com/css?family=Montserrat|Source+Code+Pro&display=swap", class=:css)
+    ]
   ),
-  pages=[
-    "Home" => "index.md",
-    "Transforms" => "transforms.md",
-    "Related" => "related.md"
-  ]
+  pages=["Home" => "index.md", "Transforms" => "transforms.md", "Related" => "related.md"]
 )
 
-deploydocs(;
-  repo="github.com/JuliaML/TableTransforms.jl",
-  devbranch="master",
-  push_preview=true
-)
+deploydocs(; repo="github.com/JuliaML/TableTransforms.jl", devbranch="master", push_preview=true)

src/TableTransforms.jl

@@ -67,9 +67,12 @@ export
   Quantile,
   Functional,
   EigenAnalysis,
-  PCA, DRS, SDS,
+  PCA,
+  DRS,
+  SDS,
   ProjectionPursuit,
   RowTable,
   ColTable,
-  →, ⊔
+  →,
+  ⊔
 end

src/assertions.jl

@@ -11,8 +11,7 @@ struct SciTypeAssertion{T,S<:ColSpec}
   colspec::S
 end
 
-SciTypeAssertion{T}(colspec::S) where {T,S<:ColSpec} = 
-  SciTypeAssertion{T,S}(colspec)
+SciTypeAssertion{T}(colspec::S) where {T,S<:ColSpec} = SciTypeAssertion{T,S}(colspec)
 
 SciTypeAssertion{T}() where {T} = SciTypeAssertion{T}(AllSpec())
 

src/distributions.jl

@@ -48,4 +48,4 @@ function cdf(d::EmpiricalDistribution{T}, x::T) where {T<:Real}
       return (pu - pl) * (x - l) / (u - l) + pl
     end
   end
-end
+end

src/tableselection.jl

@@ -20,17 +20,14 @@ struct TableSelection{T,C}
 end
 
 function Base.:(==)(a::TableSelection, b::TableSelection)
-  a.names  != b.names  && return false
+  a.names != b.names && return false
   a.onames != b.onames && return false
   all(nm -> Tables.getcolumn(a, nm) == Tables.getcolumn(b, nm), a.names)
 end
 
 function Base.show(io::IO, t::TableSelection)
   println(io, "TableSelection")
-  pretty_table(io, t,
-    vcrop_mode=:middle,
-    newline_at_end=false
-  )
+  pretty_table(io, t, vcrop_mode=:middle, newline_at_end=false)
 end
 
 # Tables.jl interface
@@ -49,13 +46,12 @@ function Tables.getcolumn(t::TableSelection, nm::Symbol)
   Tables.getcolumn(t.cols, t.mapnames[nm])
 end
 
-Tables.materializer(t::TableSelection) =
-  Tables.materializer(t.table)
+Tables.materializer(t::TableSelection) = Tables.materializer(t.table)
 
 function Tables.schema(t::TableSelection)
   schema = Tables.schema(t.cols)
-  names  = schema.names
-  types  = schema.types
-  inds   = indexin(t.onames, collect(names))
+  names = schema.names
+  types = schema.types
+  inds = indexin(t.onames, collect(names))
   Tables.Schema(t.names, types[inds])
 end

src/tabletraits.jl

@@ -16,4 +16,4 @@ divide(table) = table, nothing
 Combine a table with `features` and a `metadata`
 object into a special type of `table`.
 """
-attach(features, ::Nothing) = features
+attach(features, ::Nothing) = features

src/transforms.jl

@@ -150,7 +150,7 @@ function revert(transform::FeatureTransform, newtable, cache)
   @assert isrevertible(transform) "Transform is not revertible"
 
   newfeat, newmeta = divide(newtable)
-  fcache,   mcache = cache
+  fcache, mcache = cache
 
   feat = revertfeat(transform, newfeat, fcache)
   meta = revertmeta(transform, newmeta, mcache)
@@ -159,7 +159,7 @@ function revert(transform::FeatureTransform, newtable, cache)
 end
 
 function reapply(transform::FeatureTransform, table, cache)
-  feat,     meta = divide(table)
+  feat, meta = divide(table)
   fcache, mcache = cache
 
   for assertion in assertions(transform)
@@ -180,22 +180,20 @@ reapplymeta(::FeatureTransform, meta, mcache) = meta
 # STATELESS FALLBACKS
 # --------------------
 
-reapply(transform::StatelessTableTransform, table, cache) =
-  apply(transform, table) |> first
+reapply(transform::StatelessTableTransform, table, cache) = apply(transform, table) |> first
 
-reapply(transform::StatelessFeatureTransform, table, cache) =
-  apply(transform, table) |> first
+reapply(transform::StatelessFeatureTransform, table, cache) = apply(transform, table) |> first
 
 # ------------------
 # COLWISE FALLBACKS
 # ------------------
 
 function applyfeat(transform::ColwiseFeatureTransform, feat, prep)
   # retrieve column names and values
-  cols   = Tables.columns(feat)
-  names  = Tables.columnnames(cols)
+  cols = Tables.columns(feat)
+  names = Tables.columnnames(cols)
   snames = choose(transform.colspec, names)
-  
+
   # function to transform a single column
   function colfunc(n)
     x = Tables.getcolumn(cols, n)
@@ -225,11 +223,11 @@ end
 
 function revertfeat(transform::ColwiseFeatureTransform, newfeat, fcache)
   # transformed columns
-  cols  = Tables.columns(newfeat)
+  cols = Tables.columns(newfeat)
   names = Tables.columnnames(cols)
-  
+
   caches, snames = fcache
-  
+
   # function to transform a single column
   function colfunc(i)
     n = names[i]
@@ -248,11 +246,11 @@ end
 
 function reapplyfeat(transform::ColwiseFeatureTransform, feat, fcache)
   # retrieve column names and values
-  cols  = Tables.columns(feat)
+  cols = Tables.columns(feat)
   names = Tables.columnnames(cols)
 
   caches, snames = fcache
-  
+
   # check that cache is valid
   @assert length(names) == length(caches) "invalid caches for feat"
 
@@ -296,4 +294,4 @@ include("transforms/eigenanalysis.jl")
 include("transforms/projectionpursuit.jl")
 include("transforms/rowtable.jl")
 include("transforms/coltable.jl")
-include("transforms/parallel.jl")
+include("transforms/parallel.jl")

src/transforms/center.jl

@@ -33,15 +33,14 @@ end
 
 Center() = Center(AllSpec())
 Center(spec) = Center(colspec(spec))
-Center(cols::C...) where {C<:Col} = 
-  Center(colspec(cols))
+Center(cols::C...) where {C<:Col} = Center(colspec(cols))
 
 assertions(transform::Center) = [SciTypeAssertion{Continuous}(transform.colspec)]
 
 isrevertible(::Type{<:Center}) = true
 
 colcache(::Center, x) = mean(x)
 
-colapply(::Center, x, μ)  = @. x - μ
+colapply(::Center, x, μ) = @. x - μ
 
 colrevert(::Center, y, μ) = @. y + μ

src/transforms/coalesce.jl

@@ -40,8 +40,7 @@ end
 
 Coalesce(; value) = Coalesce(AllSpec(), value)
 Coalesce(spec; value) = Coalesce(colspec(spec), value)
-Coalesce(cols::C...; value) where {C<:Col} = 
-  Coalesce(colspec(cols), value)
+Coalesce(cols::C...; value) where {C<:Col} = Coalesce(colspec(cols), value)
 
 isrevertible(::Type{<:Coalesce}) = true
 

src/transforms/coerce.jl

@@ -22,30 +22,27 @@ struct Coerce{P} <: FeatureTransform
   verbosity::Int
 end
 
-Coerce(pair::Pair{Symbol,<:Type}...; tight=false, verbosity=1) = 
-  Coerce(pair, tight, verbosity)
+Coerce(pair::Pair{Symbol,<:Type}...; tight=false, verbosity=1) = Coerce(pair, tight, verbosity)
 
 isrevertible(::Type{<:Coerce}) = true
 
 function applyfeat(transform::Coerce, feat, prep)
-  newtable = coerce(feat, transform.pairs...;
-                    tight=transform.tight,
-                    verbosity=transform.verbosity)
+  newtable = coerce(feat, transform.pairs...; tight=transform.tight, verbosity=transform.verbosity)
 
   types = Tables.schema(feat).types
-  
+
   newtable, types
 end
 
 function revertfeat(::Coerce, newfeat, fcache)
   cols = Tables.columns(newfeat)
   names = Tables.columnnames(cols)
-  
+
   oldcols = map(zip(fcache, names)) do (T, n)
     x = Tables.getcolumn(cols, n)
     collect(T, x)
   end
-    
+
   𝒯 = (; zip(names, oldcols)...)
   𝒯 |> Tables.materializer(newfeat)
 end