mowareのブログ

import SwiftUI

struct datView: View {
    var board: Board?
    var thread: Thread?
    @State var datPath: String = ""
    @State var datContent: String?

    var body: some View {
        VStack(spacing: 8) {
            if let board = board {
                Text(board.name)
                    .font(.system(size: 16))
                Divider() // 横線
            }
            if let thread = thread {
                Text(thread.threadTitle)
                    .font(.system(size: 16))
                Divider()
            }
            // datファイルの内容を表示する
            if let content = datContent {
               Text(content)
            }
            Spacer()
        }
        .padding(.horizontal, 0)
        .padding(.top, 0)
        .padding(.bottom, 0)
        .task {
            if let thread = thread, let board = board {
                datPath = await makeDat(id: thread.threadID, url: board.url)
                datContent = await readDatFile(path: datPath)
                if datContent?.isEmpty ?? true {
                    print("datなし")
                }
            }
        }
        .refreshable {
            if let thread = thread, let board = board {
                datPath = await makeDat(id: thread.threadID, url: board.url)
                datContent = await readDatFile(path: datPath)
                if datContent?.isEmpty ?? true {
                    print("datなし")
                }
            }
        }
    }
}

struct datView_Previews: PreviewProvider {
    static var previews: some View {
        datView()
    }
}

import Foundation

struct ThreadContent{
    let threadNum: Int
    let threadTitle: String
    let threadPostNum: Int
}

func splitTitle(threadString: String) async -> ThreadContent {
    var threadContent: ThreadContent
    var colonIndex: String.Index?
    var openParenIndex: String.Index?
    var number: Int = 0
    var title: String = ""
    var postCount: Int = 0
    
    // 番号を取り出す(最初のコロンの左側)
    if let index = threadString.firstIndex(of: ":") {
        colonIndex = index
        if let colonIndex = colonIndex {
            number = Int(threadString[..<colonIndex]) ?? 0
            print("番号: \(number)")
        }
    }
    
    if let index = threadString.lastIndex(of: "(") {
        // タイトルを取り出す(最初のコロンの右が始点、末尾から最初の開き括弧の左が終点)
        openParenIndex = index
        if let colonIndex = colonIndex, let openParenIndex = openParenIndex {
            title = String(threadString[threadString.index(after: colonIndex)..<openParenIndex])
            print("タイトル: \(title)")
        }
        
        // 投稿数を取り出す(開き括弧右から末尾1文字を削除した数字)
        if let openParenIndex = openParenIndex {
            let postCountString = threadString[threadString.index(after: openParenIndex)..<threadString.index(before: threadString.endIndex)]
            postCount = Int(postCountString) ?? 0
            print("投稿数: \(postCount)")
        }

    }
    
    threadContent = ThreadContent(threadNum: number, threadTitle: title, threadPostNum: postCount)
    
    return threadContent
}

import Foundation
import Kanna

struct Thread : Identifiable {
    let id = UUID()
    let threadID: String
    let threadTitle: String
    let threadNum: Int
}

func getThreads(url: String) async -> [Thread] { // urlはboard.url
    var threads: [Thread] = []
    var threadNumDict: [String: Int] = [:]
    var threadNum = 0
    
    let boardURL = url + "subback.html"
    guard let url = URL(string: boardURL) else { return [] }

    do {
        let htmlString = try String(contentsOf: url, encoding: .shiftJIS)
        guard let doc = try? HTML(html: htmlString, encoding: .shiftJIS) else { return [] }

        for link in doc.xpath("//*[name()='small']/*[name()='a']") {
            guard let id = link["href"], let title = link.text else { continue }
            
            print(id)
            
            let truncatedID = String(id.dropLast(4))
                
            let idRegex = try! NSRegularExpression(pattern: "^[0-9]+$")
            let idRange = NSRange(location: 0, length: truncatedID.utf16.count)
            let isNumericID = idRegex.firstMatch(in: truncatedID, options: [], range: idRange) != nil
            
            if !isNumericID {
                continue
            }

            if threadNumDict[truncatedID] == nil {
                threadNum += 1
                threadNumDict[truncatedID] = threadNum
            }

            threads.append(Thread(threadID: truncatedID, threadTitle: title, threadNum: threadNumDict[truncatedID]!))
            
            
        }
    } catch {
        print("Error: \(error)")
    }

    return threads
}

import SwiftUI

struct BoardView: View {
    @State private var boardCategories: [BoardCategory] = []

    var body: some View {
        NavigationView {
            VStack{
                Text("板一覧")
                List(boardCategories) { boardCategory in
                    DisclosureGroup(boardCategory.category) {
                        ForEach(boardCategory.boards) { board in
                            NavigationLink(destination: ThreadView(board: board)) {
                                ScrollView {
                                    Text(board.name)
                                }
                            }
                        }
                    }
                }
            }
            Spacer()
        }
        .padding()
        .task {
            boardCategories = await getBoards()
        }
    }
}

struct BoardView_Previews: PreviewProvider {
    static var previews: some View {
        BoardView()
    }
}

import SwiftUI

struct ThreadView: View {
    @State private var threads: [Thread] = []
    var board: Board?

    var body: some View {
        VStack {
            Text("スレッド一覧")
            List{
                ForEach(threads) { thread in
                    Text(thread.threadTitle)
                }
            }
            Spacer()
        }
        .padding()
        .task {
            if let board = board {
               threads = await getThreads(url: board.url)
            }
        }
    }
}

struct ThreadView_Previews: PreviewProvider {
    static var previews: some View {
        ThreadView()
    }
}

import Foundation
import Kanna

struct Board : Identifiable {
    let id = UUID()
    let url: String
    let name: String
    let category: String
    let categoryNum: Int
}

struct BoardCategory : Identifiable {
    let id = UUID()
    let category: String
    let boards: [Board]
    let categoryNum: Int
}


func getBoards() async -> [BoardCategory] {
    var boards: [Board] = []
    var categoryNumDict: [String: Int] = [:]
    var categoryNum = 0
    guard let url = URL(string: "掲示板一覧のURL") else { return [] }

    do {
        let htmlString = try String(contentsOf: url, encoding: .shiftJIS)
        guard let doc = try? HTML(html: htmlString, encoding: .shiftJIS) else { return [] }

        for link in doc.xpath("//*[name()='a']") {
            guard let url = link["href"], let name = link.text else { continue }

            var category = "XXX" // カテゴリー名の初期値
            var prevElement = link.previousSibling
            while prevElement != nil && prevElement?.tagName != "b" {
                prevElement = prevElement?.previousSibling
            }
            if let prevElement = prevElement {
                category = prevElement.text ?? "XXX"
            }

            if categoryNumDict[category] == nil {
                categoryNum += 1
                categoryNumDict[category] = categoryNum
            }

            boards.append(Board(url: url, name: name, category: category, categoryNum: categoryNumDict[category]!))
        }
    } catch {
        print("Error: \(error)")
    }
    
    let groupedBoards = Dictionary(grouping: boards, by: { $0.category })
    
    var boardCategories: [BoardCategory] = groupedBoards.map { BoardCategory(category: $0.key, boards: $0.value, categoryNum: categoryNumDict[$0.key]!) }
    boardCategories.sort { $0.categoryNum < $1.categoryNum }

    return boardCategories
}