PropertyMapper
122 | */
123 | def next() {
124 | throwsExceptionIfClosed()
125 |
126 | new PropertyMapper(columns: columns, values: nextValue)
127 | }
128 |
129 | private def throwsExceptionIfClosed() {
130 | if (isClosed()) {
131 | throw new IllegalStateException("The connection the underlying dataset has already been closed.")
132 | }
133 | }
134 |
135 | /**
136 | * remove is not supported in CsvIterator.
137 | *
138 | * @throws UnsupportedOperationException when called
139 | */
140 | void remove() {
141 | throw new UnsupportedOperationException()
142 | }
143 | }
144 |
--------------------------------------------------------------------------------
/src/com/xlson/groovycsv/CsvParser.groovy:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2010 Leonard Gram
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.xlson.groovycsv
18 |
19 | import com.opencsv.CSVReader
20 |
21 | /**
22 | * Helper class used to parse information from csv files using the column names
23 | * in the first line. Currently it only supports csv files where the first line
24 | * contains the column names.
25 | * 26 | * Usage: 27 | *
28 | * def csv = '''Name,Lastname
29 | * Mark,Andersson
30 | * Pete,Hansen'''
31 | *
32 | * def data = new CsvParser().parse(csv)
33 | * for(line in data) {* println "$line.Name $line.Lastname"
34 | *}
35 | *
36 | *
37 | * @author Leonard Gram
38 | * @since 0.1
39 | */
40 | class CsvParser {
41 |
42 | /**
43 | * Number of characters used to provide to autodetection (in case auto
44 | * detection is used.
45 | */
46 | Integer autoDetectCharNumber = 1000
47 |
48 | /**
49 | * Parses a string as csv in the same way as CsvParser.parse(...).
50 | *
51 | * @param args
52 | * @param csv
53 | * @return
54 | */
55 | static Iterator parseCsv(Map args = [:], String csv) {
56 | new CsvParser().parse(args, csv)
57 | }
58 |
59 | /**
60 | * Parses a reader as csv in the same way as CsvParser.parse(...).
61 | *
62 | * @param args
63 | * @param csv
64 | * @return
65 | */
66 | static Iterator parseCsv(Map args = [:], Reader reader) {
67 | new CsvParser().parse(args, reader)
68 | }
69 |
70 | /**
71 | * Parses the csv supplied using the reader. See parse(Reader reader) for
72 | * more information about usage.
73 | *
74 | * @param args configurable parameters
75 | * @param csv the csv to parse
76 | * @return an instance of com.xlson.groovycsv.CsvIterator
77 | */
78 | Iterator parse(Map args = [:], String csv) {
79 | parse(args, new StringReader(csv))
80 | }
81 |
82 | /**
83 | * Parses the supplied csv and returns a CsvIterator that can be
84 | * use to access the data. The first line of the csv will be used
85 | * as column-headers. Named paramenters can be used to configure the
86 | * parsing, see the class documentation for more more information on
87 | * usage. There's also support for autodetecting the quote and separator
88 | * characters.
89 | * 90 | * Arguments for configuration: 91 | *
101 | * Usage: 102 | *
103 | * def csv = '''Fruit-Quantity
104 | * Apple-2
105 | * Pear-5'''
106 | *
107 | * def data = new CsvParser().parse(csv, separator: '-')
108 | *
109 | * // Print all fruits that have a quantity higher than 3
110 | * data.findAll{ (it.Quantity as int) > 3 }.each{ println it }*
111 | *
112 | * @param reader the csv to parse
113 | * @param args the configuration arguments
114 | * @return an instance of com.xlson.groovycsv.CsvIterator
115 | */
116 | Iterator parse(Map args = [:], Reader reader) {
117 | def csvReader = createCSVReader(args, reader)
118 | def columnNames = parseColumnNames(args, csvReader)
119 | new CsvIterator(columnNames, csvReader)
120 | }
121 |
122 | private def parseColumnNames(Map args, CSVReader csvReader) {
123 | def columnNames
124 |
125 | if (!args.readFirstLine) {
126 | columnNames = csvReader.readNext()
127 | }
128 |
129 | if (args.columnNames) {
130 | columnNames = args.columnNames
131 | }
132 |
133 | if (args.trimWhitespaceFromColumnNames) {
134 | columnNames = columnNames.collect { it.toString().trim() }
135 | }
136 | return columnNames
137 | }
138 |
139 | private CSVReader createCSVReader(Map args = [:], Reader reader) {
140 | Character separator
141 | Character quoteChar
142 | Character escapeChar = args.escapeChar
143 | Integer skipLines = args.skipLines ?: 0
144 |
145 | if (args.autoDetect == true) {
146 | reader = new PushbackReader(reader, autoDetectCharNumber)
147 | doAutoDetection(args, reader)
148 | separator = args.separator
149 | quoteChar = args.quoteChar
150 | } else {
151 | separator = args.separator ?: ','
152 | quoteChar = args.quoteChar ?: '"'
153 | }
154 |
155 | if (escapeChar != null) {
156 | return new CSVReader(reader, separator, quoteChar, escapeChar, skipLines)
157 | } else {
158 | return new CSVReader(reader, separator, quoteChar, skipLines)
159 | }
160 | }
161 |
162 | /**
163 | * Performs automatic detection of separator and quote character.
164 | *
165 | * It will search arguments for values 'auto' in separator and quoteChar. It
166 | * will return a new version of the arguments modified with the values that
167 | * were found.
168 | *
169 | * If nothing is detected, the values are removed from the args.
170 | *
171 | * Note that
172 | *
173 | * @param args the configuration arguments.
174 | * @param text the CSV as a String.
175 | * @return modified args with detected.
176 | */
177 | private Map doAutoDetection(Map args, PushbackReader reader) {
178 | def buf = new char[autoDetectCharNumber]
179 | def charsRead = reader.read(buf)
180 | def linesToInspect = new String(buf)
181 | reader.unread(buf, 0, charsRead)
182 |
183 |
184 | def autoDetector = new AutoDetectHandler(linesToInspect: linesToInspect)
185 | if (args.autoDetectQuoteChars) {
186 | autoDetector.autoDetectQuoteChars = args.autoDetectQuoteChars
187 | }
188 | if (args.autoDetectSeparators) {
189 | autoDetector.autoDetectSeparators = args.autoDetectSeparators
190 | }
191 | if (!args.separator) {
192 | def detectedSeparator = autoDetector.autoDetectSeparator()
193 | if (detectedSeparator) args.separator = detectedSeparator
194 | else args.remove("separator")
195 | }
196 | if (!args.quoteChar) {
197 | def detectedQuoteChar = autoDetector.autoDetectQuoteChar()
198 | if (detectedQuoteChar) args.quoteChar = detectedQuoteChar
199 | else args.remove("quoteChar")
200 | }
201 | return args
202 | }
203 |
204 | }
205 |
--------------------------------------------------------------------------------
/src/com/xlson/groovycsv/PropertyMapper.groovy:
--------------------------------------------------------------------------------
1 | /*
2 | * Copyright 2010 Leonard Gram
3 | *
4 | * Licensed under the Apache License, Version 2.0 (the "License");
5 | * you may not use this file except in compliance with the License.
6 | * You may obtain a copy of the License at
7 | *
8 | * http://www.apache.org/licenses/LICENSE-2.0
9 | *
10 | * Unless required by applicable law or agreed to in writing, software
11 | * distributed under the License is distributed on an "AS IS" BASIS,
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | * See the License for the specific language governing permissions and
14 | * limitations under the License.
15 | */
16 |
17 | package com.xlson.groovycsv
18 |
19 | import groovy.transform.EqualsAndHashCode
20 |
21 | /**
22 | * Maps between column names and values in a list. Uses propertyMissing
23 | * to allow for named access.
24 | *
25 | * @author Leonard Gram
26 | * @since 0.1
27 | */
28 | @EqualsAndHashCode
29 | class PropertyMapper {
30 |
31 | /**
32 | * A list of values for one csv line.
33 | */
34 | def values
35 |
36 | /**
37 | * The columns of the csv.
38 | */
39 | def columns = [:]
40 |
41 | /**
42 | * Maps properties to values.
43 | *
44 | * @param name the name of the property
45 | * @return the value as a String
46 | * @throws MissingPropertyException where the values-list doesn't contain enough data.
47 | */
48 | def propertyMissing(String name) {
49 | def index = columns[name]
50 | if (index != null) {
51 | if(values?.size() <= index) {
52 | return null
53 | }
54 | values[index]
55 | } else {
56 | throw new MissingPropertyException(name)
57 | }
58 | }
59 |
60 | /**
61 | * Allows values to be obtained using their position
62 | *
63 | * @param index
64 | * @return the value at that position
65 | */
66 | def getAt(Integer index) {
67 | values[index]
68 | }
69 |
70 | String toString() {
71 | columns.collect { key, index -> "$key: ${values[index]}" }.join(', ')
72 | }
73 |
74 | Map toMap() {
75 | def sortedKeys = columns.keySet().sort { columns[it] }
76 | [sortedKeys, values].transpose().collectEntries()
77 | }
78 | }
79 |
--------------------------------------------------------------------------------
/test/com/xlson/groovycsv/AutoDetectHandlerSpec.groovy:
--------------------------------------------------------------------------------
1 | package com.xlson.groovycsv
2 |
3 | import spock.lang.Specification;
4 |
5 | class AutoDetectHandlerSpec extends Specification {
6 |
7 |
8 | def "should auto detect quote character"() {
9 | setup:
10 | def adh = new AutoDetectHandler(linesToInspect: csvData)
11 |
12 | expect:
13 | adh.autoDetectQuoteChar() == quoteChar
14 |
15 | where:
16 | csvData | quoteChar
17 | testDataWithColumnNamesAnd3Rows | '"'
18 | testDataWithColumnNamesAnd2Rows | '"'
19 | csvUsingDoubleQuoteAsQuoteChar | '"'
20 | csvUsingPercentageAsQuoteChar | "%"
21 |
22 | }
23 |
24 | def "should auto detect separator"() {
25 | setup:
26 | def adh = new AutoDetectHandler(linesToInspect: csvData)
27 |
28 | expect:
29 | adh.autoDetectSeparator() == separator
30 |
31 | where:
32 | csvData | separator
33 | testDataWithColumnNamesAnd3Rows | ","
34 | testDataWithColumnNamesAnd2Rows | ","
35 | csvUsingDoubleQuoteAsQuoteChar | ','
36 | csvWithColonAsSeparator | ":"
37 | }
38 |
39 |
40 | def getTestDataWithColumnNamesAnd3Rows() {
41 | '''Name,Lastname,Age,Email
42 | Mark,Hamilton,45,mark@hamilton.com
43 | Bosse,Bildoktorn,50,bildoktorn@tv4.se
44 | Peps,Persson,65,peps.persson@hotmail.com'''
45 | }
46 |
47 | def getTestDataWithColumnNamesAnd2Rows() {
48 | '''Letter,Word,Number
49 | a,paris,5
50 | h,drink,60'''
51 | }
52 |
53 | def getCsvWithColonAsSeparator() {
54 | '''Fruit:Count
55 | Apple:5
56 | Pear:10
57 | Kiwi:200'''
58 | }
59 |
60 | def getCsvUsingDoubleQuoteAsQuoteChar() {
61 | '''Typo,Desc
62 | 123,"text ,and more"'''
63 | }
64 |
65 | def getCsvUsingPercentageAsQuoteChar() {
66 | '''Typo,Desc
67 | 1123,%bla, ha%'''
68 |
69 | }
70 |
71 | }
72 |
--------------------------------------------------------------------------------
/test/com/xlson/groovycsv/ConfigurableColumnNamesSpec.groovy:
--------------------------------------------------------------------------------
1 | package com.xlson.groovycsv
2 |
3 | import com.opencsv.CSVReader
4 | import spock.lang.Specification
5 |
6 | class ConfigurableColumnNamesSpec extends Specification {
7 |
8 | def csvWithoutCoulmnNames = """field1,field2,field3,
9 | Joe,Doe,18
10 | Jane,Doe,24"""
11 |
12 | def "Replaces existing column names with new ones"() {
13 | setup:
14 | def persons = new CsvParser().parse(csvWithoutCoulmnNames, columnNames: ['name', 'lastname', 'age'])
15 |
16 | when:
17 | def joe = persons.next()
18 |
19 | then:
20 | joe.name == 'Joe'
21 | joe.lastname == 'Doe'
22 | joe.age == '18'
23 | }
24 |
25 | def "Read all lines of csv content using custom column as column names"() {
26 | setup:
27 | def persons = new CsvParser().parse(csvWithoutCoulmnNames, readFirstLine: true, columnNames: ['name', 'lastname', 'age'])
28 |
29 | when:
30 | def names = persons*.name
31 |
32 | then:
33 | names == ['field1', 'Joe', 'Jane']
34 | }
35 |
36 | def "Parses columns from the first line by default"() {
37 | setup:
38 | def reader = Mock(CSVReader)
39 |
40 | when:
41 | def columnNames = new CsvParser().parseColumnNames([:], reader)
42 |
43 | then:
44 | reader.readNext() >> ['a', 'b', 'c']
45 | columnNames == ['a', 'b', 'c']
46 | }
47 |
48 | def "Throws away the first line by default when using custom column names."() {
49 | setup:
50 | def reader = Mock(CSVReader)
51 |
52 | when:
53 | def customColumnNames = ['1', '2', '3']
54 | def columnNames = new CsvParser().parseColumnNames([columnNames: customColumnNames], reader)
55 |
56 | then:
57 | 1 * reader.readNext()
58 | columnNames == customColumnNames
59 | }
60 |
61 | def "Does not read the first line as header when readFirstLine is specified."() {
62 | setup:
63 | def reader = Mock(CSVReader)
64 |
65 | when:
66 | def customColumnNames = ['1', '2', '3']
67 | def columnNames = new CsvParser().parseColumnNames([columnNames : customColumnNames,
68 | readFirstLine: true],
69 | reader)
70 | then:
71 | 0 * reader.readNext()
72 | columnNames == customColumnNames
73 | }
74 |
75 | }
76 |
--------------------------------------------------------------------------------
/test/com/xlson/groovycsv/CsvIteratorSpec.groovy:
--------------------------------------------------------------------------------
1 | package com.xlson.groovycsv
2 |
3 | import com.opencsv.CSVReader
4 | import spock.lang.Specification
5 |
6 | class CsvIteratorSpec extends Specification {
7 |
8 | def getCsvData() {
9 | def csv = """a,b,c
10 | 1,2,3
11 | 4,5,6"""
12 | def csvReader = new CSVReader(new StringReader(csv))
13 | def columnNames = csvReader.readNext()
14 | return [columnNames, csvReader]
15 | }
16 |
17 | def "CsvIterator iterates correctly over the CSVReader"() {
18 | setup:
19 | def (colNames, csvReader) = csvData
20 | def iter = new CsvIterator(colNames, csvReader)
21 |
22 | expect:
23 | iter.hasNext()
24 | iter.next().a == '1'
25 | iter.hasNext()
26 | iter.next().c == '6'
27 | !iter.hasNext()
28 | }
29 |
30 | def "CsvIterator should close the underlying CSVReader instance when reaching the end of the file."() {
31 | setup:
32 | CSVReader csvReader = Mock(CSVReader)
33 | def iter = new CsvIterator(["a", "b"], csvReader)
34 | csvReader.readNext() >>> [["1", "2"], ["3", "4"], null]
35 |
36 | when:
37 | iter.next()
38 |
39 | then:
40 | iter.hasNext()
41 | !iter.isClosed()
42 | 0 * csvReader.close()
43 |
44 | when:
45 | iter.next()
46 | iter.hasNext()
47 |
48 | then:
49 | iter.isClosed()
50 | 1 * csvReader.close()
51 | }
52 |
53 | def "CsvIterator isClosed after a full iteration."() {
54 | setup:
55 | def csvIterator = new CsvIterator(*csvData)
56 |
57 | when:
58 | csvIterator.each {}
59 |
60 | then:
61 | csvIterator.isClosed()
62 |
63 | when:
64 | csvIterator.next()
65 |
66 | then:
67 | thrown(IllegalStateException)
68 | }
69 |
70 | def "close can be called on the CsvIterator to close the connection to the reader."() {
71 | setup:
72 | def (colNames, csvReader) = csvData
73 | def iter = new CsvIterator(colNames, csvReader)
74 |
75 | when:
76 | iter.next()
77 | iter.close()
78 |
79 | then:
80 | iter.isClosed()
81 |
82 | when:
83 | iter.next()
84 |
85 | then:
86 | thrown(IllegalStateException)
87 |
88 | }
89 |
90 | def "CsvIterator.hasNext() returns false when the underlying reader instance is closed."() {
91 | setup: 'Create an instance of CsvIterator consisting of 2 rows.'
92 | def csvIterator = new CsvIterator(*csvData)
93 |
94 | when: 'Iterates over the iterator until hasNext() is false'
95 | csvIterator.each {}
96 |
97 | then: 'hasNext() should return false.'
98 | !csvIterator.hasNext()
99 | }
100 |
101 | }
102 |
--------------------------------------------------------------------------------
/test/com/xlson/groovycsv/CsvParserSpec.groovy:
--------------------------------------------------------------------------------
1 | package com.xlson.groovycsv
2 |
3 | import com.opencsv.CSVReader
4 | import spock.lang.*
5 |
6 | class CsvParserSpec extends Specification {
7 | def getTestDataWithColumnNamesAnd3Rows() {
8 | '''Name,Lastname,Age,Email
9 | Mark,Hamilton,45,mark@hamilton.com
10 | Bosse,Bildoktorn,50,bildoktorn@tv4.se
11 | Peps,Persson,65,peps.persson@hotmail.com'''
12 | }
13 |
14 | def getTestDataWithColumnNamesAnd2Rows() {
15 | '''Letter,Word,Number
16 | a,paris,5
17 | h,drink,60'''
18 | }
19 |
20 | def getCsvWithColonAsSeparator() {
21 | '''Fruit:Count
22 | Apple:5
23 | Pear:10
24 | Kiwi:200'''
25 | }
26 |
27 | def getTestDataWithQuotedComma() {
28 | '''a,b
29 | -,abc-,4
30 | abc,-4-'''
31 | }
32 |
33 | def "Iterating over the parsed csv values are available by column name."() {
34 | setup:
35 | def data = new CsvParser().parse(getTestDataWithColumnNamesAnd3Rows())
36 |
37 | expect:
38 | data*."$columnName" == values
39 |
40 | where:
41 | columnName | values
42 | "Name" | ['Mark', 'Bosse', "Peps"]
43 | "Lastname" | ['Hamilton', 'Bildoktorn', 'Persson']
44 | 'Age' | ['45', '50', '65']
45 | "Email" | ['mark@hamilton.com', 'bildoktorn@tv4.se', 'peps.persson@hotmail.com']
46 | }
47 |
48 | def "Functional collection methods are available on parsed object."() {
49 | setup:
50 | def data = new CsvParser().parse(getTestDataWithColumnNamesAnd3Rows())
51 |
52 | expect:
53 | data.findAll { (it.Age as int) > 46 }.size() == 2
54 | }
55 |
56 | def "readAll should never be called on the CSVReader instance used to parse the csv."() {
57 | setup:
58 | CSVReader csvReader = Mock(CSVReader)
59 | def partiallyMockedCsvParser = new CsvParser()
60 | partiallyMockedCsvParser.metaClass.createCSVReader = { Reader reader ->
61 | csvReader
62 | }
63 |
64 | when: "csv is parsed and looped through"
65 | def data = partiallyMockedCsvParser.parse(getTestDataWithColumnNamesAnd2Rows())
66 | for (d in data) {
67 | }
68 |
69 | then: "readAll() should not be called."
70 | 0 * csvReader.readAll()
71 | }
72 |
73 | def "Parse supports a custom separator."() {
74 | setup:
75 | def data = new CsvParser().parse(csvWithColonAsSeparator, separator: ':')
76 |
77 | expect:
78 | data*."$columnName" == values
79 |
80 | where:
81 | columnName | values
82 | "Fruit" | ['Apple', 'Pear', 'Kiwi']
83 | "Count" | ["5", "10", "200"]
84 | }
85 |
86 | def getCsvUsingDoubleQuoteAsQuoteChar() {
87 | '''Typo,Desc
88 | 123,"text ,and more"'''
89 | }
90 |
91 | def getCsvUsingPercentageAsQuoteChar() {
92 | '''Typo,Desc
93 | 1123,%bla, ha%'''
94 |
95 | }
96 |
97 | def "Parse supports custom quote character."() {
98 | when:
99 | def csv = new CsvParser().parse(csvData, quoteChar: quoteChar)
100 |
101 | then:
102 | csv*."$columnName" == values
103 |
104 | where:
105 | csvData | quoteChar | values | columnName
106 | csvUsingDoubleQuoteAsQuoteChar | '"' | ['text ,and more'] | "Desc"
107 | csvUsingPercentageAsQuoteChar | "%" | ['bla, ha'] | "Desc"
108 | }
109 |
110 | def "Parse supports custom escape char."() {
111 | setup:
112 | def csvData = '''Test,It
113 | 1,"this is \"a quote\""'''
114 | def csv = new CsvParser().parse(csvData, escapeChar: "\\")
115 |
116 | expect:
117 | csv*.It == ['this is "a quote"']
118 |
119 | }
120 |
121 | def "Parser quietly ignores one empty line."() {
122 | setup:
123 | def csvData = '''Fruit,Country
124 |
125 | Apple,Sweden
126 | '''
127 | def csv = new CsvParser().parse(csvData)
128 |
129 | expect:
130 | for (line in csv) {
131 | line.Fruit == 'Apple'
132 | line.Country == 'Sweden'
133 | }
134 | }
135 |
136 | def "Parser quitely ignores multiple empty lines."() {
137 | setup:
138 | def csvData = '''Color,Day
139 | Red,Monday
140 |
141 |
142 |
143 | Black,Friday'''
144 |
145 | def csv = new CsvParser().parse(csvData)
146 |
147 | expect:
148 | def firstLine = csv.next()
149 | firstLine.Color == 'Red'
150 | firstLine.Day == 'Monday'
151 |
152 | def secondLine = csv.next()
153 | secondLine.Color == 'Black'
154 | secondLine.Day == 'Friday'
155 | csv.hasNext() == false
156 | }
157 |
158 | def "Parser quitely ignores multiple empty linessadadas."() {
159 | setup:
160 | def csvData = '''Color,Day
161 |
162 |
163 |
164 | Red,Monday
165 |
166 |
167 |
168 | Black,Friday
169 |
170 |
171 | '''
172 |
173 | def csv = new CsvParser().parse(csvData)
174 |
175 | expect:
176 | for (line in csv) {
177 | println line
178 | }
179 | }
180 |
181 | def "Parse supports java.io.Reader as input."() {
182 | when:
183 | def csv = new CsvParser().parse(new StringReader(testDataWithColumnNamesAnd2Rows))
184 |
185 | then:
186 | csv*.Number == ['5', '60']
187 | }
188 |
189 | def "CsvParser can auto detect separator and quote character"() {
190 | when: "a CSV file is parsed with auto detection"
191 | def csv = new CsvParser().parse(autoDetect: true, csvData)
192 |
193 | then: "it should return the correct columns"
194 | csv*."$property" == values
195 |
196 | where:
197 | csvData | property | values
198 | testDataWithColumnNamesAnd3Rows | "Age" | ["45", "50", "65"]
199 | csvWithColonAsSeparator | "Count" | ["5", "10", "200"]
200 | csvUsingDoubleQuoteAsQuoteChar | "Desc" | ["text ,and more"]
201 | csvUsingDoubleQuoteAsQuoteChar | "Typo" | ["123"]
202 | testDataWithColumnNamesAnd2Rows | "Word" | ["paris", "drink"]
203 | testDataWithColumnNamesAnd3Rows | "Email" | ["mark@hamilton.com", "bildoktorn@tv4.se", "peps.persson@hotmail.com"]
204 | }
205 |
206 | def "should allow to override auto detection"() {
207 | when: "autoDetect is active and a separator is provided"
208 | def csv = new CsvParser().parse(autoDetect: true, separator: ',', csvWithColonAsSeparator)
209 |
210 | then: "the separator provided is used"
211 | csv*."Fruit:Count" == ["Apple:5", "Pear:10", "Kiwi:200"]
212 | }
213 |
214 | def "The separator should be allowed in the csv data if its quoted"() {
215 | when:
216 | def csv = new CsvParser().parse(quoteChar: '-', testDataWithQuotedComma)
217 |
218 | then:
219 | csv*.a == [',abc', 'abc']
220 | }
221 |
222 | def "Values in the csv can be obtained by using the index of the column."() {
223 | when:
224 | def csv = new CsvParser().parse(testDataWithColumnNamesAnd2Rows)
225 | def line = csv.next()
226 |
227 | then:
228 | line[0] == 'a'
229 | line[1] == 'paris'
230 | line[2] == '5'
231 | }
232 |
233 | def csvWithoutHeaders = 'Joe,Doe,19'
234 |
235 | def "Parsing csv without headers using the position of the values."() {
236 | when:
237 | def csv = new CsvParser().parse(readFirstLine: true, csvWithoutHeaders)
238 | def line = csv.next()
239 |
240 | then:
241 | line[0] == 'Joe'
242 | line[1] == 'Doe'
243 | line[2] == '19'
244 |
245 | }
246 |
247 | def "CsvParser.parseCsv can be used statically."() {
248 | when:
249 | def csv = CsvParser.parseCsv(csvData)
250 |
251 | then:
252 | csv*.Letter == letterValues
253 |
254 | where:
255 | csvData | letterValues
256 | testDataWithColumnNamesAnd2Rows | ['a', 'h']
257 | new StringReader(testDataWithColumnNamesAnd2Rows) | ['a', 'h']
258 | }
259 |
260 | def getTestDataWithWhitespaceSurroundingColumnNames() {
261 | """ Name , Lastname,Country
262 | Leonard,Gram,Sweden"""
263 | }
264 |
265 | def "CsvParser can strip leading and trailing whitespaces on column names."() {
266 | when:
267 | def csv = CsvParser.parseCsv(testDataWithWhitespaceSurroundingColumnNames, trimWhitespaceFromColumnNames: true)
268 |
269 | then:
270 | for(line in csv) {
271 | line.Name == 'Leonard'
272 | line.Lastname == 'Gram'
273 | line.Country == 'Sweden'
274 | }
275 | }
276 |
277 | def "CsvParser can skip lines at the beginning of the file."() {
278 |
279 | def csvWithSkipLines = '''skipped line1
280 | skipped line2
281 | Letter,Word,Number
282 | a,paris,5
283 | h,drink,60'''
284 | when:
285 | def csv = new CsvParser().parse(skipLines: 2, csvWithSkipLines)
286 | def line = csv.next()
287 |
288 | then:
289 | line["Letter"] == "a"
290 | line["Word"] == "paris"
291 | line["Number"] == "5"
292 | }
293 |
294 | def "CsvParser and different cardinality lines"() {
295 | given:
296 | def csvWithDifferentCardinality = '''header1,header2,header3
297 | val1,val2
298 | val1,val2,val3'''
299 |
300 | when:
301 | def csv = new CsvParser().parse(csvWithDifferentCardinality)
302 | def line = csv.next()
303 |
304 | then:
305 | line["header3"] == null
306 |
307 | }
308 | }
309 |
--------------------------------------------------------------------------------
/test/com/xlson/groovycsv/PropertyMapperSpec.groovy:
--------------------------------------------------------------------------------
1 | package com.xlson.groovycsv
2 |
3 | import spock.lang.Specification
4 |
5 | class PropertyMapperSpec extends Specification {
6 |
7 | def getTestDataWithDuplicatedLines() {
8 | '''a,b
9 | 1,2
10 | 1,2
11 | 3,4'''
12 | }
13 |
14 | def "PropertyMapper has a toMap() that returns a map representation."() {
15 | setup:
16 | def pm = new PropertyMapper(values: values, columns: columns)
17 |
18 | expect:
19 | pm.toMap() == toMapRepresentation
20 |
21 | where:
22 | columns | values | toMapRepresentation
23 | ['a': 0, 'b': 1, 'c': 2] | ['1', '2', '3'] | ['a': '1', 'b': '2', 'c': '3']
24 | ['Name': 0, 'Age': 1] | ['Mark', '56'] | ['Name': 'Mark', 'Age': '56']
25 | }
26 |
27 | def "PropertyMapper has a toString() that returns all the data in it's columns."() {
28 | setup:
29 | def pm = new PropertyMapper(values: values, columns: columns)
30 |
31 | expect:
32 | pm.toString() == toStringRepresentation
33 |
34 | where:
35 | columns | values | toStringRepresentation
36 | ['a': 0, 'b': 1, 'c': 2] | ['1', '2', '3'] | "a: 1, b: 2, c: 3"
37 | ['Name': 0, 'Age': 1] | ['Mark', '56'] | "Name: Mark, Age: 56"
38 | }
39 |
40 | }
41 |
--------------------------------------------------------------------------------