This closes qax-os#1096, memory usage optimization and another 4 changes

- Unzip shared string table to system temporary file when large inner XML, reduce memory usage about 70%
- Remove unnecessary exported variable `XMLHeader`, we can using `encoding/xml` package's `xml.Header` instead of it
- Using constant instead of inline text for default XML path
- Rename exported option field `WorksheetUnzipMemLimit` to `UnzipXMLSizeLimit`
- Unit test and documentation updated

Author: xuri

calcchain.go

@@ -25,7 +25,7 @@ func (f *File) calcChainReader() *xlsxCalcChain {
 
 	if f.CalcChain == nil {
 		f.CalcChain = new(xlsxCalcChain)
-		if err = f.xmlNewDecoder(bytes.NewReader(namespaceStrictToTransitional(f.readXML("xl/calcChain.xml")))).
+		if err = f.xmlNewDecoder(bytes.NewReader(namespaceStrictToTransitional(f.readXML(dafaultXMLPathCalcChain)))).
 			Decode(f.CalcChain); err != nil && err != io.EOF {
 			log.Printf("xml decode error: %s", err)
 		}
@@ -39,7 +39,7 @@ func (f *File) calcChainReader() *xlsxCalcChain {
 func (f *File) calcChainWriter() {
 	if f.CalcChain != nil && f.CalcChain.C != nil {
 		output, _ := xml.Marshal(f.CalcChain)
-		f.saveFileList("xl/calcChain.xml", output)
+		f.saveFileList(dafaultXMLPathCalcChain, output)
 	}
 }
 
@@ -54,7 +54,7 @@ func (f *File) deleteCalcChain(index int, axis string) {
 	}
 	if len(calc.C) == 0 {
 		f.CalcChain = nil
-		f.Pkg.Delete("xl/calcChain.xml")
+		f.Pkg.Delete(dafaultXMLPathCalcChain)
 		content := f.contentTypesReader()
 		content.Lock()
 		defer content.Unlock()

calcchain_test.go

@@ -5,7 +5,7 @@ import "testing"
 func TestCalcChainReader(t *testing.T) {
 	f := NewFile()
 	f.CalcChain = nil
-	f.Pkg.Store("xl/calcChain.xml", MacintoshCyrillicCharset)
+	f.Pkg.Store(dafaultXMLPathCalcChain, MacintoshCyrillicCharset)
 	f.calcChainReader()
 }
 

cell.go

@@ -14,6 +14,7 @@ package excelize
 import (
 	"encoding/xml"
 	"fmt"
+	"os"
 	"reflect"
 	"strconv"
 	"strings"
@@ -348,36 +349,57 @@ func (f *File) SetCellStr(sheet, axis, value string) error {
 	ws.Lock()
 	defer ws.Unlock()
 	cellData.S = f.prepareCellStyle(ws, col, cellData.S)
-	cellData.T, cellData.V = f.setCellString(value)
+	cellData.T, cellData.V, err = f.setCellString(value)
 	return err
 }
 
 // setCellString provides a function to set string type to shared string
 // table.
-func (f *File) setCellString(value string) (t string, v string) {
+func (f *File) setCellString(value string) (t, v string, err error) {
 	if len(value) > TotalCellChars {
 		value = value[:TotalCellChars]
 	}
 	t = "s"
-	v = strconv.Itoa(f.setSharedString(value))
+	var si int
+	if si, err = f.setSharedString(value); err != nil {
+		return
+	}
+	v = strconv.Itoa(si)
+	return
+}
+
+// sharedStringsLoader load shared string table from system temporary file to
+// memory, and reset shared string table for reader.
+func (f *File) sharedStringsLoader() (err error) {
+	f.Lock()
+	defer f.Unlock()
+	if path, ok := f.tempFiles.Load(dafaultXMLPathSharedStrings); ok {
+		f.Pkg.Store(dafaultXMLPathSharedStrings, f.readBytes(dafaultXMLPathSharedStrings))
+		f.tempFiles.Delete(dafaultXMLPathSharedStrings)
+		err = os.Remove(path.(string))
+		f.SharedStrings, f.sharedStringItemMap = nil, nil
+	}
 	return
 }
 
 // setSharedString provides a function to add string to the share string table.
-func (f *File) setSharedString(val string) int {
+func (f *File) setSharedString(val string) (int, error) {
+	if err := f.sharedStringsLoader(); err != nil {
+		return 0, err
+	}
 	sst := f.sharedStringsReader()
 	f.Lock()
 	defer f.Unlock()
 	if i, ok := f.sharedStringsMap[val]; ok {
-		return i
+		return i, nil
 	}
 	sst.Count++
 	sst.UniqueCount++
 	t := xlsxT{Val: val}
 	_, val, t.Space = setCellStr(val)
 	sst.SI = append(sst.SI, xlsxSI{T: &t})
 	f.sharedStringsMap[val] = sst.UniqueCount - 1
-	return sst.UniqueCount - 1
+	return sst.UniqueCount - 1, nil
 }
 
 // setCellStr provides a function to set string type to cell.
@@ -762,6 +784,34 @@ func (f *File) GetCellRichText(sheet, cell string) (runs []RichTextRun, err erro
 	return
 }
 
+// newRpr create run properties for the rich text by given font format.
+func newRpr(fnt *Font) *xlsxRPr {
+	rpr := xlsxRPr{}
+	trueVal := ""
+	if fnt.Bold {
+		rpr.B = &trueVal
+	}
+	if fnt.Italic {
+		rpr.I = &trueVal
+	}
+	if fnt.Strike {
+		rpr.Strike = &trueVal
+	}
+	if fnt.Underline != "" {
+		rpr.U = &attrValString{Val: &fnt.Underline}
+	}
+	if fnt.Family != "" {
+		rpr.RFont = &attrValString{Val: &fnt.Family}
+	}
+	if fnt.Size > 0.0 {
+		rpr.Sz = &attrValFloat{Val: &fnt.Size}
+	}
+	if fnt.Color != "" {
+		rpr.Color = &xlsxColor{RGB: getPaletteColor(fnt.Color)}
+	}
+	return &rpr
+}
+
 // SetCellRichText provides a function to set cell with rich text by given
 // worksheet. For example, set rich text on the A1 cell of the worksheet named
 // Sheet1:
@@ -875,6 +925,9 @@ func (f *File) SetCellRichText(sheet, cell string, runs []RichTextRun) error {
 	if err != nil {
 		return err
 	}
+	if err := f.sharedStringsLoader(); err != nil {
+		return err
+	}
 	cellData.S = f.prepareCellStyle(ws, col, cellData.S)
 	si := xlsxSI{}
 	sst := f.sharedStringsReader()
@@ -889,30 +942,7 @@ func (f *File) SetCellRichText(sheet, cell string, runs []RichTextRun) error {
 		_, run.T.Val, run.T.Space = setCellStr(textRun.Text)
 		fnt := textRun.Font
 		if fnt != nil {
-			rpr := xlsxRPr{}
-			trueVal := ""
-			if fnt.Bold {
-				rpr.B = &trueVal
-			}
-			if fnt.Italic {
-				rpr.I = &trueVal
-			}
-			if fnt.Strike {
-				rpr.Strike = &trueVal
-			}
-			if fnt.Underline != "" {
-				rpr.U = &attrValString{Val: &fnt.Underline}
-			}
-			if fnt.Family != "" {
-				rpr.RFont = &attrValString{Val: &fnt.Family}
-			}
-			if fnt.Size > 0.0 {
-				rpr.Sz = &attrValFloat{Val: &fnt.Size}
-			}
-			if fnt.Color != "" {
-				rpr.Color = &xlsxColor{RGB: getPaletteColor(fnt.Color)}
-			}
-			run.RPr = &rpr
+			run.RPr = newRpr(fnt)
 		}
 		textRuns = append(textRuns, run)
 	}

cell_test.go

@@ -649,3 +649,20 @@ func TestFormattedValue2(t *testing.T) {
 	v = f.formattedValue(1, "43528", false)
 	assert.Equal(t, "43528", v)
 }
+
+func TestSharedStringsError(t *testing.T) {
+	f, err := OpenFile(filepath.Join("test", "Book1.xlsx"), Options{UnzipXMLSizeLimit: 128})
+	assert.NoError(t, err)
+	f.tempFiles.Store(dafaultXMLPathSharedStrings, "")
+	assert.Equal(t, "1", f.getFromStringItemMap(1))
+
+	// Test reload the file error on set cell cell and rich text. The error message was different between macOS and Windows.
+	err = f.SetCellValue("Sheet1", "A19", "A19")
+	assert.Error(t, err)
+
+	f.tempFiles.Store(dafaultXMLPathSharedStrings, "")
+	err = f.SetCellRichText("Sheet1", "A19", []RichTextRun{})
+	assert.Error(t, err)
+
+	assert.NoError(t, f.Close())
+}

docProps.go

@@ -27,8 +27,8 @@ import (
 //     Application       | The name of the application that created this document.
 //                       |
 //     ScaleCrop         | Indicates the display mode of the document thumbnail. Set this element
-//                       | to TRUE to enable scaling of the document thumbnail to the display. Set
-//                       | this element to FALSE to enable cropping of the document thumbnail to
+//                       | to 'true' to enable scaling of the document thumbnail to the display. Set
+//                       | this element to 'false' to enable cropping of the document thumbnail to
 //                       | show only sections that will fit the display.
 //                       |
 //     DocSecurity       | Security level of a document as a numeric value. Document security is
@@ -41,8 +41,8 @@ import (
 //     Company           | The name of a company associated with the document.
 //                       |
 //     LinksUpToDate     | Indicates whether hyperlinks in a document are up-to-date. Set this
-//                       | element to TRUE to indicate that hyperlinks are updated. Set this
-//                       | element to FALSE to indicate that hyperlinks are outdated.
+//                       | element to 'true' to indicate that hyperlinks are updated. Set this
+//                       | element to 'false' to indicate that hyperlinks are outdated.
 //                       |
 //     HyperlinksChanged | Specifies that one or more hyperlinks in this part were updated
 //                       | exclusively in this part by a producer. The next producer to open this
@@ -75,7 +75,7 @@ func (f *File) SetAppProps(appProperties *AppProperties) (err error) {
 		field              string
 	)
 	app = new(xlsxProperties)
-	if err = f.xmlNewDecoder(bytes.NewReader(namespaceStrictToTransitional(f.readXML("docProps/app.xml")))).
+	if err = f.xmlNewDecoder(bytes.NewReader(namespaceStrictToTransitional(f.readXML(dafaultXMLPathDocPropsApp)))).
 		Decode(app); err != nil && err != io.EOF {
 		err = fmt.Errorf("xml decode error: %s", err)
 		return
@@ -95,14 +95,14 @@ func (f *File) SetAppProps(appProperties *AppProperties) (err error) {
 	}
 	app.Vt = NameSpaceDocumentPropertiesVariantTypes.Value
 	output, err = xml.Marshal(app)
-	f.saveFileList("docProps/app.xml", output)
+	f.saveFileList(dafaultXMLPathDocPropsApp, output)
 	return
 }
 
 // GetAppProps provides a function to get document application properties.
 func (f *File) GetAppProps() (ret *AppProperties, err error) {
 	var app = new(xlsxProperties)
-	if err = f.xmlNewDecoder(bytes.NewReader(namespaceStrictToTransitional(f.readXML("docProps/app.xml")))).
+	if err = f.xmlNewDecoder(bytes.NewReader(namespaceStrictToTransitional(f.readXML(dafaultXMLPathDocPropsApp)))).
 		Decode(app); err != nil && err != io.EOF {
 		err = fmt.Errorf("xml decode error: %s", err)
 		return
@@ -181,7 +181,7 @@ func (f *File) SetDocProps(docProperties *DocProperties) (err error) {
 	)
 
 	core = new(decodeCoreProperties)
-	if err = f.xmlNewDecoder(bytes.NewReader(namespaceStrictToTransitional(f.readXML("docProps/core.xml")))).
+	if err = f.xmlNewDecoder(bytes.NewReader(namespaceStrictToTransitional(f.readXML(dafaultXMLPathDocPropsCore)))).
 		Decode(core); err != nil && err != io.EOF {
 		err = fmt.Errorf("xml decode error: %s", err)
 		return
@@ -223,7 +223,7 @@ func (f *File) SetDocProps(docProperties *DocProperties) (err error) {
 		newProps.Modified.Text = docProperties.Modified
 	}
 	output, err = xml.Marshal(newProps)
-	f.saveFileList("docProps/core.xml", output)
+	f.saveFileList(dafaultXMLPathDocPropsCore, output)
 
 	return
 }
@@ -232,7 +232,7 @@ func (f *File) SetDocProps(docProperties *DocProperties) (err error) {
 func (f *File) GetDocProps() (ret *DocProperties, err error) {
 	var core = new(decodeCoreProperties)
 
-	if err = f.xmlNewDecoder(bytes.NewReader(namespaceStrictToTransitional(f.readXML("docProps/core.xml")))).
+	if err = f.xmlNewDecoder(bytes.NewReader(namespaceStrictToTransitional(f.readXML(dafaultXMLPathDocPropsCore)))).
 		Decode(core); err != nil && err != io.EOF {
 		err = fmt.Errorf("xml decode error: %s", err)
 		return

docProps_test.go

@@ -35,13 +35,13 @@ func TestSetAppProps(t *testing.T) {
 		AppVersion:        "16.0000",
 	}))
 	assert.NoError(t, f.SaveAs(filepath.Join("test", "TestSetAppProps.xlsx")))
-	f.Pkg.Store("docProps/app.xml", nil)
+	f.Pkg.Store(dafaultXMLPathDocPropsApp, nil)
 	assert.NoError(t, f.SetAppProps(&AppProperties{}))
 	assert.NoError(t, f.Close())
 
 	// Test unsupported charset
 	f = NewFile()
-	f.Pkg.Store("docProps/app.xml", MacintoshCyrillicCharset)
+	f.Pkg.Store(dafaultXMLPathDocPropsApp, MacintoshCyrillicCharset)
 	assert.EqualError(t, f.SetAppProps(&AppProperties{}), "xml decode error: XML syntax error on line 1: invalid UTF-8")
 }
 
@@ -53,14 +53,14 @@ func TestGetAppProps(t *testing.T) {
 	props, err := f.GetAppProps()
 	assert.NoError(t, err)
 	assert.Equal(t, props.Application, "Microsoft Macintosh Excel")
-	f.Pkg.Store("docProps/app.xml", nil)
+	f.Pkg.Store(dafaultXMLPathDocPropsApp, nil)
 	_, err = f.GetAppProps()
 	assert.NoError(t, err)
 	assert.NoError(t, f.Close())
 
 	// Test unsupported charset
 	f = NewFile()
-	f.Pkg.Store("docProps/app.xml", MacintoshCyrillicCharset)
+	f.Pkg.Store(dafaultXMLPathDocPropsApp, MacintoshCyrillicCharset)
 	_, err = f.GetAppProps()
 	assert.EqualError(t, err, "xml decode error: XML syntax error on line 1: invalid UTF-8")
 }
@@ -87,13 +87,13 @@ func TestSetDocProps(t *testing.T) {
 		Version:        "1.0.0",
 	}))
 	assert.NoError(t, f.SaveAs(filepath.Join("test", "TestSetDocProps.xlsx")))
-	f.Pkg.Store("docProps/core.xml", nil)
+	f.Pkg.Store(dafaultXMLPathDocPropsCore, nil)
 	assert.NoError(t, f.SetDocProps(&DocProperties{}))
 	assert.NoError(t, f.Close())
 
 	// Test unsupported charset
 	f = NewFile()
-	f.Pkg.Store("docProps/core.xml", MacintoshCyrillicCharset)
+	f.Pkg.Store(dafaultXMLPathDocPropsCore, MacintoshCyrillicCharset)
 	assert.EqualError(t, f.SetDocProps(&DocProperties{}), "xml decode error: XML syntax error on line 1: invalid UTF-8")
 }
 
@@ -105,14 +105,14 @@ func TestGetDocProps(t *testing.T) {
 	props, err := f.GetDocProps()
 	assert.NoError(t, err)
 	assert.Equal(t, props.Creator, "Microsoft Office User")
-	f.Pkg.Store("docProps/core.xml", nil)
+	f.Pkg.Store(dafaultXMLPathDocPropsCore, nil)
 	_, err = f.GetDocProps()
 	assert.NoError(t, err)
 	assert.NoError(t, f.Close())
 
 	// Test unsupported charset
 	f = NewFile()
-	f.Pkg.Store("docProps/core.xml", MacintoshCyrillicCharset)
+	f.Pkg.Store(dafaultXMLPathDocPropsCore, MacintoshCyrillicCharset)
 	_, err = f.GetDocProps()
 	assert.EqualError(t, err, "xml decode error: XML syntax error on line 1: invalid UTF-8")
 }

errors.go

@@ -143,8 +143,8 @@ var (
 	// characters length that exceeds the limit.
 	ErrCellCharsLength = fmt.Errorf("cell value must be 0-%d characters", TotalCellChars)
 	// ErrOptionsUnzipSizeLimit defined the error message for receiving
-	// invalid UnzipSizeLimit and WorksheetUnzipMemLimit.
-	ErrOptionsUnzipSizeLimit = errors.New("the value of UnzipSizeLimit should be greater than or equal to WorksheetUnzipMemLimit")
+	// invalid UnzipSizeLimit and UnzipXMLSizeLimit.
+	ErrOptionsUnzipSizeLimit = errors.New("the value of UnzipSizeLimit should be greater than or equal to UnzipXMLSizeLimit")
 	// ErrSave defined the error message for saving file.
 	ErrSave = errors.New("no path defined for file, consider File.WriteTo or File.Write")
 	// ErrAttrValBool defined the error message on marshal and unmarshal