Add StdNames

src/TableTransforms.jl

@@ -31,6 +31,7 @@ export
   Filter,
   DropMissing,
   Rename,
+  StdNames,
   Replace,
   Coalesce,
   Coerce,

src/transforms.jl

@@ -214,6 +214,7 @@ end
 include("transforms/select.jl")
 include("transforms/filter.jl")
 include("transforms/rename.jl")
+include("transforms/stdnames.jl")
 include("transforms/replace.jl")
 include("transforms/coalesce.jl")
 include("transforms/coerce.jl")

src/transforms/stdnames.jl

@@ -0,0 +1,59 @@
+# ------------------------------------------------------------------
+# Licensed under the MIT License. See LICENSE in the project root.
+# ------------------------------------------------------------------
+
+"""
+    StdNames(S)
+
+StdNames transform standardizes the column names.
+"""
+struct StdNames <: Stateless
+    stdmethod::Symbol
+end
+
+isrevertible(::Type{StdNames}) = true
+
+function apply(transform::StdNames, table)    
+    if transform.stdmethod == :camel
+        _camel(table)
+    elseif transform.stdmethod == :snake
+        _snake(table)
+    else
+        _upper(table)
+    end
+end
+
+function revert(::StdNames, newtable, cache)
+    names = Tables.columnnames(newtable)
+    namesdict = Dict(zip(names, cache))
+    newtable |> Rename(namesdict)
+end
+
+function _camel(table)
+    oldnames = Tables.columnnames(table)
+    function camelfunction(x)
+        substrings = split(string(x))
+        capitalize(s) = String([i == 1 ? uppercase(c) : c for (i, c) in enumerate(s)])
+        Symbol(join(map(capitalize, substrings)))
+    end
+
+    newnames = map(camelfunction, oldnames)
+    namesdict = Dict(zip(oldnames, newnames))
+    table |> Rename(namesdict), oldnames
+end
+
+function _snake(table)
+    oldnames = Tables.columnnames(table)
+    snakefunction(x) = Symbol(join(split(string(x)), "_"))
+    newnames = map(snakefunction, oldnames)
+    namesdict = Dict(zip(oldnames, newnames))
+    table |> Rename(namesdict), oldnames
+end
+
+function _upper(table)
+    oldnames = Tables.columnnames(table)
+    upperfunction(x) = Symbol(uppercase(string(x)))    
+    newnames = map(upperfunction, oldnames)
+    namesdict = Dict(zip(oldnames, newnames))
+    table |> Rename(namesdict), oldnames
+end

test/transforms.jl

@@ -680,6 +680,34 @@
     @test n1 == n2
   end
 
+  @testset "StdNames" begin
+    a = [3, 2, 1, 4, 5, 3]
+    b = [2, 4, 4, 5, 8, 5]
+    t = Table(; a, b)
+    t = t |> Rename(:a => "apple tree", :b => "banana tree")
+
+    # upper test
+    T = StdNames(:upper)
+    n, c = apply(T, t)
+    tₒ = revert(T, n, c)
+    @test Tables.columnnames(n) == (Symbol("APPLE TREE"), Symbol("BANANA TREE"))
+    @test t == tₒ
+
+    # camel test
+    T = StdNames(:camel)
+    n, c = apply(T, t)
+    tₒ = revert(T, n, c)
+    @test Tables.columnnames(n) == (:AppleTree, :BananaTree)
+    @test t == tₒ
+
+    # snake test
+    T = StdNames(:snake)
+    n, c = apply(T, t)
+    tₒ = revert(T, n, c)
+    @test Tables.columnnames(n) == (:apple_tree, :banana_tree)
+    @test t == tₒ
+  end
+
   @testset "Replace" begin
     a = [3, 2, 1, 4, 5, 3]
     b = [2, 4, 4, 5, 8, 5]