Test we can create a RefTable, populate it, use it to deference shared string

IDs and derive an xlsxSST from it.

sharedstrings.go

@@ -4,8 +4,8 @@ package xlsx
 // http://schemas.openxmlformats.org/spreadsheetml/2006/main currently
 // I have not checked this for completeness - it does as much as need.
 type xlsxSST struct {
-	Count       string   `xml:"count,attr"`
-	UniqueCount string   `xml:"uniqueCount,attr"`
+	Count       int   `xml:"count,attr"`
+	UniqueCount int   `xml:"uniqueCount,attr"`
 	SI          []xlsxSI `xml:"si"`
 }
 
@@ -34,12 +34,20 @@ type xlsxR struct {
 // 	Data string `xml:"chardata"`
 // }
 
+
+type RefTable []string
+
+// NewSharedStringRefTable() creates a new, empty RefTable.
+func NewSharedStringRefTable() RefTable {
+	return RefTable{}
+}
+
 // MakeSharedStringRefTable() takes an xlsxSST struct and converts
 // it's contents to an slice of strings used to refer to string values
 // by numeric index - this is the model used within XLSX worksheet (a
 // numeric reference is stored to a shared cell value).
-func MakeSharedStringRefTable(source *xlsxSST) []string {
-	reftable := make([]string, len(source.SI))
+func MakeSharedStringRefTable(source *xlsxSST) RefTable {
+	reftable := make(RefTable, len(source.SI))
 	for i, si := range source.SI {
 		if len(si.R) > 0 {
 			for j := 0; j < len(si.R); j++ {
@@ -52,10 +60,24 @@ func MakeSharedStringRefTable(source *xlsxSST) []string {
 	return reftable
 }
 
-// ResolveSharedString() looks up a string value by numeric index from
+// NewXlsxSSTFromRefTable() takes a RefTable and returns and
+// equivalent xlsxSST representation.
+func NewXlsxSSTFromRefTable(refTable RefTable) xlsxSST {
+	sst := xlsxSST{}
+	sst.Count = len(refTable)
+	sst.UniqueCount = sst.Count
+	for _, ref := range refTable {
+		si := xlsxSI{}
+		si.T = ref
+		sst.SI = append(sst.SI, si)
+	}
+	return sst
+}
+
+// Resolvesharedstring() looks up a string value by numeric index from
 // a provided reference table (just a slice of strings in the correct
 // order).  This function only exists to provide clarity or purpose
 // via it's name.
-func ResolveSharedString(reftable []string, index int) string {
-	return reftable[index]
+func (rt RefTable) ResolveSharedString(index int) string {
+	return rt[index]
 }

sharedstrings_test.go

@@ -33,6 +33,14 @@ func (s *SharedStringsSuite) SetUpTest(c *C) {
         </sst>`)
 }
 
+func (s *SharedStringsSuite) TestCreateNewSharedStringRefTable(c *C) {
+	refTable := NewSharedStringRefTable()
+	refTable = append(refTable, "Foo")
+	refTable = append(refTable, "Bar")
+	c.Assert(refTable.ResolveSharedString(0), Equals, "Foo")
+	c.Assert(refTable.ResolveSharedString(1), Equals, "Bar")
+}
+
 // Test we can correctly convert a xlsxSST into a reference table
 // using xlsx.MakeSharedStringRefTable().
 func (s *SharedStringsSuite) TestMakeSharedStringRefTable(c *C) {
@@ -45,13 +53,14 @@ func (s *SharedStringsSuite) TestMakeSharedStringRefTable(c *C) {
 	c.Assert(reftable[1], Equals, "Bar")
 }
 
-// Test we can correctly resolve a numeric reference in the reference table to a string value using xlsx.ResolveSharedString().
+// Test we can correctly resolve a numeric reference in the reference
+// table to a string value using RefTable.ResolveSharedString().
 func (s *SharedStringsSuite) TestResolveSharedString(c *C) {
 	sst := new(xlsxSST)
 	err := xml.NewDecoder(s.SharedStringsXML).Decode(sst)
 	c.Assert(err, IsNil)
 	reftable := MakeSharedStringRefTable(sst)
-	c.Assert(ResolveSharedString(reftable, 0), Equals, "Foo")
+	c.Assert(reftable.ResolveSharedString(0), Equals, "Foo")
 }
 
 // Test we can correctly unmarshal an the sharedstrings.xml file into
@@ -60,9 +69,23 @@ func (s *SharedStringsSuite) TestUnmarshallSharedStrings(c *C) {
 	sst := new(xlsxSST)
 	err := xml.NewDecoder(s.SharedStringsXML).Decode(sst)
 	c.Assert(err, IsNil)
-	c.Assert(sst.Count, Equals, "4")
-	c.Assert(sst.UniqueCount, Equals, "4")
+	c.Assert(sst.Count, Equals, 4)
+	c.Assert(sst.UniqueCount, Equals, 4)
 	c.Assert(sst.SI, HasLen, 4)
 	si := sst.SI[0]
 	c.Assert(si.T, Equals, "Foo")
 }
+
+// Test we can correctly create the xlsx.xlsxSST struct from a RefTable
+func (s *SharedStringsSuite) TestNewXLSXSSTFromRefTable(c *C) {
+	refTable := NewSharedStringRefTable()
+	refTable = append(refTable, "Foo")
+	refTable = append(refTable, "Bar")
+	sst := NewXlsxSSTFromRefTable(refTable)
+	c.Assert(sst, NotNil)
+	c.Assert(sst.Count, Equals, 2)
+	c.Assert(sst.UniqueCount, Equals, 2)
+	c.Assert(sst.SI, HasLen, 2)
+	si := sst.SI[0]
+	c.Assert(si.T, Equals, "Foo")
+}