Merge pull request #9 from setnicka/master

Allow to parse of elements of multiple types

Author: tamerh

README.md

@@ -1,7 +1,8 @@
-## xml stream parser 
-xml-stream-parser is xml parser for GO. It is efficient to parse large xml data with streaming fashion. 
+# xml stream parser
 
-### Usage
+xml-stream-parser is xml parser for GO. It is efficient to parse large xml data with streaming fashion.
+
+## Usage
 
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
@@ -22,46 +23,50 @@ xml-stream-parser is xml parser for GO. It is efficient to parse large xml data
          <userComment rating="4">Excellent overview of world literature.</userComment>
       </comments>
    </book>
+   <journal>
+      <title>Journal of XML parsing</title>
+      <issue>1</issue>
+   </journal>
 </bookstore>
 ```
 
-<b>Stream</b> over books
-```go
-
+**Stream** over books and journals
 
+```go
 f, _ := os.Open("input.xml")
 br := bufio.NewReaderSize(f,65536)
-parser := xmlparser.NewXMLParser(br, "book")
+parser := xmlparser.NewXMLParser(br, "book", "journal")
 
 for xml := range parser.Stream() {
-	fmt.Println(xml.Childs["title"][0].InnerText)
-	fmt.Println(xml.Childs["comments"][0].Childs["userComment"][0].Attrs["rating"])
-	fmt.Println(xml.Childs["comments"][0].Childs["userComment"][0].InnerText)
+   fmt.Println(xml.Childs["title"][0].InnerText)
+   if xml.Name == "book" {
+      fmt.Println(xml.Childs["comments"][0].Childs["userComment"][0].Attrs["rating"])
+      fmt.Println(xml.Childs["comments"][0].Childs["userComment"][0].InnerText)
+   }
 }
-   
 ```
 
-<b>Skip</b> tags for speed
+**Skip** tags for speed
+
 ```go
 parser := xmlparser.NewXMLParser(br, "book").SkipElements([]string{"price", "comments"})
 ```
 
-<b>Error</b> handlings
+**Error** handlings
+
 ```go
 for xml := range parser.Stream() {
-   if xml.Err !=nil { 
+   if xml.Err !=nil {
       // handle error
    }
 }
 ```
 
-<b>Progress</b> of parsing
+**Progress** of parsing
+
 ```go
 // total byte read to calculate the progress of parsing
 parser.TotalReadSize
 ```
 
