Improve csv reading when a semi-colon is part of the name and not a separator for the type

Author: jericks

src/main/groovy/geoscript/feature/Schema.groovy

@@ -469,7 +469,7 @@ class Schema {
      * @param alias The alias
      * @return The GeoTools binding class name
      */
-    static lookUpBinding(String alias) {
+    static String lookUpBinding(String alias) {
         Map map = [
             ("geoscript.geom.LinearRing".toLowerCase()) : "org.locationtech.jts.geom.LinearRing",
             ("LinearRing".toLowerCase()) : "org.locationtech.jts.geom.LinearRing",
@@ -508,6 +508,16 @@ class Schema {
         map.get(alias.toLowerCase(), alias)
     }
 
+    static boolean isValidFieldType(String type) {
+        boolean isValid = true
+        try {
+            Class.forName(Schema.lookUpBinding(type))
+        } catch(ClassNotFoundException ex) {
+            isValid = false
+        }
+        isValid
+    }
+
     /**
      * Build a SimpleFeatureType from the name and a List of Fields.
      * @param name The name

src/main/groovy/geoscript/layer/io/CsvReader.groovy

@@ -218,7 +218,14 @@ class CsvReader implements Reader {
                     name = parts[0]
                     type = parts[1]
                 }
-                new Field(name, type)
+                // Make sure the type is valid
+                if (Schema.isValidFieldType(type)) {
+                    new Field(name, type)
+                }
+                // Otherwise fall back
+                else {
+                    new Field("${name}:${type}", "String")
+                }
             }
             fields.add(new Field("geom", "Point"))
             Schema schema = new Schema(layerName, fields)
@@ -245,8 +252,8 @@ class CsvReader implements Reader {
                         def v = values[i]
                         def colType = "String"
                         def proj = null
-                        // Get the type from the header
-                        if (c.contains(":")) {
+                        // Get the type from the header (if the type is valid)
+                        if (c.contains(":") && Schema.isValidFieldType(c.split(":")[1])) {
                             String[] parts = c.split(":")
                             c = parts[0]
                             colType = parts[1]
@@ -293,6 +300,9 @@ class CsvReader implements Reader {
                     Map valueMap = [:]
                     cols.eachWithIndex {c,i ->
                         String colName = getColumnName(c)
+                        if (!layer.schema.has(colName)) {
+                            colName = c
+                        }
                         def v = values[i]
                         if (usingSingleColumn && colName.equalsIgnoreCase(column)) {
                             if (isGeom) {
@@ -400,7 +410,11 @@ class CsvReader implements Reader {
             str.startsWith("MULTILINESTRING (") || str.startsWith("MULTILINESTRING(") ||
             str.startsWith("MULTIPOLYGON") || str.startsWith("MULTIPOLYGON(") ||
             str.startsWith("GEOMETRYCOLLECTION (") || str.startsWith("GEOMETRYCOLLECTION(") ||
-            str.startsWith("LINEARRING (") || str.startsWith("LINEARRING(")
+            str.startsWith("LINEARRING (") || str.startsWith("LINEARRING(") ||
+            str.startsWith("CIRCULARSTRING (") || str.startsWith("CIRCULARSTRING(") ||
+            str.startsWith("CIRCULARRING (") || str.startsWith("CIRCULARRING(") ||
+            str.startsWith("COMPOUNDCURVE (") || str.startsWith("COMPOUNDCURVE(") ||
+            str.startsWith("COMPOUNDRING (") || str.startsWith("COMPOUNDRING(")
         ) {
             return true
         }

src/test/groovy/geoscript/feature/SchemaTestCase.groovy

@@ -319,6 +319,20 @@ class SchemaTestCase {
         assertEquals "org.geotools.geometry.jts.CompoundCurve", Schema.lookUpBinding("CompoundCurve")
     }
 
+    @Test void isValidFieldType() {
+        assertTrue(Schema.isValidFieldType("str"))
+        assertTrue(Schema.isValidFieldType("string"))
+        assertTrue(Schema.isValidFieldType("java.lang.String"))
+        assertTrue(Schema.isValidFieldType("Point"))
+        assertTrue(Schema.isValidFieldType("geoscript.geom.Point"))
+        assertTrue(Schema.isValidFieldType("int"))
+        assertTrue(Schema.isValidFieldType("integer"))
+
+        assertFalse(Schema.isValidFieldType("asdf"))
+        assertFalse(Schema.isValidFieldType("junk"))
+        assertFalse(Schema.isValidFieldType("inter"))
+    }
+
     @Test void spec() {
         Schema s1 = new Schema("widgets", [new Field("geom","Point"), new Field("name","string"), new Field("price","float")])
         assertEquals "geom:Point,name:String,price:Float", s1.spec

src/test/groovy/geoscript/layer/io/CsvReaderTestCase.groovy

@@ -39,6 +39,20 @@ class CsvReaderTestCase {
         }
     }
 
+    @Test void readWKTWithSemiColons() {
+        String csv = """"geom:geom","name:x","price:y"
+"POINT (111 -47)","House","12.5"
+"POINT (121 -45)","School","22.7"
+"""
+        CsvReader reader = new CsvReader()
+        Layer layer = reader.read(csv)
+        assertEquals("csv geom:geom: Point, name:x: String, price:y: String", layer.schema.toString())
+        assertEquals(2, layer.count)
+        layer.eachFeature { f ->
+            assertTrue(f.geom instanceof geoscript.geom.Point)
+        }
+    }
+
     @Test void readWKTWithTypesAndProj() {
         String csv = """"geom:Point:EPSG:4326","name:String","price:Double"
 "POINT (111 -47)","House","12.5"