Prevent NPE in CSV diff rendering when column removed

modules/csv/csv.go

@@ -30,7 +30,7 @@ func CreateReader(input io.Reader, delimiter rune) *stdcsv.Reader {
 func CreateReaderAndGuessDelimiter(rd io.Reader) (*stdcsv.Reader, error) {
 	var data = make([]byte, 1e4)
 	size, err := rd.Read(data)
-	if err != nil {
+	if err != nil && err != io.EOF {
 		return nil, err
 	}
 

modules/markup/csv/csv.go

@@ -88,7 +88,7 @@ func (Renderer) Render(ctx *markup.RenderContext, input io.Reader, output io.Wri
 
 	// FIXME: don't read all to memory
 	rawBytes, err := ioutil.ReadAll(input)
-	if err != nil {
+	if err != nil && err != io.EOF {
 		return err
 	}
 
@@ -104,7 +104,7 @@ func (Renderer) Render(ctx *markup.RenderContext, input io.Reader, output io.Wri
 	}
 
 	rd, err := csv.CreateReaderAndGuessDelimiter(bytes.NewReader(rawBytes))
-	if err != nil {
+	if err != nil && err != io.EOF {
 		return err
 	}
 

services/gitdiff/csv.go

@@ -53,6 +53,9 @@ type csvReader struct {
 	eof    bool
 }
 
+// ErrorUndefinedCell is for when a row, column coordinates do not exist in the CSV
+var ErrorUndefinedCell = errors.New("undefined cell")
+
 // createCsvReader creates a csvReader and fills the buffer
 func createCsvReader(reader *csv.Reader, bufferRowCount int) (*csvReader, error) {
 	csv := &csvReader{reader: reader}
@@ -70,7 +73,7 @@ func createCsvReader(reader *csv.Reader, bufferRowCount int) (*csvReader, error)
 
 // GetRow gets a row from the buffer if present or advances the reader to the requested row. On the end of the file only nil gets returned.
 func (csv *csvReader) GetRow(row int) ([]string, error) {
-	if row < len(csv.buffer) {
+	if row < len(csv.buffer) && row >= 0 {
 		return csv.buffer[row], nil
 	}
 	if csv.eof {
@@ -131,7 +134,11 @@ func createCsvDiffSingle(reader *csv.Reader, celltype TableDiffCellType) ([]*Tab
 		}
 		cells := make([]*TableDiffCell, len(row))
 		for j := 0; j < len(row); j++ {
-			cells[j] = &TableDiffCell{LeftCell: row[j], Type: celltype}
+			if celltype == TableDiffCellDel {
+				cells[j] = &TableDiffCell{LeftCell: row[j], Type: celltype}
+			} else {
+				cells[j] = &TableDiffCell{RightCell: row[j], Type: celltype}
+			}
 		}
 		rows = append(rows, &TableDiffRow{RowIdx: i, Cells: cells})
 		i++
@@ -161,31 +168,6 @@ func createCsvDiff(diffFile *DiffFile, baseReader *csv.Reader, headReader *csv.R
 	createDiffRow := func(aline int, bline int) (*TableDiffRow, error) {
 		cells := make([]*TableDiffCell, columns)
 
-		if aline == 0 || bline == 0 {
-			var (
-				row      []string
-				celltype TableDiffCellType
-				err      error
-			)
-			if bline == 0 {
-				row, err = a.GetRow(aline - 1)
-				celltype = TableDiffCellDel
-			} else {
-				row, err = b.GetRow(bline - 1)
-				celltype = TableDiffCellAdd
-			}
-			if err != nil {
-				return nil, err
-			}
-			if row == nil {
-				return nil, nil
-			}
-			for i := 0; i < len(row); i++ {
-				cells[i] = &TableDiffCell{LeftCell: row[i], Type: celltype}
-			}
-			return &TableDiffRow{RowIdx: bline, Cells: cells}, nil
-		}
-
 		arow, err := a.GetRow(aline - 1)
 		if err != nil {
 			return nil, err
@@ -199,25 +181,82 @@ func createCsvDiff(diffFile *DiffFile, baseReader *csv.Reader, headReader *csv.R
 		}
 
 		for i := 0; i < len(a2b); i++ {
-			acell, _ := getCell(arow, i)
-			if a2b[i] == unmappedColumn {
-				cells[i] = &TableDiffCell{LeftCell: acell, Type: TableDiffCellDel}
+			var aCell string
+			aIsUndefined := false
+			if aline > 0 {
+				if cell, err := getCell(arow, i); err != nil {
+					if err != ErrorUndefinedCell {
+						return nil, err
+					}
+					aIsUndefined = true
+				} else {
+					aCell = cell
+				}
 			} else {
-				bcell, _ := getCell(brow, a2b[i])
+				aIsUndefined = true
+			}
 
-				celltype := TableDiffCellChanged
-				if acell == bcell {
-					celltype = TableDiffCellEqual
+			if a2b[i] == unmappedColumn {
+				cells[i] = &TableDiffCell{LeftCell: aCell, Type: TableDiffCellDel}
+			} else {
+				var bCell string
+				bIsUndefined := false
+				if bline > 0 {
+					if cell, err := getCell(brow, a2b[i]); err != nil {
+						if err != ErrorUndefinedCell {
+							return nil, err
+						}
+						bIsUndefined = true
+					} else {
+						bCell = cell
+					}
+				} else {
+					bIsUndefined = true
 				}
-
-				cells[i] = &TableDiffCell{LeftCell: acell, RightCell: bcell, Type: celltype}
+				var cellType TableDiffCellType
+				if aIsUndefined && !bIsUndefined {
+					cellType = TableDiffCellAdd
+				} else if bIsUndefined {
+					cellType = TableDiffCellDel
+				} else if aCell == bCell {
+					cellType = TableDiffCellEqual
+				} else {
+					cellType = TableDiffCellChanged
+				}
+				cells[i] = &TableDiffCell{LeftCell: aCell, RightCell: bCell, Type: cellType}
 			}
 		}
+		cellsIndex := 0
 		for i := 0; i < len(b2a); i++ {
 			if b2a[i] == unmappedColumn {
-				bcell, _ := getCell(brow, i)
-				cells[i] = &TableDiffCell{LeftCell: bcell, Type: TableDiffCellAdd}
+				var bCell string
+				bIsUndefined := false
+				if bline > 0 {
+					if cell, err := getCell(brow, i); err != nil {
+						if err != ErrorUndefinedCell {
+							return nil, err
+						}
+						bIsUndefined = true
+					} else {
+						bCell = cell
+					}
+				} else {
+					bIsUndefined = true
+				}
+				if cells[cellsIndex] != nil && len(cells) >= cellsIndex+1 {
+					copy(cells[cellsIndex+1:], cells[cellsIndex:])
+				}
+				var cellType TableDiffCellType
+				if bIsUndefined {
+					cellType = TableDiffCellDel
+				} else {
+					cellType = TableDiffCellAdd
+				}
+				cells[cellsIndex] = &TableDiffCell{RightCell: bCell, Type: cellType}
+			} else if cellsIndex < b2a[i] {
+				cellsIndex = b2a[i]
 			}
+			cellsIndex++
 		}
 
 		return &TableDiffRow{RowIdx: bline, Cells: cells}, nil
@@ -300,26 +339,26 @@ func getColumnMapping(a *csvReader, b *csvReader) ([]int, []int) {
 
 // tryMapColumnsByContent tries to map missing columns by the content of the first lines.
 func tryMapColumnsByContent(a *csvReader, a2b []int, b *csvReader, b2a []int) {
-	start := 0
 	for i := 0; i < len(a2b); i++ {
-		if a2b[i] == unmappedColumn {
-			if b2a[start] == unmappedColumn {
+		bStart := 0
+		for a2b[i] == unmappedColumn && bStart < len(b2a) {
+			if b2a[bStart] == unmappedColumn {
 				rows := util.Min(maxRowsToInspect, util.Max(0, util.Min(len(a.buffer), len(b.buffer))-1))
 				same := 0
 				for j := 1; j <= rows; j++ {
-					acell, ea := getCell(a.buffer[j], i)
-					bcell, eb := getCell(b.buffer[j], start+1)
-					if ea == nil && eb == nil && acell == bcell {
+					aCell, aErr := getCell(a.buffer[j], i)
+					bCell, bErr := getCell(b.buffer[j], bStart)
+					if aErr == nil && bErr == nil && aCell == bCell {
 						same++
 					}
 				}
 				if (float32(same) / float32(rows)) > minRatioToMatch {
-					a2b[i] = start + 1
-					b2a[start+1] = i
+					a2b[i] = bStart
+					b2a[bStart] = i
 				}
 			}
+			bStart++
 		}
-		start = a2b[i]
 	}
 }
 
@@ -328,7 +367,7 @@ func getCell(row []string, column int) (string, error) {
 	if column < len(row) {
 		return row[column], nil
 	}
-	return "", errors.New("Undefined column")
+	return "", ErrorUndefinedCell
 }
 
 // countUnmappedColumns returns the count of unmapped columns.