Adjust errors.Wrap() messages

Signed-off-by: Lehner Florian <[email protected]>

Author: florianl

datatypes.go

@@ -57,14 +57,15 @@ func extractDataElement(r io.Reader, order binary.ByteOrder, dataType, numberOfB
 	if dataType == MiMatrix {
 		element, i, err = extractMatrix(r, order)
 		if err != nil {
-			return nil, 0, errors.Wrap(err, "extractMatrix() in extractDataElement() failed")
+			return nil, 0, errors.Wrap(err, "\nextractMatrix() in extractDataElement() failed")
 		}
 		return element, i, nil
 	}
 
 	data, err = readMatfBytes(r, order, numberOfBytes)
+
 	if err != nil {
-		return nil, 0, fmt.Errorf("Unable to read %d bytes: %v", numberOfBytes, err)
+		return nil, 0, errors.Wrap(err, "\nreadMatfBytes() in extractDataElement() failed")
 	}
 	for i < numberOfBytes {
 		switch dataType {
@@ -111,22 +112,25 @@ func extractDataElement(r io.Reader, order binary.ByteOrder, dataType, numberOfB
 func extractNumeric(r io.Reader, order binary.ByteOrder) (interface{}, int, error) {
 	dataType, numberOfBytes, offset, err := extractTag(r, order)
 	if err != nil {
-		return nil, 0, errors.Wrap(err, "extractTag() in extractNumeric() failed")
+		return nil, 0, errors.Wrap(err, "\nextractTag() in extractNumeric() failed")
 	}
 
 	re, _, err := extractDataElement(r, order, int(dataType), int(numberOfBytes))
 	if err != nil {
-		return nil, 0, errors.Wrap(err, "extractDataElement() in extractNumeric() failed")
+		return nil, 0, errors.Wrap(err, "\nextractDataElement() in extractNumeric() failed")
 	}
 	return re, offset + int(numberOfBytes), err
 }
 
 func extractFieldNames(r io.Reader, order binary.ByteOrder, fieldNameLength, numberOfFields int) ([]string, error) {
 	var index int
 	var names []string
+	if fieldNameLength*numberOfFields == 0 {
+		return names, nil
+	}
 	data, err := readMatfBytes(r, order, fieldNameLength*numberOfFields)
 	if err != nil {
-		return []string{}, fmt.Errorf("Unable to read %d bytes: %v", fieldNameLength*numberOfFields, err)
+		return []string{}, errors.Wrap(err, "\nreadMatfBytes() in extractFieldNames() failed")
 	}
 	for ; numberOfFields > 0; numberOfFields-- {
 		str := string(data[index : index+fieldNameLength])
@@ -139,7 +143,7 @@ func extractFieldNames(r io.Reader, order binary.ByteOrder, fieldNameLength, num
 func extractArrayName(r io.Reader, order binary.ByteOrder) (string, int, error) {
 	_, numberOfBytes, offset, err := extractTag(r, order)
 	if err != nil {
-		return "", 0, errors.Wrap(err, "extractTag() in extractArrayName() failed")
+		return "", 0, errors.Wrap(err, "\nextractTag() in extractArrayName() failed")
 	}
 	if numberOfBytes == 0 {
 		return "", offset, nil

matf.go

@@ -77,7 +77,7 @@ func readHeader(mat *Matf, file *os.File) error {
 	data := make([]byte, 128)
 	count, err := file.Read(data)
 	if err != nil {
-		return errors.Wrap(err, "file.Read() in readHeader() failed")
+		return errors.Wrap(err, "\nfile.Read() in readHeader() failed")
 	}
 
 	if count != 128 {
@@ -129,6 +129,7 @@ func alignIndex(r io.Reader, order binary.ByteOrder, index int) int {
 
 func extractClass(mat *MatMatrix, r io.Reader, order binary.ByteOrder) (int, error) {
 	var index int
+
 	switch int(mat.Class) {
 	case MxCellClass:
 		var content CellPrt
@@ -256,12 +257,13 @@ func extractMatrix(r io.Reader, order binary.ByteOrder) (MatMatrix, int, error)
 	// Array Flags
 	_, numberOfBytes, offset, err = extractTag(r, order)
 	if err != nil {
-		return MatMatrix{}, 0, err
+		return MatMatrix{}, 0, errors.Wrap(err, "\nextractTag() in extractMatrix() failed:")
 	}
 	index = alignIndex(r, order, index+offset+int(numberOfBytes))
+
 	arrayFlags, err := readMatfBytes(r, order, int(numberOfBytes))
 	if err != nil {
-		return MatMatrix{}, 0, err
+		return MatMatrix{}, 0, errors.Wrap(err, "\nreadMatfBytes() in extractMatrix() failed:")
 	}
 	matrix.Flags = order.Uint32(arrayFlags)
 	matrix.Class = matrix.Flags & 0x0F
@@ -270,26 +272,26 @@ func extractMatrix(r io.Reader, order binary.ByteOrder) (MatMatrix, int, error)
 	// Dimensions Array
 	dataType, numberOfBytes, offset, err = extractTag(r, order)
 	if err != nil {
-		return MatMatrix{}, 0, err
+		return MatMatrix{}, 0, errors.Wrap(err, "\nextractTag() in extractMatrix() failed:")
 	}
 	dims, _, err := extractDataElement(r, order, int(dataType), int(numberOfBytes))
 	if err != nil {
-		return MatMatrix{}, 0, err
+		return MatMatrix{}, 0, errors.Wrap(err, "\nextractDataElement() in extractMatrix() failed:")
 	}
 	matrix.Dim, _ = readDimensions(dims)
 	index = alignIndex(r, order, index+offset+int(numberOfBytes))
 
 	// Array Name
 	arrayName, step, err := extractArrayName(r, order)
 	if err != nil {
-		return MatMatrix{}, 0, err
+		return MatMatrix{}, 0, errors.Wrap(err, "\nextractArrayName() in extractMatrix() failed:")
 	}
 	matrix.Name = arrayName
 	index = alignIndex(r, order, index+step)
 
 	steps, err := extractClass(&matrix, r, order)
 	if err != nil {
-		return MatMatrix{}, 0, err
+		return MatMatrix{}, 0, errors.Wrap(err, "\nextractClass() in extractMatrix() failed:")
 	}
 	index = alignIndex(r, order, index+steps)
 
@@ -321,7 +323,7 @@ func decompressData(data []byte) ([]byte, error) {
 	var out bytes.Buffer
 	r, err := zlib.NewReader(tmp)
 	if err != nil {
-		return []byte{}, errors.Wrap(err, "zlib.NewReader() in decompressData() failed")
+		return []byte{}, errors.Wrap(err, "\nzlib.NewReader() in decompressData() failed")
 	}
 	defer r.Close()
 	if r != nil {
@@ -343,41 +345,41 @@ func readDataElementField(m *Matf, order binary.ByteOrder) (MatMatrix, error) {
 	completeBytes = order.Uint32(tag[4:8])
 	data, err = readBytes(m, int(completeBytes))
 	if err != nil {
-		return MatMatrix{}, errors.Wrap(err, "readBytes() in readDataElementField() failed")
+		return MatMatrix{}, errors.Wrap(err, "\nreadBytes() in readDataElementField() failed")
 	}
 
 	if dataType == uint32(MiCompressed) {
 		plain, err := decompressData(data[:completeBytes])
 		if err != nil {
-			return MatMatrix{}, errors.Wrap(err, "decompressData() in readDataElementField() failed")
+			return MatMatrix{}, errors.Wrap(err, "\ndecompressData() in readDataElementField() failed")
 		}
 		dataType = order.Uint32(plain[:4])
 		completeBytes = order.Uint32(plain[4:8])
 		if err != nil {
-			return MatMatrix{}, errors.Wrap(err, "extractTag() in readDataElementField() failed")
+			return MatMatrix{}, errors.Wrap(err, "\nextractTag() in readDataElementField() failed")
 		}
-		data = plain
+		data = plain[8:]
 	}
 
 	tmpfile, err := ioutil.TempFile("", "matf")
 	if err != nil {
-		return MatMatrix{}, errors.Wrap(err, "ioutil.TempFile() in readDataElementField() failed")
+		return MatMatrix{}, errors.Wrap(err, "\nioutil.TempFile() in readDataElementField() failed")
 	}
 
 	defer func() {
 		tmpfile.Close()
 		os.Remove(tmpfile.Name())
 	}()
 
-	if _, err := tmpfile.Write(data); err != nil {
-		return MatMatrix{}, errors.Wrap(err, "os.Write() in readDataElementField() failed")
+	if _, err = tmpfile.Write(data); err != nil {
+		return MatMatrix{}, errors.Wrap(err, "\nos.Write() in readDataElementField() failed")
 	}
 	tmpfile.Seek(0, 0)
 	r := bufio.NewReader(tmpfile)
 
 	element, i, err := extractDataElement(r, order, int(dataType), int(completeBytes))
 	if err != nil {
-		return MatMatrix{}, errors.Wrap(err, "extractDataElement() in readDataElementField() failed")
+		return MatMatrix{}, errors.Wrap(err, "\nextractDataElement() in readDataElementField() failed")
 	}
 	if int(dataType) == MiMatrix {
 		mat = element.(MatMatrix)
@@ -411,7 +413,7 @@ func Open(file string) (*Matf, error) {
 
 	err = readHeader(mat, f)
 	if err != nil {
-		return nil, errors.Wrap(err, "readHeader() in Open() failed")
+		return nil, errors.Wrap(err, "\nreadHeader() in Open() failed")
 	}
 
 	return mat, nil