feat: Development commit

7 files changed, 361 insertions, 0 deletions

diff --git a/Sora/Data/Booru/Booru.swift b/Sora/Data/Booru/Booru.swift
new file mode 100644
index 0000000..8dce279
--- /dev/null
+++ b/Sora/Data/Booru/Booru.swift
@@ -0,0 +1,4 @@
+enum Booru: String, CaseIterable {
+    case yandere
+    case safebooru
+}
diff --git a/Sora/Data/Booru/BooruManager.swift b/Sora/Data/Booru/BooruManager.swift
new file mode 100644
index 0000000..5eb6f70
--- /dev/null
+++ b/Sora/Data/Booru/BooruManager.swift
@@ -0,0 +1,142 @@
+import SwiftUI
+
+@MainActor
+class BooruManager: ObservableObject {
+    @Published var posts: [BooruPost] = []
+    @Published var allTags: [BooruTag] = []
+    @Published var isLoading: Bool = false
+    @Published var currentPage: Int = 1
+    @Published var searchText = ""
+    @Published var endOfData: Bool = false
+    #if os(macOS)
+        @Published var selectedPost: BooruPost?
+    #endif
+    private var currentTask: Task<Void, Never>?
+    private let booru: Booru?
+    var tags: [String] {
+        if searchText.isEmpty {
+            return []
+        }
+
+        return searchText
+            .split(separator: " ")
+            .map { $0.trimmingCharacters(in: .whitespacesAndNewlines) }
+            .filter { !$0.isEmpty }
+    }
+
+    init(booru: Booru? = nil) {
+        self.booru = booru
+
+        fetchAllTags()
+    }
+
+    func fetchPosts(page: Int = 1, limit: Int = 100, tags: [String] = [], replace: Bool = false) async {
+        guard !isLoading else { return }
+        guard booru != nil else { return }
+
+        currentTask?.cancel()
+
+        currentTask = Task {
+            isLoading = true
+
+            defer { isLoading = false }
+
+            if replace {
+                self.posts = []
+                self.currentPage = 1
+            }
+
+            guard let url = urlForPosts(page: self.booru == .safebooru ? page - 1 : page, limit: limit, tags: tags) else {
+                return
+            }
+
+            do {
+                let (data, _) = try await URLSession.shared.data(from: url)
+
+                if Task.isCancelled { return }
+
+                DispatchQueue.main.async {
+                    let newPosts = Array(Set(BooruPostXMLParser(data: data).parse())).sorted { $0.id > $1.id }
+
+                    if newPosts.isEmpty {
+                        self.endOfData = true
+                    } else {
+                        self.posts += Array(Set(newPosts))
+                    }
+                }
+            } catch {
+                if (error as? URLError)?.code != .cancelled {
+                    #if DEBUG
+                        print("fetchPosts: \(error)")
+                    #endif
+                }
+            }
+        }
+    }
+
+    func performSearch() {
+        Task {
+            await fetchPosts(page: 1, tags: tags, replace: true)
+        }
+    }
+
+    func loadNextPage() {
+        guard !isLoading else { return }
+
+        Task {
+            await fetchPosts(page: currentPage + 1, tags: tags)
+
+            DispatchQueue.main.async {
+                self.currentPage += 1
+            }
+        }
+    }
+
+    func fetchAllTags(limit: Int = 100_000) {
+        guard booru != nil else { return }
+
+        Task {
+            guard let url = urlForTags(limit: limit) else { return }
+
+            do {
+                let (data, _) = try await URLSession.shared.data(from: url)
+
+                if Task.isCancelled { return }
+
+                DispatchQueue.main.async {
+                    self.allTags = BooruTagXMLParser(data: data).parse().sorted { $0.count > $1.count }
+                }
+            } catch {
+                if (error as? URLError)?.code != .cancelled {
+                    #if DEBUG
+                        print("fetchAllTags: \(error)")
+                    #endif
+                }
+            }
+        }
+    }
+
+    private func urlForPosts(page: Int, limit: Int, tags: [String]) -> URL? {
+        let tagString = tags.joined(separator: "+")
+
+        switch booru {
+        case .yandere:
+            return URL(string: "https://yande.re/post.xml?page=\(page)&limit=\(limit)&tags=\(tagString)")
+        case .safebooru:
+            return URL(string: "https://safebooru.org/index.php?page=dapi&s=post&q=index&pid=\(page)&limit=\(limit)&tags=\(tagString)")
+        default:
+            return nil
+        }
+    }
+
+    private func urlForTags(limit: Int) -> URL? {
+        switch booru {
+        case .yandere:
+            return URL(string: "https://yande.re/tag.xml?limit=\(limit)")
+        case .safebooru:
+            return URL(string: "https://safebooru.org/index.php?page=dapi&s=tag&q=index&limit=\(limit)")
+        default:
+            return nil
+        }
+    }
+}
diff --git a/Sora/Data/Booru/BooruPost.swift b/Sora/Data/Booru/BooruPost.swift
new file mode 100644
index 0000000..59b8952
--- /dev/null
+++ b/Sora/Data/Booru/BooruPost.swift
@@ -0,0 +1,27 @@
+import Foundation
+
+struct BooruPost: Identifiable, Hashable {
+    let id: String
+    let height: Int
+    let score: String
+    let fileURL: URL
+    let parentID: String
+    let sampleURL: URL
+    let sampleWidth: Int
+    let sampleHeight: Int
+    let previewURL: URL
+    let rating: String
+    let tags: [String]
+    let width: Int
+    let change: String
+    let md5: String
+    let creatorID: String
+    let hasChildren: Bool
+    let createdAt: Date
+    let status: String
+    let source: String
+    let hasNotes: Bool
+    let hasComments: Bool
+    let previewWidth: Int
+    let previewHeight: Int
+}
diff --git a/Sora/Data/Booru/BooruPostXMLParser.swift b/Sora/Data/Booru/BooruPostXMLParser.swift
new file mode 100644
index 0000000..30207bc
--- /dev/null
+++ b/Sora/Data/Booru/BooruPostXMLParser.swift
@@ -0,0 +1,116 @@
+import Foundation
+
+class BooruPostXMLParser: NSObject, XMLParserDelegate {
+    private var posts: [BooruPost] = []
+    private var currentPost: BooruPost?
+    private var parser: XMLParser
+
+    init(data: Data) {
+        parser = XMLParser(data: data)
+
+        super.init()
+
+        parser.delegate = self
+    }
+
+    func parse() -> [BooruPost] {
+        parser.parse()
+
+        return posts
+    }
+
+    func parser(_: XMLParser, didStartElement elementName: String, namespaceURI _: String?, qualifiedName _: String?, attributes attributeDict: [String: String] = [:]) {
+        if elementName == "post" {
+            guard let id = attributeDict["id"],
+                  let heightStr = attributeDict["height"],
+                  let height = Int(heightStr),
+                  let score = attributeDict["score"],
+                  let fileUrl = attributeDict["file_url"],
+                  let parentId = attributeDict["parent_id"],
+                  let sampleUrl = attributeDict["sample_url"],
+                  let sampleWidthStr = attributeDict["sample_width"],
+                  let sampleWidth = Int(sampleWidthStr),
+                  let sampleHeightStr = attributeDict["sample_height"],
+                  let sampleHeight = Int(sampleHeightStr),
+                  let previewUrl = attributeDict["preview_url"],
+                  let rating = attributeDict["rating"],
+                  let tags = attributeDict["tags"],
+                  let widthStr = attributeDict["width"],
+                  let width = Int(widthStr),
+                  let change = attributeDict["change"],
+                  let md5 = attributeDict["md5"],
+                  let creatorId = attributeDict["creator_id"],
+                  let hasChildrenStr = attributeDict["has_children"],
+                  let createdAt = attributeDict["created_at"],
+                  let status = attributeDict["status"],
+                  let source = attributeDict["source"],
+                  let previewWidthStr = attributeDict["preview_width"],
+                  let previewWidth = Int(previewWidthStr),
+                  let previewHeightStr = attributeDict["preview_height"],
+                  let previewHeight = Int(previewHeightStr)
+            else {
+                return
+            }
+
+            let hasNotesStr = attributeDict["has_notes"] ?? "false"
+            let hasCommentsStr = attributeDict["has_comments"] ?? "false"
+
+            currentPost = BooruPost(
+                id: id,
+                height: height,
+                score: score,
+                fileURL: URL(string: fileUrl)!,
+                parentID: parentId,
+                sampleURL: URL(string: sampleUrl)!,
+                sampleWidth: sampleWidth,
+                sampleHeight: sampleHeight,
+                previewURL: URL(string: previewUrl)!,
+                rating: rating,
+                tags: tags.components(separatedBy: " ").filter { !$0.isEmpty },
+                width: width,
+                change: change,
+                md5: md5,
+                creatorID: creatorId,
+                hasChildren: hasChildrenStr == "true",
+                createdAt: parseCreatedAt(createdAt)!,
+                status: status,
+                source: source,
+                hasNotes: hasNotesStr == "true",
+                hasComments: hasCommentsStr == "true",
+                previewWidth: previewWidth,
+                previewHeight: previewHeight
+            )
+        }
+    }
+
+    func parser(_: XMLParser, didEndElement elementName: String, namespaceURI _: String?, qualifiedName _: String?) {
+        if elementName == "post", let post = currentPost {
+            posts.append(post)
+
+            currentPost = nil
+        }
+    }
+
+    #if DEBUG
+        func parser(_: XMLParser, parseErrorOccurred parseError: any Error) {
+            print("parser: \(parseError)")
+        }
+    #endif
+
+    func parseCreatedAt(_ input: String) -> Date? {
+        let dateFormatter = DateFormatter()
+
+        dateFormatter.dateFormat = "EEE MMM dd HH:mm:ss Z yyyy"
+        dateFormatter.locale = Locale(identifier: "en_US_POSIX")
+
+        if let date = dateFormatter.date(from: input) {
+            return date
+        }
+
+        if let timestamp = Double(input) {
+            return Date(timeIntervalSince1970: timestamp)
+        }
+
+        return nil
+    }
+}
diff --git a/Sora/Data/Booru/BooruTag.swift b/Sora/Data/Booru/BooruTag.swift
new file mode 100644
index 0000000..b98bc75
--- /dev/null
+++ b/Sora/Data/Booru/BooruTag.swift
@@ -0,0 +1,9 @@
+import Foundation
+
+struct BooruTag: Identifiable, Hashable {
+    let id: String
+    let name: String
+    let count: Int
+    let type: Int
+    let ambiguous: Bool
+}
diff --git a/Sora/Data/Booru/BooruTagXMLParser.swift b/Sora/Data/Booru/BooruTagXMLParser.swift
new file mode 100644
index 0000000..0dfebc3
--- /dev/null
+++ b/Sora/Data/Booru/BooruTagXMLParser.swift
@@ -0,0 +1,58 @@
+import Foundation
+
+class BooruTagXMLParser: NSObject, XMLParserDelegate {
+    private var tags: [BooruTag] = []
+    private var currentTag: BooruTag?
+    private var parser: XMLParser
+
+    init(data: Data) {
+        parser = XMLParser(data: data)
+
+        super.init()
+
+        parser.delegate = self
+    }
+
+    func parse() -> [BooruTag] {
+        parser.parse()
+
+        return tags
+    }
+
+    func parser(_: XMLParser, didStartElement elementName: String, namespaceURI _: String?, qualifiedName _: String?, attributes attributeDict: [String: String] = [:]) {
+        if elementName == "tag" {
+            guard let id = attributeDict["id"],
+                  let name = attributeDict["name"],
+                  let countStr = attributeDict["count"],
+                  let count = Int(countStr),
+                  let typeStr = attributeDict["type"],
+                  let type = Int(typeStr),
+                  let ambiguousStr = attributeDict["ambiguous"]
+            else {
+                return
+            }
+
+            currentTag = BooruTag(
+                id: id,
+                name: name,
+                count: count,
+                type: type,
+                ambiguous: ambiguousStr == "true"
+            )
+        }
+    }
+
+    func parser(_: XMLParser, didEndElement elementName: String, namespaceURI _: String?, qualifiedName _: String?) {
+        if elementName == "tag", let tag = currentTag {
+            tags.append(tag)
+
+            currentTag = nil
+        }
+    }
+
+    #if DEBUG
+        func parser(_: XMLParser, parseErrorOccurred parseError: any Error) {
+            print(parseError)
+        }
+    #endif
+}
diff --git a/Sora/Data/Booru/PostFileType.swift b/Sora/Data/Booru/PostFileType.swift
new file mode 100644
index 0000000..addd8db
--- /dev/null
+++ b/Sora/Data/Booru/PostFileType.swift
@@ -0,0 +1,5 @@
+enum PostFileType: String, CaseIterable {
+    case original
+    case sample
+    case preview
+}