Add source map option to get the actual added/modified row

cmd/digest.go

@@ -56,15 +56,16 @@ func runDigest() {
 		Encoder:      config.GetEncoder(),
 		Reader:       config.GetInput(),
 		Writer:       os.Stdout,
+		SourceMap:    true,
 	}
 
-	base, err := digest.Create(baseConfig)
+	base, _, err := digest.Create(baseConfig)
 	if err != nil {
 		log.Fatal(err)
 	}
 	log.Println("Generated Base Digest")
 
-	change, err := digest.Create(inputConfig)
+	change, sourceMap, err := digest.Create(inputConfig)
 	if err != nil {
 		log.Fatal(err)
 	}
@@ -73,10 +74,15 @@ func runDigest() {
 	additions, modifications := digest.Compare(base, change)
 
 	fmt.Println(fmt.Sprintf("Additions Count: %d", len(additions)))
-	fmt.Println(additions)
+	for _, addition := range additions {
+		fmt.Println(sourceMap[addition])
+	}
+
 	fmt.Println("")
 	fmt.Println(fmt.Sprintf("Modifications Count: %d", len(modifications)))
-	fmt.Println(modifications)
+	for _, modification := range modifications {
+		fmt.Println(sourceMap[modification])
+	}
 }
 
 var debug bool

pkg/digest/digest.go

@@ -14,6 +14,7 @@ import (
 type Digest struct {
 	Key   uint64
 	Value uint64
+	Row   string
 }
 
 // CreateDigest creates a Digest for each line of csv.
@@ -24,10 +25,11 @@ func CreateDigest(csv []string, keyPositions []int) Digest {
 		keyCsv[i] = csv[pos]
 	}
 
+	row := strings.Join(csv, ",")
 	key := xxhash.Sum64String(strings.Join(keyCsv, ","))
-	digest := xxhash.Sum64String(strings.Join(csv, ","))
+	digest := xxhash.Sum64String(row)
 
-	return Digest{Key: key, Value: digest}
+	return Digest{Key: key, Value: digest, Row: row}
 
 }
 
@@ -36,24 +38,29 @@ type DigestConfig struct {
 	Encoder      encoder.Encoder
 	Reader       io.Reader
 	Writer       io.Writer
+	SourceMap    bool
 }
 
-func Create(config DigestConfig) (map[uint64]uint64, error) {
+func Create(config DigestConfig) (map[uint64]uint64, map[uint64]string, error) {
 	reader := csv.NewReader(config.Reader)
 
 	output := make(map[uint64]uint64)
+	sourceMap := make(map[uint64]string)
 	for {
 		line, err := reader.Read()
 		if err != nil {
 			if err == io.EOF {
 				break
 			}
-			return nil, err
+			return nil, nil, err
 		}
 		digest := CreateDigest(line, config.KeyPositions)
 		output[digest.Key] = digest.Value
+		if config.SourceMap {
+			sourceMap[digest.Key] = digest.Row
+		}
 	}
 
 	// config.Encoder.Encode(output, config.Writer)
-	return output, nil
+	return output, sourceMap, nil
 }

pkg/digest/digest_test.go

@@ -15,7 +15,7 @@ func TestCreateDigest(t *testing.T) {
 	firstKey := xxhash.Sum64String("1")
 	firstLineDigest := xxhash.Sum64String(firstLine)
 
-	expectedDigest := Digest{Key: firstKey, Value: firstLineDigest}
+	expectedDigest := Digest{Key: firstKey, Value: firstLineDigest, Row: firstLine}
 
 	actualDigest := CreateDigest(strings.Split(firstLine, ","), []int{0})
 
@@ -38,15 +38,33 @@ func TestDigestForFile(t *testing.T) {
 		Writer:       &outputBuffer,
 		Encoder:      encoder.JsonEncoder{},
 		KeyPositions: []int{0},
+		SourceMap:    true,
 	}
 
-	actualDigest, err := Create(testConfig)
+	actualDigest, sourceMap, err := Create(testConfig)
 
 	//actualDigest := outputBuffer.String()
 	//expectedDigest := fmt.Sprintf(`{"%d":%d,"%d":%d}`, firstKey, firstDigest, secondKey, secondDigest)
 
 	expectedDigest := map[uint64]uint64{firstKey: firstDigest, secondKey: secondDigest}
+	expectedSourceMap := map[uint64]string{firstKey: firstLine, secondKey: secondLine}
 
 	assert.Nil(t, err, "error at DigestForFile")
 	assert.Equal(t, expectedDigest, actualDigest)
+	assert.Equal(t, expectedSourceMap, sourceMap)
+
+	// No source map
+	testConfigWithoutSourceMap := DigestConfig{
+		Reader:       strings.NewReader(firstLine + "\n" + secondLine),
+		Writer:       &outputBuffer,
+		Encoder:      encoder.JsonEncoder{},
+		KeyPositions: []int{0},
+		SourceMap:    false,
+	}
+
+	actualDigest, sourceMap, err = Create(testConfigWithoutSourceMap)
+
+	assert.Nil(t, err, "error at DigestForFile")
+	assert.Equal(t, expectedDigest, actualDigest)
+	assert.Equal(t, map[uint64]string{}, sourceMap)
 }