Add StdNames

docs/src/transforms/builtin.md

@@ -32,6 +32,12 @@ DropMissing
 Rename
 ```
 
+## StdNames
+
+```@docs
+StdNames
+```
+
 ## Replace
 
 ```@docs

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,77 @@
+# ------------------------------------------------------------------
+# Licensed under the MIT License. See LICENSE in the project root.
+# ------------------------------------------------------------------
+
+"""
+    StdNames(spec)
+
+Standardizes column names according to given `spec`.
+Default to `:upper` case specification.
+
+# Specs
+
+* `:upper` - Uppercase, e.g. COLUMNNAME
+* `:camel` - Camelcase, e.g. ColumnName
+* `:snake` - Snakecase, e.g. column_name
+"""
+struct StdNames <: Stateless
+  spec::Symbol
+end
+
+StdNames() = StdNames(:upper)
+
+isrevertible(::Type{StdNames}) = true
+
+function apply(transform::StdNames, table)  
+  # retrieve spec
+  spec = transform.spec
+
+  # retrieve column names
+  cols = Tables.columns(table)
+  oldnames = string.(Tables.columnnames(cols))
+
+  # clean column names
+  cleaned = _clean.(oldnames)
+
+  # apply spec
+  spec == :camel && (names = _camel.(cleaned))
+  spec == :snake && (names = _snake.(cleaned))
+  spec == :upper && (names = _upper.(cleaned))
+
+  # make names unique
+  newnames = _unique(names)
+
+  # rename transform
+  rtrans = Rename(Dict(oldnames .=> newnames))
+  newtable, rcache = apply(rtrans, table)
+
+  newtable, (rtrans, rcache)
+end
+
+function revert(::StdNames, newtable, cache)
+  rtrans, rcache = cache
+  revert(rtrans, newtable, rcache)
+end
+
+const delim = [' ', '\t', '-', '_']
+
+_clean(name) = filter(c -> isdigit(c) || isletter(c) || c ∈ delim, name)
+
+function _unique(names)
+  newnames = String[]
+  for name in names
+    n = name
+    while n ∈ newnames
+      n = string(n, "_")
+    end
+    push!(newnames, n)
+  end
+
+  newnames
+end
+
+_camel(name) = join(uppercasefirst.(split(name, delim)))
+
+_snake(name) = join(lowercase.(split(strip(name, delim), delim)), '_')
+
+_upper(name) = replace(uppercase(name), delim => "")

test/transforms.jl

@@ -694,6 +694,77 @@
     @test n1 == n2
   end
 
+  @testset "StdNames" begin
+    names = ["apple banana", "apple\tbanana", "apple_banana", "apple-banana", "apple_Banana"]
+    for name in names
+      @test TableTransforms._camel(name) == "AppleBanana"
+      @test TableTransforms._snake(name) == "apple_banana"
+      @test TableTransforms._upper(name) == "APPLEBANANA"
+    end
+
+    names = ["a", "A", "_a", "_A", "a ", "A "]
+    for name in names
+      @test TableTransforms._camel(name) == "A"
+      @test TableTransforms._snake(name) == "a"
+      @test TableTransforms._upper(name) == "A"
+    end
+
+    # special characters
+    name = "a&B"
+    @test TableTransforms._clean(name) == "aB"
+
+    name = "apple#"
+    @test TableTransforms._clean(name) == "apple"
+
+    name = "apple-tree"
+    @test TableTransforms._clean(name) == "apple-tree"
+
+    # invariance test
+    names = ["AppleTree", "BananaFruit", "PearSeed"]
+    for name in names
+      @test TableTransforms._camel(name) == name
+    end
+
+    names = ["apple_tree", "banana_fruit", "pear_seed"]
+    for name in names
+      @test TableTransforms._snake(name) == name
+    end
+
+    names = ["APPLETREE", "BANANAFRUIT", "PEARSEED"]
+    for name in names
+      @test TableTransforms._upper(name) == name
+    end
+
+    # uniqueness test
+    names = (Symbol("AppleTree"), Symbol("apple tree"), Symbol("apple_tree"))
+    cols = ([1,2,3], [4,5,6], [7,8,9])
+    t = Table(; zip(names, cols)...)
+    rt = Tables.rowtable(t)
+    T = StdNames(:upper)
+    n, c = apply(T, rt)
+    columns = Tables.columns(n)
+    columnnames = Tables.columnnames(columns)
+    @test columnnames == (:APPLETREE, :APPLETREE_, :APPLETREE__)
+
+    # row table test
+    names = (:a, Symbol("apple tree"), Symbol("banana tree"))
+    cols = ([1,2,3], [4,5,6], [7,8,9])
+    t = Table(; zip(names, cols)...)
+    rt = Tables.rowtable(t)
+    T = StdNames()
+    n, c = apply(T, rt)
+    @test Tables.isrowtable(n)
+    @test isrevertible(T)
+    rtₒ = revert(T, n, c)
+    @test rt == rtₒ
+
+    # reapply test
+    T = StdNames()
+    n1, c1 = apply(T, rt)
+    n2 = reapply(T, n1, c1)
+    @test n1 == n2
+  end
+
   @testset "Replace" begin
     a = [3, 2, 1, 4, 5, 3]
     b = [2, 4, 4, 5, 8, 5]