KotatsuApp/kotatsu-parsers
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

XoxoComics: Fixes (#2229)

Browse Source
This commit is contained in:
Naga
2025-09-23 01:27:10 +02:00
committed by GitHub
parent 185d9b6e6e
commit 86b8642456
2 changed files with 226 additions and 166 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
.gitignore vendored
View File

@@ -92,3 +92,7 @@ local.properties
.idea/**/runConfigurations.xml .idea/**/runConfigurations.xml
.idea/**/AndroidProjectSystem.xml .idea/**/AndroidProjectSystem.xml
.idea/caches/deviceStreaming.xml .idea/caches/deviceStreaming.xml
/.idea/copilot.data.migration.agent.xml
/.idea/copilot.data.migration.ask.xml
/.idea/copilot.data.migration.ask2agent.xml
/.idea/copilot.data.migration.edit.xml

388
src/main/kotlin/org/koitharu/kotatsu/parsers/site/wpcomics/en/XoxoComics.kt
View File

@@ -6,191 +6,247 @@ import kotlinx.coroutines.coroutineScope
import kotlinx.coroutines.sync.withLock import kotlinx.coroutines.sync.withLock
import org.koitharu.kotatsu.parsers.MangaLoaderContext import org.koitharu.kotatsu.parsers.MangaLoaderContext
import org.koitharu.kotatsu.parsers.MangaSourceParser import org.koitharu.kotatsu.parsers.MangaSourceParser
import org.koitharu.kotatsu.parsers.model.* import org.koitharu.kotatsu.parsers.model.ContentRating
import org.koitharu.kotatsu.parsers.model.ContentType
import org.koitharu.kotatsu.parsers.model.Manga
import org.koitharu.kotatsu.parsers.model.MangaChapter
import org.koitharu.kotatsu.parsers.model.MangaListFilter
import org.koitharu.kotatsu.parsers.model.MangaPage
import org.koitharu.kotatsu.parsers.model.MangaParserSource
import org.koitharu.kotatsu.parsers.model.MangaState
import org.koitharu.kotatsu.parsers.model.MangaTag
import org.koitharu.kotatsu.parsers.model.RATING_UNKNOWN
import org.koitharu.kotatsu.parsers.model.SortOrder
import org.koitharu.kotatsu.parsers.site.wpcomics.WpComicsParser import org.koitharu.kotatsu.parsers.site.wpcomics.WpComicsParser
import org.koitharu.kotatsu.parsers.util.* import org.koitharu.kotatsu.parsers.util.attrAsRelativeUrl
import org.koitharu.kotatsu.parsers.Broken import org.koitharu.kotatsu.parsers.util.generateUid
import org.koitharu.kotatsu.parsers.util.host
import org.koitharu.kotatsu.parsers.util.mapChapters
import org.koitharu.kotatsu.parsers.util.mapToSet
import org.koitharu.kotatsu.parsers.util.oneOrThrowIfMany
import org.koitharu.kotatsu.parsers.util.parseHtml
import org.koitharu.kotatsu.parsers.util.parseSafe
import org.koitharu.kotatsu.parsers.util.removeSuffix
import org.koitharu.kotatsu.parsers.util.selectFirstOrThrow
import org.koitharu.kotatsu.parsers.util.textOrNull
import org.koitharu.kotatsu.parsers.util.toAbsoluteUrl
import org.koitharu.kotatsu.parsers.util.toTitleCase
import org.koitharu.kotatsu.parsers.util.urlEncoded
import java.text.SimpleDateFormat import java.text.SimpleDateFormat
import java.util.* import java.util.EnumSet
@Broken
@MangaSourceParser("XOXOCOMICS", "XoxoComics", "en", ContentType.COMICS) @MangaSourceParser("XOXOCOMICS", "XoxoComics", "en", ContentType.COMICS)
internal class XoxoComics(context: MangaLoaderContext) : internal class XoxoComics(context: MangaLoaderContext) :
WpComicsParser(context, MangaParserSource.XOXOCOMICS, "xoxocomic.com", 50) { WpComicsParser(context, MangaParserSource.XOXOCOMICS, "xoxocomic.com", 36) {
override val listUrl = "/comic-list" override val listUrl = "/comic-list"
override val datePattern = "MM/dd/yyyy" override val datePattern = "MM/dd/yyyy"
override val availableSortOrders: Set<SortOrder> = EnumSet.of( override val availableSortOrders: Set<SortOrder> = EnumSet.of(
SortOrder.UPDATED, SortOrder.UPDATED,
SortOrder.NEWEST, SortOrder.NEWEST,
SortOrder.POPULARITY, SortOrder.POPULARITY,
SortOrder.ALPHABETICAL, SortOrder.ALPHABETICAL,
) )
override suspend fun getListPage(page: Int, order: SortOrder, filter: MangaListFilter): List<Manga> { override suspend fun getListPage(page: Int, order: SortOrder, filter: MangaListFilter): List<Manga> {
val url = buildString { val url = buildString {
append("https://") append("https://")
append(domain) append(domain)
when { when {
!filter.query.isNullOrEmpty() -> {
append("/search-comic?keyword=")
append(filter.query.urlEncoded())
append("&page=")
append(page.toString())
}
!filter.query.isNullOrEmpty() -> { else -> {
append("/search-comic?keyword=") // Handle state filters
append(filter.query.urlEncoded()) val state = filter.states.oneOrThrowIfMany()
append("&page=") val tag = filter.tags.oneOrThrowIfMany()
append(page.toString())
}
else -> { when {
// Tag filtering (genre pages)
tag != null -> {
append("/")
append(tag.key)
append("-comic")
when (order) {
SortOrder.POPULARITY -> append("/popular")
SortOrder.UPDATED -> append("/latest")
SortOrder.NEWEST -> append("/newest")
SortOrder.ALPHABETICAL -> append("")
else -> append("/latest")
}
}
// State filtering (ongoing/completed)
state != null -> {
when (state) {
MangaState.ONGOING -> append("/ongoing-comic")
MangaState.FINISHED -> append("/completed-comic")
else -> append(listUrl)
}
when (order) {
SortOrder.POPULARITY -> append("/popular")
SortOrder.UPDATED -> append("/latest")
SortOrder.NEWEST -> append("/newest")
SortOrder.ALPHABETICAL -> append("")
else -> append("/latest")
}
}
// Default listing
else -> {
when (order) {
SortOrder.UPDATED -> append("/comic-update")
SortOrder.POPULARITY -> append("/popular-comic")
SortOrder.NEWEST -> append("/new-comic")
SortOrder.ALPHABETICAL -> append(listUrl)
else -> append("/comic-update")
}
}
}
if (filter.tags.isNotEmpty()) { append("?page=")
filter.tags.oneOrThrowIfMany()?.let { append(page.toString())
append("/") }
append(it.key) }
} }
} val doc = webClient.httpGet(url).parseHtml()
filter.states.oneOrThrowIfMany()?.let { // Handle different page layouts: popular comics (article.item), ongoing/completed (div.item), and list pages (li.row)
append( val elements = doc.select("div.items article.item, div.row div.item, li.row")
when (it) {
MangaState.ONGOING -> "/ongoing"
MangaState.FINISHED -> "/completed"
else -> ""
},
)
if (filter.tags.isEmpty()) {
append("-comic")
}
}
if (filter.states.isEmpty() && filter.tags.isEmpty()) { return elements.map { element ->
append(listUrl) // Find the main link - could be in different locations depending on page type
} val a = element.selectFirst("figure figcaption h3 a")
?: element.selectFirst("figcaption h3 a")
?: element.selectFirst("h3 a")
?: element.selectFirst("a")
?: throw IllegalStateException("Could not find main link in element")
when (order) { val href = a.attrAsRelativeUrl("href")
SortOrder.POPULARITY -> append("/popular")
SortOrder.UPDATED -> append("/latest")
SortOrder.NEWEST -> append("/newest")
SortOrder.ALPHABETICAL -> append("")
else -> append("/latest")
}
append("?page=")
append(page.toString())
}
}
}
val doc = webClient.httpGet(url).parseHtml()
return doc.select("div.item, #nt_listchapter nav ul li").map { div -> // Handle different image structures and lazy loading
val href = div.selectFirstOrThrow("a").attrAsRelativeUrl("href") val img = element.selectFirst("img")
Manga( val coverUrl = when {
id = generateUid(href), img?.hasAttr("data-original") == true -> img.attr("data-original")
url = href, img?.hasAttr("data-src") == true -> img.attr("data-src")
publicUrl = href.toAbsoluteUrl(div.host ?: domain), img?.hasAttr("src") == true -> img.attr("src")
coverUrl = div.selectFirst("img")?.src().orEmpty(), else -> ""
title = div.selectFirstOrThrow("h3").text().orEmpty(), }.takeIf { it.isNotBlank() && !it.contains("data:image") } ?: ""
altTitles = emptySet(),
rating = RATING_UNKNOWN,
tags = emptySet(),
authors = emptySet(),
state = null,
source = source,
contentRating = if (isNsfwSource) ContentRating.ADULT else null,
)
}
}
override suspend fun getOrCreateTagMap(): ArrayMap<String, MangaTag> = mutex.withLock { val title = a.text().trim()
tagCache?.let { return@withLock it }
val doc = webClient.httpGet("https://$domain$listUrl").parseHtml()
val list = doc.select("div.genres ul li:not(.active)").mapNotNull { li ->
val a = li.selectFirst("a") ?: return@mapNotNull null
val href = a.attr("href").removeSuffix('/').substringAfterLast('/')
MangaTag(
key = href,
title = a.text(),
source = source,
)
}
val result = list.associateByTo(ArrayMap(list.size)) { it.title }
tagCache = result
result
}
override suspend fun getDetails(manga: Manga): Manga = coroutineScope { Manga(
val fullUrl = manga.url.toAbsoluteUrl(domain) id = generateUid(href),
val doc = webClient.httpGet(fullUrl).parseHtml() url = href,
val chaptersDeferred = async { loadChapters(fullUrl) } publicUrl = href.toAbsoluteUrl(element.host ?: domain),
val desc = doc.selectFirstOrThrow(selectDesc).html() coverUrl = coverUrl,
val stateDiv = doc.selectFirst(selectState) title = title,
val state = stateDiv?.let { altTitles = emptySet(),
when (it.text()) { rating = RATING_UNKNOWN,
in ongoing -> MangaState.ONGOING tags = emptySet(),
in finished -> MangaState.FINISHED authors = emptySet(),
else -> null state = null,
} source = source,
} contentRating = if (isNsfwSource) ContentRating.ADULT else null,
val author = doc.body().select(selectAut).textOrNull() )
manga.copy( }
tags = doc.body().select(selectTag).mapToSet { a -> }
MangaTag(
key = a.attr("href").removeSuffix('/').substringAfterLast('/'),
title = a.text().toTitleCase(),
source = source,
)
},
description = desc,
authors = setOfNotNull(author),
state = state,
chapters = chaptersDeferred.await(),
)
}
private val dateFormat = SimpleDateFormat("MM/dd/yyyy", sourceLocale) override suspend fun getOrCreateTagMap(): ArrayMap<String, MangaTag> = mutex.withLock {
tagCache?.let { return@withLock it }
val doc = webClient.httpGet("https://$domain$listUrl").parseHtml()
val list = doc.select("div.genres ul li:not(.active)").mapNotNull { li ->
val a = li.selectFirst("a") ?: return@mapNotNull null
val href = a.attr("href").removeSuffix('/').substringAfterLast('/')
MangaTag(
key = href,
title = a.text(),
source = source,
)
}
val result = list.associateByTo(ArrayMap(list.size)) { it.title }
tagCache = result
result
}
private suspend fun loadChapters(baseUrl: String): List<MangaChapter> { override suspend fun getDetails(manga: Manga): Manga = coroutineScope {
val chapters = ArrayList<MangaChapter>() val fullUrl = manga.url.toAbsoluteUrl(domain)
var page = 0 val doc = webClient.httpGet(fullUrl).parseHtml()
while (true) { val chaptersDeferred = async { loadChapters(fullUrl) }
++page val desc = doc.selectFirstOrThrow(selectDesc).html()
val doc = webClient.httpGet("$baseUrl?page=$page").parseHtml() val stateDiv = doc.selectFirst(selectState)
doc.selectFirst("#nt_listchapter nav ul li:not(.heading)") ?: break val state = stateDiv?.let {
chapters.addAll( when (it.text()) {
doc.select("#nt_listchapter nav ul li:not(.heading)").mapChapters { _, li -> in ongoing -> MangaState.ONGOING
val a = li.selectFirstOrThrow("a") in finished -> MangaState.FINISHED
val href = a.attr("href") else -> null
val dateText = li.selectFirst("div.col-xs-3")?.text() }
MangaChapter( }
id = generateUid(href), val author = doc.body().select(selectAut).textOrNull()
title = a.text(), manga.copy(
number = 0f, tags = doc.body().select(selectTag).mapToSet { a ->
volume = 0, MangaTag(
url = href, key = a.attr("href").removeSuffix('/').substringAfterLast('/'),
scanlator = null, title = a.text().toTitleCase(),
uploadDate = dateFormat.parseSafe(dateText), source = source,
branch = null, )
source = source, },
) description = desc,
authors = setOfNotNull(author),
state = state,
chapters = chaptersDeferred.await(),
)
}
}, private val dateFormat = SimpleDateFormat("MM/dd/yyyy", sourceLocale)
)
}
chapters.reverse()
return chapters.mapIndexed { i, x -> x.copy(volume = x.volume, number = (i + 1).toFloat()) }
}
override suspend fun getPages(chapter: MangaChapter): List<MangaPage> { private suspend fun loadChapters(baseUrl: String): List<MangaChapter> {
val fullUrl = chapter.url.toAbsoluteUrl(domain) + "/all" val chapters = ArrayList<MangaChapter>()
val doc = webClient.httpGet(fullUrl).parseHtml() var page = 0
return doc.select(selectPage).mapNotNull { url -> while (true) {
val img = url.src()?.toRelativeUrl(domain) ?: return@mapNotNull null ++page
val originalImage = img.replace("[", "").replace("]", "") val doc = webClient.httpGet("$baseUrl?page=$page").parseHtml()
MangaPage( val chapterElements = doc.select("#nt_listchapter nav ul li:not(.heading)")
id = generateUid(img), if (chapterElements.isEmpty()) break
url = originalImage,
preview = null, chapters.addAll(
source = source, chapterElements.mapChapters { _, li ->
) val a = li.selectFirstOrThrow("a")
} val href = a.attr("href")
} val dateText = li.selectFirst("div.col-xs-3")?.text()
MangaChapter(
id = generateUid(href),
title = a.text(),
number = 0f,
volume = 0,
url = href,
scanlator = null,
uploadDate = dateFormat.parseSafe(dateText),
branch = null,
source = source,
)
},
)
}
chapters.reverse()
return chapters.mapIndexed { i, x -> x.copy(volume = x.volume, number = (i + 1).toFloat()) }
}
override suspend fun getPages(chapter: MangaChapter): List<MangaPage> {
val fullUrl = chapter.url.toAbsoluteUrl(domain) + "/all"
val doc = webClient.httpGet(fullUrl).parseHtml()
return doc.select("img[data-original]").mapNotNull { img ->
val imgUrl = img.attr("data-original").takeIf { it.isNotBlank() } ?: return@mapNotNull null
val originalImage = imgUrl.replace("[", "").replace("]", "")
MangaPage(
id = generateUid(originalImage),
url = originalImage,
preview = null,
source = source,
)
}
}
} }