cleaned up much of the code

Author: dchenk

format_state.go

@@ -7,14 +7,12 @@ import (
 )
 
 // A formatState holds the current state of open tag, class, or style formats.
-type formatState struct {
-	open []*Format // the list of currently open attribute tags
-}
+type formatState []*Format // the list of currently open attribute tags
 
 // hasSet says if the given format is already opened.
 func (fs *formatState) hasSet(fm *Format) bool {
-	for i := range fs.open {
-		if fs.open[i].Place == fm.Place && fs.open[i].Val == fm.Val {
+	for i := range *fs {
+		if (*fs)[i].Place == fm.Place && (*fs)[i].Val == fm.Val {
 			return true
 		}
 	}
@@ -25,19 +23,19 @@ func (fs *formatState) hasSet(fm *Format) bool {
 // in the opposite order in which they were opened.
 func (fs *formatState) closePrevious(buf *bytes.Buffer, o *Op, doingBlock bool) {
 
-	closedTemp := &formatState{}
+	closedTemp := make(formatState, 0, 1)
 
-	for i := len(fs.open) - 1; i >= 0; i-- { // Start with the last format opened.
+	for i := len(*fs) - 1; i >= 0; i-- { // Start with the last format opened.
 
-		f := fs.open[i]
+		f := (*fs)[i]
 
 		// If this format is not set on the current Op, close it.
-		if (!f.wrap && !f.fm.HasFormat(o)) || (f.wrap && f.fm.(FormatWrapper).Close(fs.open, o, doingBlock)) {
+		if (!f.wrap && !f.fm.HasFormat(o)) || (f.wrap && f.fm.(FormatWrapper).Close(*fs, o, doingBlock)) {
 
 			// If we need to close a tag after which there are tags that should stay open, close the following tags for now.
-			if i < len(fs.open)-1 {
-				for ij := len(fs.open) - 1; ij > i; ij-- {
-					closedTemp.add(fs.open[ij])
+			if i < len(*fs)-1 {
+				for ij := len(*fs) - 1; ij > i; ij-- {
+					closedTemp.add((*fs)[ij])
 					fs.pop(buf)
 				}
 			}
@@ -50,29 +48,29 @@ func (fs *formatState) closePrevious(buf *bytes.Buffer, o *Op, doingBlock bool)
 
 	// Re-open the temporarily closed formats.
 	closedTemp.writeFormats(buf)
-	fs.open = append(fs.open, closedTemp.open...) // Copy after the sorting.
+	*fs = append(*fs, closedTemp...) // Copy after the sorting.
 
 }
 
 // pop removes the last format from the state of currently open formats.
 func (fs *formatState) pop(buf *bytes.Buffer) {
-	indx := len(fs.open) - 1
-	if fs.open[indx].wrap {
-		buf.WriteString(fs.open[indx].wrapPost)
-	} else if fs.open[indx].Place == Tag {
-		closeTag(buf, fs.open[indx].Val)
+	indx := len(*fs) - 1
+	if (*fs)[indx].wrap {
+		buf.WriteString((*fs)[indx].wrapPost)
+	} else if (*fs)[indx].Place == Tag {
+		closeTag(buf, (*fs)[indx].Val)
 	} else {
 		closeTag(buf, "span")
 	}
-	fs.open = fs.open[:indx]
+	*fs = (*fs)[:indx]
 }
 
 // add adds a format that the string that will be written to buf right after this will have.
 // Before calling add, check if the Format is already opened up earlier.
 // Do not use add to write block-level styles (those are written by o.writeBlock after being merged).
 func (fs *formatState) add(f *Format) {
 	if f.Place < 3 { // Check if the Place is valid.
-		fs.open = append(fs.open, f)
+		*fs = append(*fs, f)
 	}
 }
 
@@ -82,24 +80,24 @@ func (fs *formatState) writeFormats(buf *bytes.Buffer) {
 
 	sort.Sort(fs) // Ensure that the serialization is consistent even if attribute ordering in a map changes.
 
-	for i := range fs.open {
+	for i := range *fs {
 
-		if fs.open[i].wrap {
-			buf.WriteString(fs.open[i].Val) // The complete opening or closing wrap is given.
+		if (*fs)[i].wrap {
+			buf.WriteString((*fs)[i].Val) // The complete opening or closing wrap is given.
 			continue
 		}
 
 		buf.WriteByte('<')
 
-		switch fs.open[i].Place {
+		switch (*fs)[i].Place {
 		case Tag:
-			buf.WriteString(fs.open[i].Val)
+			buf.WriteString((*fs)[i].Val)
 		case Class:
 			buf.WriteString("span class=")
-			buf.WriteString(strconv.Quote(fs.open[i].Val))
+			buf.WriteString(strconv.Quote((*fs)[i].Val))
 		case Style:
 			buf.WriteString("span style=")
-			buf.WriteString(strconv.Quote(fs.open[i].Val))
+			buf.WriteString(strconv.Quote((*fs)[i].Val))
 		}
 
 		buf.WriteByte('>')
@@ -110,29 +108,27 @@ func (fs *formatState) writeFormats(buf *bytes.Buffer) {
 
 // Implement the sort.Interface interface.
 
-func (fs *formatState) Len() int {
-	return len(fs.open)
-}
+func (fs *formatState) Len() int { return len(*fs) }
 
 func (fs *formatState) Less(i, j int) bool {
 
 	// Formats that implement the FormatWrapper interface are written first.
-	if _, ok := fs.open[i].fm.(FormatWrapper); ok {
+	if _, ok := (*fs)[i].fm.(FormatWrapper); ok {
 		return true
-	} else if _, ok := fs.open[j].fm.(FormatWrapper); ok {
+	} else if _, ok := (*fs)[j].fm.(FormatWrapper); ok {
 		return false
 	}
 
 	// Tags are written first, then classes, and then style attributes.
-	if fs.open[i].Place != fs.open[j].Place {
-		return fs.open[i].Place < fs.open[j].Place
+	if (*fs)[i].Place != (*fs)[j].Place {
+		return (*fs)[i].Place < (*fs)[j].Place
 	}
 
 	// Simply check values.
-	return fs.open[i].Val < fs.open[j].Val
+	return (*fs)[i].Val < (*fs)[j].Val
 
 }
 
 func (fs *formatState) Swap(i, j int) {
-	fs.open[i], fs.open[j] = fs.open[j], fs.open[i]
+	(*fs)[i], (*fs)[j] = (*fs)[j], (*fs)[i]
 }

format_state_test.go

@@ -55,32 +55,31 @@ func TestFormatState_add(t *testing.T) {
 		},
 	}
 
-	fs := new(formatState) // reuse
+	fs := make(formatState, 0, 2) // reuse
 
 	for i, ca := range cases {
 
-		fs.open = ca.current
+		fs = ca.current
 
 		fmTer := ca.o.getFormatter(ca.keyword, nil)
 		fm := fmTer.Fmt()
 		fm.fm = fmTer
 
 		fs.add(fm)
 
-		if len(ca.want) != len(fs.open) {
-			t.Errorf("(index %d) unequal count of formats", i)
-			t.FailNow()
+		if len(ca.want) != len(fs) {
+			t.Fatalf("(index %d) unequal count of formats", i)
 		}
 
-		for j := range fs.open {
-			if ca.want[j].Val != fs.open[j].Val {
-				t.Errorf("did not add format Val correctly (index %d); got %q", i, fs.open[j].Val)
+		for j := range fs {
+			if ca.want[j].Val != fs[j].Val {
+				t.Errorf("did not add format Val correctly (index %d); got %q", i, fs[j].Val)
 			}
-			if ca.want[j].Place != fs.open[j].Place {
-				t.Errorf("did not add format Place correctly (index %d); got %v", i, fs.open[j].Place)
+			if ca.want[j].Place != fs[j].Place {
+				t.Errorf("did not add format Place correctly (index %d); got %v", i, fs[j].Place)
 			}
-			if ca.want[j].Block != fs.open[j].Block {
-				t.Errorf("did not add format Block correctly (index %d); got %v", i, fs.open[j].Block)
+			if ca.want[j].Block != fs[j].Block {
+				t.Errorf("did not add format Block correctly (index %d); got %v", i, fs[j].Block)
 			}
 		}
 
@@ -99,27 +98,27 @@ func TestFormatState_closePrevious(t *testing.T) {
 	o2.Attrs["italic"] = "y"
 
 	cases := []formatState{
-		{[]*Format{
+		{
 			{"em", Tag, false, false, "", "", o1.getFormatter("italic", nil)},
 			{"strong", Tag, false, false, "", "", o1.getFormatter("bold", nil)},
-		}},
-		{[]*Format{
+		},
+		{
 			{"background-color:#e0e0e0;", Style, false, false, "", "", o2.getFormatter("background", nil)},
 			{"em", Tag, false, false, "", "", o2.getFormatter("italic", nil)},
-		}},
+		},
 	}
 
 	want := []string{"</strong></em>", "</em></span>"}
 
-	buf := new(bytes.Buffer)
+	var buf bytes.Buffer
 
 	for i := range cases {
 
 		o := blankOp()
 
-		cases[i].closePrevious(buf, o, false)
+		cases[i].closePrevious(&buf, o, false)
 		got := buf.String()
-		if got != want[i] || len(cases[i].open) != 0 {
+		if got != want[i] || len(cases[i]) != 0 {
 			t.Errorf("closed formats wrong (index %d); wanted %q; got %q", i, want[i], got)
 		}
 
@@ -187,38 +186,38 @@ func TestFormatState_Sort(t *testing.T) {
 
 	for i := range cases {
 
-		fsCase := new(formatState)
+		fsCase := make(formatState, 0, 1)
 		for _, s := range cases[i] {
-			fsCase.open = append(fsCase.open, &Format{
+			fsCase = append(fsCase, &Format{
 				Val:   s.Val,
 				Place: s.Place,
 				fm:    o.getFormatter(s.keyword, nil),
 			})
 		}
 
-		sort.Sort(fsCase)
+		sort.Sort(&fsCase)
 
-		fsWant := new(formatState)
+		fsWant := make(formatState, 0, 1)
 		for _, s := range want[i] {
-			fsWant.open = append(fsWant.open, &Format{
+			fsWant = append(fsWant, &Format{
 				Val:   s.Val,
 				Place: s.Place,
 				fm:    o.getFormatter(s.keyword, nil),
 			})
 		}
 
 		ok := true
-		for j := range fsCase.open {
-			if fsCase.open[j].Val != fsWant.open[j].Val {
+		for j := range fsCase {
+			if fsCase[j].Val != fsWant[j].Val {
 				ok = false
-			} else if fsCase.open[j].Place != fsWant.open[j].Place {
+			} else if fsCase[j].Place != fsWant[j].Place {
 				ok = false
 			}
 		}
 		if !ok {
 			t.Errorf("bad sorting (index %d); got:\n", i)
-			for k := range fsCase.open {
-				t.Errorf("  (%d) %+v\n", k, *fsCase.open[k])
+			for k := range fsCase {
+				t.Errorf("  (%d) %+v\n", k, fsCase[k])
 			}
 		}