(Expansion) Retrieve articles from an XML parser

Thing is, since the code for the XML parser is a bit more complicated, it's harder to pass variables around just like with Lunch Card.

Not sure how ArticleInfo is an integer

Code Block 
                        ArticleRow(image: article.img, title: article.title, author: article.author, date: article.date)

You need to pass the right type.

Your new ArticlesParser lacks the property articles and it does not compile.

So do I redefine it? I'm still a little confused.

Sorry, I do not understand why you removed it. It is I who is confused.

Code Block 
class ArticlesInfo: ObservableObject {
    var dataUrl = URL(string: https://storage.googleapis.com/thehairsociety/2021/03/2f23e2d4-ths.xml)
    func loadArticles() {
        do {
            if FileManager.default.fileExists(atPath: dataUrl!.path) {
                return
            }
            //Read `Data` from a file specified by URL
            let data = try Data(contentsOf: dataUrl!)
            //Parse Available Articles
            let articles = try // ArticlesParser?  JSONDecoder?
            self.articles = articles // <-- Value of type 'ArticlesInfo' has no property 'articles'
        } catch {
            print(error)
        }
    }
}

ArticlesParser now holds articles as a published variable. 

But ArticlesInfo - where the loadArticles() function is held - now cannot call articles because that property does not exist in ArticlesInfo.

On the topic of using the Lunch Card method, would using JSON be easier to use than XML?

Why did you remove articles? I completely do not understand why.

You can do it in the same way:

Code Block 
class ArticlesInfo: ObservableObject {
  @Published var articles: ...
    //...    
    func loadArticles() {
      // Use `ArticlesParser` here
      //...
    }
}

Code Block 
import Foundation
struct ArticleInfo: Identifiable, Codable {
    var id: String = ""
    var title: String = ""
    var date: Date?
    var author: String = ""
    var img: URL?
    var content: String = ""
}
class ArticlesInfo: ObservableObject {
    @Published var articles: [ArticleInfo] = []
    var dataUrl = URL(string: "https://storage.googleapis.com/thehairsociety/2021/03/2f23e2d4-ths.xml")
    
    func loadArticles() {
        do {
            let data = try Data(contentsOf: dataUrl!)
            let parser = ArticlesParser(data: data)
            if parser.parse() {
                print(parser.articles) // Value of type 'ArticlesParser' has no property 'articles'
                let articles: try //...?
                self.articles = articles // Unsure what I put here
            } else {
                if let error = parser.parserError {
                    print(error)
                } else {
                    print("Failed with unknown reason")
                }
            }
        } catch {
            print(error)
        }
    }
}
class ArticlesParser: XMLParser {
    var dateTimeZone = TimeZone(abbreviation: "GMT-6")
    lazy var dateFormater: DateFormatter = {
        let df = DateFormatter()
        df.locale = Locale(identifier: "en_US_POSIX")
        df.dateFormat = "MMM dd, yyyy"
        df.timeZone = dateTimeZone
        return df
    }()
    
    private var textBuffer: String = ""
    private var nextArticle: ArticleInfo? = nil
    override init(data: Data) {
        super.init(data: data)
        self.delegate = self
    }
}
extension ArticlesParser: XMLParserDelegate {
    // Called when opening tag (`<elementName>`) is found
    func parser(_ parser: XMLParser, didStartElement elementName: String, namespaceURI: String?, qualifiedName qName: String?, attributes attributeDict: [String : String] = [:]) {
        switch elementName {
        case "posts":
            nextArticle = ArticleInfo()
        case "title":
            textBuffer = ""
        case "date":
            textBuffer = ""
        case "author":
            textBuffer = ""
        case "img":
            textBuffer = ""
        case "content":
            textBuffer = ""
        default:
            print("Ignoring \(elementName)")
            break
        }
    }
    
    // Called when closing tag (`</elementName>`) is found
    func parser(_ parser: XMLParser, didEndElement elementName: String, namespaceURI: String?, qualifiedName qName: String?) {
        switch elementName {
        case "posts":
            if let article = nextArticle {
                articles.append(article) // Cannot find 'articles' in scope
            }
        case "title":
            nextArticle?.title = textBuffer
        case "date":
            print("date: \(textBuffer)")
            nextArticle?.date = dateFormater.date(from: textBuffer)
        case "author":
            nextArticle?.author = textBuffer
        case "img":
            print("img: \(textBuffer)")
            nextArticle?.img = URL(string: textBuffer)
        case "content":
            nextArticle?.content = textBuffer
        default:
            print("Ignoring \(elementName)")
            break
        }
    }
    
    // Called when a character sequence is found
    // This may be called multiple times in a single element
    func parser(_ parser: XMLParser, foundCharacters string: String) {
        textBuffer += string
    }
    
    // Called when a CDATA block is found
    func parser(_ parser: XMLParser, foundCDATA CDATABlock: Data) {
        guard let string = String(data: CDATABlock, encoding: .utf8) else {
            print("CDATA contains non-textual data, ignored")
            return
        }
        textBuffer += string
    }
    
    // For debugging
    func parser(_ parser: XMLParser, parseErrorOccurred parseError: Error) {
        print(parseError)
        print("on:", parser.lineNumber, "at:", parser.columnNumber)
    }
}

Here's code for ArticleInfo 

Your latest ArticlesParser lacks the property articles

to integrate the extension into the actual ObservableObject:

What do you mean by integrate?

There was no point for the extension if the main ObservableObject would just have the variable.

You continue saying words which I do not understand

I added an extension for ArticlesInfo and decided against it.

Code Block 
extension ArticlesInfo {
    var dataUrl: URL {
        FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
            .appendingPathComponent("THS.xml")
    }
    
    func saveArticles() {
        do {
            //Convert Array of `CardInfo` to `Data`
            let data = try JSONEncoder().encode(dataUrl)
            //Write `Data` to a file specified by URL
            try data.write(to: dataUrl, options: .atomic)
        } catch {
            print(error)
        }
    }
    
    func loadArticles() {
        do {
            if FileManager.default.fileExists(atPath: dataUrl.path) {
                return
            }
            //Read `Data` from a file specified by URL
            let data = try Data(contentsOf: dataUrl)
            //Parse Available Articles
            let articles = try JSONDecoder().decode([ArticleInfo].self, from: data)
            self.articles = articles
        } catch {
            print(error)
        }
    }
}