Add the colspec(col::Col) method & Update ColSpec interface error messages (#189)

* Add the 'colspec(col::Col)' method & Update 'ColSpec' interface error messages

* Update docstring

* Update docstring

* Fix tests

Author: eliascarv

src/colspec.jl

@@ -61,6 +61,11 @@ abstract type ColSpec end
 
 Converts the `spec` argument to a `ColSpec` object.
 
+    colspec(col::Col)
+
+Converts the `col` to a single column selection,
+this is equivalent to calling `colspec([col])`.
+
 # Examples
 
 ```julia
@@ -75,13 +80,18 @@ colspec(:) # AllSpec
 colspec(nothing) # NoneSpec
 # if the argument is a ColSpec, return it
 colspec(NoneSpec()) # NoneSpec
+# single column selection
+colspec(:a) # NameSpec
+colspec("a") # NameSpec
+colspec(1) # IndexSpec
 ```
 """
 colspec(spec::ColSpec) = spec
+colspec(col::Col) = colspec([col])
 
 # argument errors
-colspec(::Tuple{}) = throw(ArgumentError("Invalid column spec."))
-colspec(::Any) = throw(ArgumentError("Invalid column spec."))
+colspec(::Any) = throw(ArgumentError("invalid column selection"))
+colspec(::Tuple{}) = throw(ArgumentError("column selection cannot be empty"))
 
 """
     choose(colspec::ColSpec, names) -> Vector{Symbol}
@@ -130,7 +140,9 @@ function choose end
 struct NameSpec <: ColSpec
   names::Vector{Symbol}
   function NameSpec(names)
-    @assert !isempty(names) "Invalid column selection."
+    if isempty(names)
+      throw(ArgumentError("column selection cannot be empty"))
+    end
     new(names)
   end
 end
@@ -148,7 +160,9 @@ choose(colspec::NameSpec, names) = _choose(colspec.names, names)
 struct IndexSpec <: ColSpec
   inds::Vector{Int}
   function IndexSpec(inds)
-    @assert !isempty(inds) "Invalid column selection."
+    if isempty(inds)
+      throw(ArgumentError("column selection cannot be empty"))
+    end
     new(inds)
   end
 end
@@ -174,7 +188,7 @@ choose(colspec::RegexSpec, names::Tuple) = choose(colspec, collect(names))
 function choose(colspec::RegexSpec, names::Vector)
   regex = colspec.regex
   snames = filter(nm -> occursin(regex, String(nm)), names)
-  @assert !isempty(snames) "Invalid column selection."
+  @assert !isempty(snames) "regex doesn't match any names in input table"
   _choose(snames, names)
 end
 
@@ -200,6 +214,6 @@ choose(::NoneSpec, names) = Symbol[]
 # helper functions
 function _choose(snames::Vector{Symbol}, names)
   # validate columns
-  @assert snames ⊆ names "Invalid column selection."
+  @assert snames ⊆ names "names not present in input table"
   return snames
 end

src/transforms/indicator.jl

@@ -31,7 +31,7 @@ struct Indicator{S<:ColSpec} <: StatelessFeatureTransform
   scale::Symbol
   categ::Bool
 
-  function Indicator(col, k, scale, categ)
+  function Indicator(col::Col, k, scale, categ)
     if k < 1
       throw(ArgumentError("`k` must be greater than or equal to 1"))
     end
@@ -40,7 +40,7 @@ struct Indicator{S<:ColSpec} <: StatelessFeatureTransform
       throw(ArgumentError("invalid `scale` option, use `:quantile` or `:linear`"))
     end
 
-    cs = colspec([col])
+    cs = colspec(col)
     new{typeof(cs)}(cs, k, scale, categ)
   end
 end

src/transforms/map.jl

@@ -43,16 +43,13 @@ const MapPair = Union{PairWithTarget,PairWithoutTarget}
 _extract(p::PairWithTarget) = first(p), first(last(p)), last(last(p))
 _extract(p::PairWithoutTarget) = first(p), last(p), nothing
 
-_colspec(spec) = colspec(spec)
-_colspec(col::Col) = colspec([col])
-
 _target(name) = name
 _target(name::AbstractString) = Symbol(name)
 
 function Map(pairs::MapPair...)
   tuples = map(pairs) do p
     spec, fun, name = _extract(p)
-    (_colspec(spec), fun, _target(name))
+    (colspec(spec), fun, _target(name))
   end
   colspecs = map(t -> t[1], tuples) |> collect
   funs = map(t -> t[2], tuples) |> collect

src/transforms/onehot.jl

@@ -22,8 +22,8 @@ OneHot("a", categ=true)
 struct OneHot{S<:ColSpec} <: StatelessFeatureTransform
   colspec::S
   categ::Bool
-  function OneHot(col, categ)
-    cs = colspec([col])
+  function OneHot(col::Col, categ)
+    cs = colspec(col)
     new{typeof(cs)}(cs, categ)
   end
 end

test/colspec.jl

@@ -65,15 +65,43 @@
   snames = TT.choose(colspec, tupnames)
   @test snames == Symbol[]
 
+  # single symbol
+  colspec = TT.colspec(:a)
+  snames = TT.choose(colspec, vecnames)
+  @test snames == [:a]
+  snames = TT.choose(colspec, tupnames)
+  @test snames == [:a]
+
+  # single string
+  colspec = TT.colspec("b")
+  snames = TT.choose(colspec, vecnames)
+  @test snames == [:b]
+  snames = TT.choose(colspec, tupnames)
+  @test snames == [:b]
+
+  # single integer
+  colspec = TT.colspec(3)
+  snames = TT.choose(colspec, vecnames)
+  @test snames == [:c]
+  snames = TT.choose(colspec, tupnames)
+  @test snames == [:c]
+
   # throws
+  # invalid colspec
+  @test_throws ArgumentError TT.colspec(missing)
+  # empty selection
+  @test_throws ArgumentError TT.colspec(Symbol[])
+  @test_throws ArgumentError TT.colspec(String[])
+  @test_throws ArgumentError TT.colspec(Int[])
+  @test_throws ArgumentError TT.colspec(())
+  # regex doesn't match any names in input table
   colspec = TT.colspec(r"x")
   @test_throws AssertionError TT.choose(colspec, vecnames)
   @test_throws AssertionError TT.choose(colspec, tupnames)
-  @test_throws AssertionError TT.colspec(Symbol[])
-  @test_throws AssertionError TT.colspec(String[])
-  @test_throws AssertionError TT.colspec(Int[])
-  @test_throws ArgumentError TT.colspec(())
-  @test_throws ArgumentError TT.colspec(missing)
+  # names not present in input table
+  colspec = TT.colspec([:x, :a])
+  @test_throws AssertionError TT.choose(colspec, vecnames)
+  @test_throws AssertionError TT.choose(colspec, tupnames)
 
   # type stability
   colspec = TT.colspec([:a, :b])
@@ -103,4 +131,13 @@
   colspec = TT.colspec(nothing)
   @inferred TT.choose(colspec, vecnames)
   @inferred TT.choose(colspec, tupnames)
+  colspec = TT.colspec(:a)
+  @inferred TT.choose(colspec, vecnames)
+  @inferred TT.choose(colspec, tupnames)
+  colspec = TT.colspec("b")
+  @inferred TT.choose(colspec, vecnames)
+  @inferred TT.choose(colspec, tupnames)
+  colspec = TT.colspec(3)
+  @inferred TT.choose(colspec, vecnames)
+  @inferred TT.choose(colspec, tupnames)
 end

test/transforms/filter.jl

@@ -397,13 +397,13 @@ end
   @test ntypes[6] == Missing
   @test ttypes == Tables.schema(tₒ).types
 
-  # throws: empty tuple
+  # throws: empty selection
   @test_throws ArgumentError DropMissing(())
+  @test_throws ArgumentError DropMissing(Symbol[])
+  @test_throws ArgumentError DropMissing(String[])
 
-  # throws: empty selection
+  # throws: regex doesn't match any names in input table
   @test_throws AssertionError apply(DropMissing(r"g"), t)
-  @test_throws AssertionError DropMissing(Symbol[])
-  @test_throws AssertionError DropMissing(String[])
 
   # throws: columns that do not exist in the original table
   @test_throws AssertionError apply(DropMissing(:g, :h), t)

test/transforms/select.jl

@@ -224,12 +224,14 @@
 
   # throws: Select without arguments
   @test_throws ArgumentError Select()
-  @test_throws ArgumentError Select(())
-
+  
   # throws: empty selection
+  @test_throws ArgumentError Select(())
+  @test_throws ArgumentError Select(Symbol[])
+  @test_throws ArgumentError Select(String[])
+  
+  # throws: regex doesn't match any names in input table
   @test_throws AssertionError apply(Select(r"a"), t)
-  @test_throws AssertionError Select(Symbol[])
-  @test_throws AssertionError Select(String[])
 
   # throws: columns that do not exist in the original table
   @test_throws AssertionError apply(Select(:x3, :y3), t)
@@ -372,19 +374,21 @@ end
 
   # throws: Reject without arguments
   @test_throws ArgumentError Reject()
+  
+  # throws: empty rejection
   @test_throws ArgumentError Reject(())
+  @test_throws ArgumentError Reject(Symbol[])
+  @test_throws ArgumentError Reject(String[])
 
-  # throws: empty rejection
+  # throws: regex doesn't match any names in input table
   @test_throws AssertionError apply(Reject(r"a"), t)
-  @test_throws AssertionError Reject(Symbol[])
-  @test_throws AssertionError Reject(String[])
 
   # throws: reject all columns
-  @test_throws AssertionError apply(Reject(r"[xy]"), t)
-  @test_throws AssertionError apply(Reject(:x1, :x2, :y1, :y2), t)
-  @test_throws AssertionError apply(Reject([:x1, :x2, :y1, :y2]), t)
-  @test_throws AssertionError apply(Reject((:x1, :x2, :y1, :y2)), t)
-  @test_throws AssertionError apply(Reject("x1", "x2", "y1", "y2"), t)
-  @test_throws AssertionError apply(Reject(["x1", "x2", "y1", "y2"]), t)
-  @test_throws AssertionError apply(Reject(["x1", "x2", "y1", "y2"]), t)
+  @test_throws ArgumentError apply(Reject(r"[xy]"), t)
+  @test_throws ArgumentError apply(Reject(:x1, :x2, :y1, :y2), t)
+  @test_throws ArgumentError apply(Reject([:x1, :x2, :y1, :y2]), t)
+  @test_throws ArgumentError apply(Reject((:x1, :x2, :y1, :y2)), t)
+  @test_throws ArgumentError apply(Reject("x1", "x2", "y1", "y2"), t)
+  @test_throws ArgumentError apply(Reject(["x1", "x2", "y1", "y2"]), t)
+  @test_throws ArgumentError apply(Reject(["x1", "x2", "y1", "y2"]), t)
 end

test/transforms/sort.jl

@@ -75,12 +75,14 @@
 
   # throws: Sort without arguments
   @test_throws ArgumentError Sort()
-  @test_throws ArgumentError Sort(())
 
   # throws: empty selection
+  @test_throws ArgumentError Sort(())
+  @test_throws ArgumentError Sort(Symbol[])
+  @test_throws ArgumentError Sort(String[])
+
+  # throws: regex doesn't match any names in input table
   @test_throws AssertionError apply(Sort(r"x"), t)
-  @test_throws AssertionError Sort(Symbol[])
-  @test_throws AssertionError Sort(String[])
 
   # throws: columns that do not exist in the original table
   @test_throws AssertionError apply(Sort([:d, :e]), t)