Refactor StdNames (#184)

* Refactor 'StdNames' transform

* Fix tests

* Add more tests

Author: eliascarv

src/transforms/stdnames.jl

@@ -2,23 +2,33 @@
 # Licensed under the MIT License. See LICENSE in the project root.
 # ------------------------------------------------------------------
 
+const SPECS = [:uppersnake, :uppercamel, :upperflat, :snake, :camel, :flat]
+
 """
-    StdNames(spec)
+    StdNames(spec = :uppersnake)
 
 Standardizes column names according to given `spec`.
-Default to `:upper` case specification.
+Default to `:uppersnake` case specification.
 
 # Specs
 
-* `:upper` - Uppercase, e.g. COLUMNNAME
-* `:camel` - Camelcase, e.g. ColumnName
-* `:snake` - Snakecase, e.g. column_name
+* `:uppersnake` - Upper Snake Case, e.g. COLUMN_NAME
+* `:uppercamel` - Upper Camel Case, e.g. ColumnName
+* `:upperflat` - Upper Flat Case, e.g. COLUMNNAME
+* `:snake` - Snake Case, e.g. column_name
+* `:camel` - Camel Case, e.g. columnName
+* `:flat` - Flat Case, e.g. columnname
 """
 struct StdNames <: StatelessFeatureTransform
   spec::Symbol
-end
 
-StdNames() = StdNames(:upper)
+  function StdNames(spec = :uppersnake)
+    if spec ∉ SPECS
+      throw(ArgumentError("invalid specification, use one of these: $SPECS"))
+    end
+    new(spec)
+  end
+end
 
 isrevertible(::Type{StdNames}) = true
 
@@ -28,18 +38,21 @@ function applyfeat(transform::StdNames, feat, prep)
 
   # retrieve column names
   cols = Tables.columns(feat)
-  oldnames = string.(Tables.columnnames(cols))
+  oldnames = Tables.columnnames(cols)
 
   # clean column names
-  cleaned = _clean.(oldnames)
+  names = map(nm -> _clean(string(nm)), oldnames)
 
   # apply spec
-  spec == :camel && (names = _camel.(cleaned))
-  spec == :snake && (names = _snake.(cleaned))
-  spec == :upper && (names = _upper.(cleaned))
+  spec === :uppersnake && (names = _uppersnake.(names))
+  spec === :uppercamel && (names = _uppercamel.(names))
+  spec === :upperflat && (names = _upperflat.(names))
+  spec === :snake && (names = _snake.(names))
+  spec === :camel && (names = _camel.(names))
+  spec === :flat && (names = _flat.(names))
 
   # make names unique
-  newnames = _unique(names)
+  newnames = _makeunique(names)
 
   # rename transform
   rtrans = Rename(colspec(oldnames), Symbol.(newnames))
@@ -53,25 +66,43 @@ function revertfeat(::StdNames, newfeat, fcache)
   revertfeat(rtrans, newfeat, rfcache)
 end
 
-const delim = [' ', '\t', '-', '_']
+const DELIMS = [' ', '\t', '-', '_']
 
-_clean(name) = filter(c -> isdigit(c) || isletter(c) || c ∈ delim, name)
+function _clean(name)
+  nm = strip(name, DELIMS)
+  filter(c -> isdigit(c) || isletter(c) || c ∈ DELIMS, nm)
+end
 
-function _unique(names)
+function _makeunique(names)
   newnames = String[]
   for name in names
-    n = name
-    while n ∈ newnames
-      n = string(n, "_")
+    while name ∈ newnames
+      name = name * "_"
     end
-    push!(newnames, n)
+    push!(newnames, name)
   end
-
   newnames
 end
 
-_camel(name) = join(uppercasefirst.(split(name, delim)))
+_uppersnake(name) = _isuppersnake(name) ? name : join(uppercase.(split(name, DELIMS)), '_')
+
+_uppercamel(name) = _isuppercamel(name) ? name : join(uppercasefirst.(split(name, DELIMS)))
+
+_upperflat(name) = _isupperflat(name) ? name : replace(uppercase(name), DELIMS => "")
+
+_snake(name) = _issnake(name) ? name : join(lowercase.(split(name, DELIMS)), '_')
+
+function _camel(name)
+  _iscamel(name) && return name
+  first, others... = split(name, DELIMS)
+  join([lowercase(first); uppercasefirst.(others)])
+end
 
-_snake(name) = join(lowercase.(split(strip(name, delim), delim)), '_')
+_flat(name) = _isflat(name) ? name : replace(lowercase(name), DELIMS => "")
 
-_upper(name) = replace(uppercase(name), delim => "")
+_isuppersnake(name) = occursin(r"^[A-Z0-9]+(_[A-Z0-9]+)+$", name)
+_isuppercamel(name) = occursin(r"^[A-Z][a-z0-9]*([A-Z][a-z0-9]*)+$", name)
+_isupperflat(name) = occursin(r"^[A-Z0-9]+$", name)
+_issnake(name) = occursin(r"^[a-z0-9]+(_[a-z0-9]+)+$", name)
+_iscamel(name) = occursin(r"^[a-z][a-z0-9]*([A-Z][a-z0-9]*)+$", name)
+_isflat(name) = occursin(r"^[a-z0-9]+$", name)

test/shows.jl

@@ -58,17 +58,17 @@
   end
 
   @testset "StdNames" begin
-    T = StdNames(:upper)
+    T = StdNames(:upperflat)
 
     # compact mode
     iostr = sprint(show, T)
-    @test iostr == "StdNames(:upper)"
+    @test iostr == "StdNames(:upperflat)"
 
     # full mode
     iostr = sprint(show, MIME("text/plain"), T)
     @test iostr == """
     StdNames transform
-    └─ spec = :upper"""
+    └─ spec = :upperflat"""
   end
 
   @testset "Sort" begin

test/transforms/stdnames.jl

@@ -1,16 +1,62 @@
 @testset "StdNames" begin
+  names = Symbol.(["_apple tree_", " banana-fruit ", "-pear\tseed-"])
+  columns = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
+  t = Table(; zip(names, columns)...)
+  T = StdNames(:uppersnake)
+  n, c = apply(T, t)
+  @test Tables.schema(n).names == (:APPLE_TREE, :BANANA_FRUIT, :PEAR_SEED)
+  tₒ = revert(T, n, c)
+  @test t == tₒ
+
+  T = StdNames(:uppercamel)
+  n, c = apply(T, t)
+  @test Tables.schema(n).names == (:AppleTree, :BananaFruit, :PearSeed)
+  tₒ = revert(T, n, c)
+  @test t == tₒ
+
+  T = StdNames(:upperflat)
+  n, c = apply(T, t)
+  @test Tables.schema(n).names == (:APPLETREE, :BANANAFRUIT, :PEARSEED)
+  tₒ = revert(T, n, c)
+  @test t == tₒ
+
+  T = StdNames(:snake)
+  n, c = apply(T, t)
+  @test Tables.schema(n).names == (:apple_tree, :banana_fruit, :pear_seed)
+  tₒ = revert(T, n, c)
+  @test t == tₒ
+
+  T = StdNames(:camel)
+  n, c = apply(T, t)
+  @test Tables.schema(n).names == (:appleTree, :bananaFruit, :pearSeed)
+  tₒ = revert(T, n, c)
+  @test t == tₒ
+
+  T = StdNames(:flat)
+  n, c = apply(T, t)
+  @test Tables.schema(n).names == (:appletree, :bananafruit, :pearseed)
+  tₒ = revert(T, n, c)
+  @test t == tₒ
+
+  # internal functions
   names = ["apple banana", "apple\tbanana", "apple_banana", "apple-banana", "apple_Banana"]
   for name in names
-    @test TT._camel(name) == "AppleBanana"
+    @test TT._uppersnake(name) == "APPLE_BANANA"
+    @test TT._uppercamel(name) == "AppleBanana"
+    @test TT._upperflat(name) == "APPLEBANANA"
     @test TT._snake(name) == "apple_banana"
-    @test TT._upper(name) == "APPLEBANANA"
+    @test TT._camel(name) == "appleBanana"
+    @test TT._flat(name) == "applebanana"
   end
 
   names = ["a", "A", "_a", "_A", "a ", "A "]
   for name in names
-    @test TT._camel(name) == "A"
-    @test TT._snake(name) == "a"
-    @test TT._upper(name) == "A"
+    @test TT._uppersnake(TT._clean(name)) == "A"
+    @test TT._uppercamel(TT._clean(name)) == "A"
+    @test TT._upperflat(TT._clean(name)) == "A"
+    @test TT._snake(TT._clean(name)) == "a"
+    @test TT._camel(TT._clean(name)) == "a"
+    @test TT._flat(TT._clean(name)) == "a"
   end
 
   # special characters
@@ -24,36 +70,55 @@
   @test TT._clean(name) == "apple-tree"
 
   # invariance test
+  names = ["APPLE_TREE", "BANANA_FRUIT", "PEAR_SEED"]
+  for name in names
+    @test TT._isuppersnake(name)
+    @test TT._uppersnake(name) == name
+  end
+
   names = ["AppleTree", "BananaFruit", "PearSeed"]
   for name in names
-    @test TT._camel(name) == name
+    @test TT._isuppercamel(name)
+    @test TT._uppercamel(name) == name
+  end
+
+  names = ["APPLETREE", "BANANAFRUIT", "PEARSEED"]
+  for name in names
+    @test TT._isupperflat(name)
+    @test TT._upperflat(name) == name
   end
 
   names = ["apple_tree", "banana_fruit", "pear_seed"]
   for name in names
+    @test TT._issnake(name)
     @test TT._snake(name) == name
   end
 
-  names = ["APPLETREE", "BANANAFRUIT", "PEARSEED"]
+  names = ["appleTree", "bananaFruit", "pearSeed"]
   for name in names
-    @test TT._upper(name) == name
+    @test TT._iscamel(name)
+    @test TT._camel(name) == name
+  end
+
+  names = ["appletree", "bananafruit", "pearseed"]
+  for name in names
+    @test TT._isflat(name)
+    @test TT._flat(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)...)
+  columns = ([1, 2, 3], [4, 5, 6], [7, 8, 9])
+  t = Table(; zip(names, columns)...)
   rt = Tables.rowtable(t)
-  T = StdNames(:upper)
+  T = StdNames(:upperflat)
   n, c = apply(T, rt)
-  columns = Tables.columns(n)
-  columnnames = Tables.columnnames(columns)
-  @test columnnames == (:APPLETREE, :APPLETREE_, :APPLETREE__)
+  @test Tables.schema(n).names == (: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)...)
+  columns = ([1, 2, 3], [4, 5, 6], [7, 8, 9])
+  t = Table(; zip(names, columns)...)
   rt = Tables.rowtable(t)
   T = StdNames()
   n, c = apply(T, rt)
@@ -67,4 +132,7 @@
   n1, c1 = apply(T, rt)
   n2 = reapply(T, n1, c1)
   @test n1 == n2
+
+  # throws
+  @test_throws ArgumentError StdNames(:test)
 end