Initial commit; substitutions can be reviewed, no further functionality implemented yet

Pods/SwiftSoup/Sources/TreeBuilder.swift

@@ -0,0 +1,98 @@
+//
+//  TreeBuilder.swift
+//  SwiftSoup
+//
+//  Created by Nabil Chatbi on 24/10/16.
+//  Copyright © 2016 Nabil Chatbi.. All rights reserved.
+//
+
+import Foundation
+
+public class TreeBuilder {
+    public var reader: CharacterReader
+    var tokeniser: Tokeniser
+    public var doc: Document // current doc we are building into
+    public var stack: Array<Element> // the stack of open elements
+    public var baseUri: String // current base uri, for creating new elements
+    public var currentToken: Token? // currentToken is used only for error tracking.
+    public var errors: ParseErrorList // null when not tracking errors
+    public var settings: ParseSettings
+
+    private let start: Token.StartTag = Token.StartTag() // start tag to process
+    private let end: Token.EndTag  = Token.EndTag()
+
+    public func defaultSettings() -> ParseSettings {preconditionFailure("This method must be overridden")}
+
+    public init() {
+        doc =  Document("")
+        reader = CharacterReader("")
+        tokeniser = Tokeniser(reader, nil)
+        stack = Array<Element>()
+        baseUri = ""
+        errors = ParseErrorList(0, 0)
+        settings = ParseSettings(false, false)
+    }
+
+    public func initialiseParse(_ input: String, _ baseUri: String, _ errors: ParseErrorList, _ settings: ParseSettings) {
+        doc = Document(baseUri)
+        self.settings = settings
+        reader = CharacterReader(input)
+        self.errors = errors
+        tokeniser = Tokeniser(reader, errors)
+        stack = Array<Element>()
+        self.baseUri = baseUri
+    }
+
+    func parse(_ input: String, _ baseUri: String, _ errors: ParseErrorList, _ settings: ParseSettings)throws->Document {
+		initialiseParse(input, baseUri, errors, settings)
+        try runParser()
+        return doc
+    }
+
+    public func runParser()throws {
+        while (true) {
+            let token: Token = try tokeniser.read()
+            try process(token)
+            token.reset()
+
+            if (token.type == Token.TokenType.EOF) {
+                break
+            }
+        }
+    }
+
+    @discardableResult
+    public func process(_ token: Token)throws->Bool {preconditionFailure("This method must be overridden")}
+
+    @discardableResult
+    public func processStartTag(_ name: String)throws->Bool {
+        if (currentToken === start) { // don't recycle an in-use token
+            return try process(Token.StartTag().name(name))
+        }
+        return try process(start.reset().name(name))
+    }
+
+    @discardableResult
+    public func processStartTag(_ name: String, _ attrs: Attributes)throws->Bool {
+        if (currentToken === start) { // don't recycle an in-use token
+            return try process(Token.StartTag().nameAttr(name, attrs))
+        }
+        start.reset()
+        start.nameAttr(name, attrs)
+        return try process(start)
+    }
+
+    @discardableResult
+    public func processEndTag(_ name: String)throws->Bool {
+    if (currentToken === end) { // don't recycle an in-use token
+    return try process(Token.EndTag().name(name))
+    }
+
+    return try process(end.reset().name(name))
+    }
+
+    public func currentElement() -> Element? {
+        let size: Int = stack.count
+        return size > 0 ? stack[size-1] : nil
+    }
+}