better handle unmatching records and targets

Author: Stefan Tudose

errors.go

@@ -8,6 +8,8 @@ var (
 	// ErrEOF is thrown if the EOF is reached by the Next method.
 	ErrEOF = errors.New("end of file reached")
 
+	ErrScanTargetsNotMatch = errors.New("the number of scan targets does not match the number of csv records")
+
 	errNilPtr = errors.New("destination is a nil pointer")
 	errNotPtr = errors.New("destination not a pointer")
 )

parser.go

@@ -14,10 +14,11 @@ type Parser struct {
 	lastErr          error
 }
 
-// ParserConfig has information for parser
+// ParserConfig allows to configure the parser.
 type ParserConfig struct {
-	Comma         rune
-	IgnoreHeaders bool
+	Comma                  rune
+	IgnoreHeaders          bool
+	IgnoreUnmatchingFields bool
 }
 
 type Decoder interface {
@@ -54,9 +55,11 @@ func newParser(reader io.Reader, config ParserConfig) (*Parser, error) {
 }
 
 // Scan copies the values in the current row into the values pointed
-// at by dest. The number of values in dest can be different than the
-// number of values. In this case Scan will only fill the available
-// values.
+// at by dest.
+// With the defult behaviour, it will throw an error if the number of values in dest
+// is different from the number of values.
+// If the `IgnoreUnmatchingFields` flag is set, it will ignore the records and the
+// arguments that have no match.
 //
 // Scan converts columns read from the database into the following
 // common types:
@@ -72,12 +75,23 @@ func newParser(reader io.Reader, config ParserConfig) (*Parser, error) {
 //
 func (p *Parser) Scan(dest ...interface{}) error {
 	if p.currentRowValues == nil {
-		return errors.New("Scan called without calling Next")
+		return errors.New("scan called without calling Next")
+	}
+	if !p.config.IgnoreUnmatchingFields && len(p.currentRowValues) != len(dest) {
+		return fmt.Errorf("%w: got %d scan targets and %d records",
+			ErrScanTargetsNotMatch,
+			len(dest),
+			len(p.currentRowValues),
+		)
 	}
 	for i, val := range p.currentRowValues {
+		if i >= len(dest) {
+			// ignore the remaining records as they have no scan target
+			break
+		}
 		err := convertAssignValue(dest[i], val)
 		if err != nil {
-			return fmt.Errorf(`Scan error on value index %d: %v`, i, err)
+			return fmt.Errorf("scan error on value index %d: %v", i, err)
 		}
 	}
 	return nil

parser_test.go

@@ -0,0 +1,100 @@
+package csvdecoder
+
+import (
+	"errors"
+	"strings"
+	"testing"
+)
+
+func TestParserIgnoreUnmatchingFields(t *testing.T) {
+	var strVal string
+	var intVal int
+	var anotherIntVal int
+
+	for _, tc := range []struct {
+		name          string
+		config        ParserConfig
+		data          string
+		scanTargets   []interface{}
+		expectedError error
+	}{
+		{
+			name: "should work when numbers match and flag is false",
+			config: ParserConfig{
+				IgnoreUnmatchingFields: false,
+			},
+			data:          "rec,2\n",
+			scanTargets:   []interface{}{&strVal, &intVal},
+			expectedError: nil,
+		},
+		{
+			name: "should work when numbers match and flag is true",
+			config: ParserConfig{
+				IgnoreUnmatchingFields: true,
+			},
+			data:          "rec,2\n",
+			scanTargets:   []interface{}{&strVal, &intVal},
+			expectedError: nil,
+		},
+		{
+			name:          "should work when numbers match with default config",
+			config:        ParserConfig{},
+			data:          "rec,2\n",
+			scanTargets:   []interface{}{&strVal, &intVal},
+			expectedError: nil,
+		},
+		{
+			name: "should work with more targets when the flag is true",
+			config: ParserConfig{
+				IgnoreUnmatchingFields: true,
+			},
+			data:          "rec,2\n",
+			scanTargets:   []interface{}{&strVal, &intVal, &anotherIntVal},
+			expectedError: nil,
+		},
+		{
+			name: "should work with more records when the flag is true",
+			config: ParserConfig{
+				IgnoreUnmatchingFields: true,
+			},
+			data:          "rec,2\n",
+			scanTargets:   []interface{}{&strVal},
+			expectedError: nil,
+		},
+		{
+			name: "should fail with more targets when the flag is false",
+			config: ParserConfig{
+				IgnoreUnmatchingFields: false,
+			},
+			data:          "rec,2\n",
+			scanTargets:   []interface{}{&strVal, &intVal, &anotherIntVal},
+			expectedError: ErrScanTargetsNotMatch,
+		},
+		{
+			name: "should fail with more records when the flag is false",
+			config: ParserConfig{
+				IgnoreUnmatchingFields: false,
+			},
+			data:          "rec,2\n",
+			scanTargets:   []interface{}{&strVal},
+			expectedError: ErrScanTargetsNotMatch,
+		},
+	} {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			parser, err := NewParserWithConfig(strings.NewReader(tc.data), tc.config)
+			if err != nil {
+				t.Fatalf("could not create parser: %w", err)
+			}
+
+			for parser.Next() {
+				if err := parser.Scan(tc.scanTargets...); !errors.Is(err, tc.expectedError) {
+					t.Errorf("expected '%s', got '%v'", tc.expectedError, err)
+				}
+			}
+			if parser.Err() != nil {
+				t.Error(err)
+			}
+		})
+	}
+}