-
-
-
 If you interested check also [json parser](https://github.com/tamerh/jsparser) which works similarly

xmlparser.go

@@ -8,7 +8,7 @@ import (
 
 type XMLParser struct {
 	reader            *bufio.Reader
-	loopElement       string
+	loopElements      map[string]bool
 	resultChannel     chan *XMLElement
 	skipElements      map[string]bool
 	skipOuterElements bool
@@ -18,22 +18,29 @@ type XMLParser struct {
 }
 
 type XMLElement struct {
+	Name      string
 	Attrs     map[string]string
 	InnerText string
 	Childs    map[string][]XMLElement
 	Err       error
 }
 
-func NewXMLParser(reader *bufio.Reader, loopElement string) *XMLParser {
+func NewXMLParser(reader *bufio.Reader, loopElements ...string) *XMLParser {
 
 	x := &XMLParser{
 		reader:        reader,
-		loopElement:   loopElement,
+		loopElements:  map[string]bool{},
 		resultChannel: make(chan *XMLElement, 256),
 		skipElements:  map[string]bool{},
 		scratch:       &scratch{data: make([]byte, 1024)},
 		scratch2:      &scratch{data: make([]byte, 1024)},
 	}
+
+	// Register loop elements
+	for _, e := range loopElements {
+		x.loopElements[e] = true
+	}
+
 	return x
 }
 
@@ -69,7 +76,6 @@ func (x *XMLParser) parse() {
 
 	defer close(x.resultChannel)
 	var element *XMLElement
-	var tagName string
 	var tagClosed bool
 	var err error
 	var b byte
@@ -116,29 +122,29 @@ func (x *XMLParser) parse() {
 				continue
 			}
 
-			tagName, element, tagClosed, err = x.startElement()
+			element, tagClosed, err = x.startElement()
 
 			if err != nil {
 				x.sendError()
 				return
 			}
 
-			if tagName == x.loopElement {
+			if _, found := x.loopElements[element.Name]; found {
 				if tagClosed {
 					x.resultChannel <- element
 					continue
 				}
 
-				element = x.getElementTree(tagName, element)
+				element = x.getElementTree(element)
 				x.resultChannel <- element
 				if element.Err != nil {
 					return
 				}
 			} else if x.skipOuterElements {
 
-				if _, ok := x.skipElements[tagName]; ok && !tagClosed {
+				if _, ok := x.skipElements[element.Name]; ok && !tagClosed {
 
-					err = x.skipElement(tagName)
+					err = x.skipElement(element.Name)
 					if err != nil {
 						x.sendError()
 						return
@@ -154,7 +160,7 @@ func (x *XMLParser) parse() {
 
 }
 
-func (x *XMLParser) getElementTree(tagName string, result *XMLElement) *XMLElement {
+func (x *XMLParser) getElementTree(result *XMLElement) *XMLElement {
 
 	if result.Err != nil {
 		return result
@@ -166,7 +172,6 @@ func (x *XMLParser) getElementTree(tagName string, result *XMLElement) *XMLEleme
 	var element *XMLElement
 	var tagClosed bool
 	x.scratch2.reset() // this hold the inner text
-	var tagName2 string
 	var iscomment bool
 
 	for {
@@ -219,7 +224,7 @@ func (x *XMLParser) getElementTree(tagName string, result *XMLElement) *XMLEleme
 					return result
 				}
 
-				if tag == tagName {
+				if tag == result.Name {
 					if len(result.Childs) == 0 {
 						result.InnerText = string(x.scratch2.bytes())
 					}
@@ -229,34 +234,34 @@ func (x *XMLParser) getElementTree(tagName string, result *XMLElement) *XMLEleme
 				x.unreadByte()
 			}
 
-			tagName2, element, tagClosed, err = x.startElement()
+			element, tagClosed, err = x.startElement()
 
 			if err != nil {
 				result.Err = err
 				return result
 			}
 
-			if _, ok := x.skipElements[tagName2]; ok && !tagClosed {
-				err = x.skipElement(tagName2)
+			if _, ok := x.skipElements[element.Name]; ok && !tagClosed {
+				err = x.skipElement(element.Name)
 				if err != nil {
 					result.Err = err
 					return result
 				}
 				continue
 			}
 			if !tagClosed {
-				element = x.getElementTree(tagName2, element)
+				element = x.getElementTree(element)
 			}
 
-			if _, ok := result.Childs[tagName2]; ok {
-				result.Childs[tagName2] = append(result.Childs[tagName2], *element)
+			if _, ok := result.Childs[element.Name]; ok {
+				result.Childs[element.Name] = append(result.Childs[element.Name], *element)
 			} else {
 				var childs []XMLElement
 				childs = append(childs, *element)
 				if result.Childs == nil {
 					result.Childs = map[string][]XMLElement{}
 				}
-				result.Childs[tagName2] = childs
+				result.Childs[element.Name] = childs
 			}
 
 		} else {
@@ -302,7 +307,7 @@ func (x *XMLParser) skipElement(elname string) error {
 	}
 }
 
-func (x *XMLParser) startElement() (string, *XMLElement, bool, error) {
+func (x *XMLParser) startElement() (*XMLElement, bool, error) {
 
 	x.scratch.reset()
 
@@ -313,26 +318,27 @@ func (x *XMLParser) startElement() (string, *XMLElement, bool, error) {
 	// a tag have 3 forms * <abc > ** <abc type="foo" val="bar"/> *** <abc />
 	var attr string
 	var attrVal string
-	var tagName string
 	for {
 
 		cur, err = x.readByte()
 
 		if err != nil {
-			return "", nil, false, x.defaultError()
+			return nil, false, x.defaultError()
 		}
 
 		if x.isWS(cur) {
-			tagName = string(x.scratch.bytes())
+			result.Name = string(x.scratch.bytes())
 			x.scratch.reset()
 			goto search_close_tag
 		}
 
 		if cur == '>' {
 			if prev == '/' {
-				return string(x.scratch.bytes()[:len(x.scratch.bytes())-1]), result, true, nil
+				result.Name = string(x.scratch.bytes()[:len(x.scratch.bytes())-1])
+				return result, true, nil
 			}
-			return string(x.scratch.bytes()), result, false, nil
+			result.Name = string(x.scratch.bytes())
+			return result, false, nil
 		}
 		x.scratch.add(cur)
 		prev = cur
@@ -344,7 +350,7 @@ search_close_tag:
 		cur, err = x.readByte()
 
 		if err != nil {
-			return "", nil, false, x.defaultError()
+			return nil, false, x.defaultError()
 		}
 
 		if x.isWS(cur) {
@@ -359,17 +365,17 @@ search_close_tag:
 			cur, err = x.readByte()
 
 			if err != nil {
-				return "", nil, false, x.defaultError()
+				return nil, false, x.defaultError()
 			}
 
 			if !(cur == '"' || cur == '\'') {
-				return "", nil, false, x.defaultError()
+				return nil, false, x.defaultError()
 			}
 
 			attr = string(x.scratch.bytes())
 			attrVal, err = x.string(cur)
 			if err != nil {
-				return "", nil, false, x.defaultError()
+				return nil, false, x.defaultError()
 			}
 			result.Attrs[attr] = attrVal
 			x.scratch.reset()
@@ -378,9 +384,9 @@ search_close_tag:
 
 		if cur == '>' { //if tag name not found
 			if prev == '/' { //tag special close
-				return tagName, result, true, nil
+				return result, true, nil
 			}
-			return tagName, result, false, nil
+			return result, false, nil
 		}
 
 		x.scratch.add(cur)

xmlparser_test.go

@@ -6,18 +6,18 @@ import (
 	"testing"
 )
 
-func getparser(prop string) *XMLParser {
+func getparser(prop ...string) *XMLParser {
 
-	return getparserFile("sample.xml", prop)
+	return getparserFile("sample.xml", prop...)
 }
 
-func getparserFile(filename, prop string) *XMLParser {
+func getparserFile(filename string, prop ...string) *XMLParser {
 
 	file, _ := os.Open(filename)
 
 	br := bufio.NewReader(file)
 
-	p := NewXMLParser(br, prop)
+	p := NewXMLParser(br, prop...)
 
 	return p
 
@@ -232,6 +232,47 @@ func TestError(t *testing.T) {
 
 }
 
+func TestMultipleTags(t *testing.T) {
+	p := getparser("tag1", "tag2")
+
+	tagCount := map[string]int{}
+	for xml := range p.Stream() {
+		if xml.Name != "tag1" && xml.Name != "tag2" {
+			t.Errorf("Only 'tag1' and 'tag2' expected, but '%s' returned", xml.Name)
+		}
+		tagCount[xml.Name]++
+	}
+
+	if tagCount["tag1"] != 2 {
+		t.Errorf("There should be 2 parsed 'tag1', but %d found", tagCount["tag1"])
+	}
+	if tagCount["tag2"] != 2 {
+		t.Errorf("There should be 2 parsed 'tag2', but %d found", tagCount["tag2"])
+	}
+}
+
+func TestMultipleTagsNested(t *testing.T) {
+	p := getparser("tag1", "tag11")
+
+	tagCount := map[string]int{}
+	for xml := range p.Stream() {
+		if xml.Name != "tag1" && xml.Name != "tag11" {
+			t.Errorf("Only 'tag1' and 'tag11' expected, but '%s' returned", xml.Name)
+		}
+		tagCount[xml.Name]++
+	}
+
+	if tagCount["tag1"] != 2 {
+		t.Errorf("There should be 2 parsed 'tag1', but %d found", tagCount["tag1"])
+	}
+	if tagCount["tag11"] != 1 {
+		if tagCount["tag11"] == 4 {
+			t.Errorf("There should be only 1 parsed 'tag11', but 'tag11' nested under 'tag1' were parsed too")
+		}
+		t.Errorf("There should be 1 parsed 'tag11', but %d found", tagCount["tag11"])
+	}
+}
+
 func Benchmark1(b *testing.B) {
 
 	for n := 0; n < b.N; n++ {