From 90966aa7e46b13e0c9f71565540325b865f19571 Mon Sep 17 00:00:00 2001 From: devi <70220050+davvarrr@users.noreply.github.com> Date: Sat, 24 Jun 2023 23:12:38 +0200 Subject: [PATCH 01/14] Update MangaReaderParser.kt add 54 new source rework parseInfoList Source sorting part language --- .../site/mangareader/MangaReaderParser.kt | 1339 +++++++++++++---- 1 file changed, 1029 insertions(+), 310 deletions(-) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/MangaReaderParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/MangaReaderParser.kt index 7211c931..21267241 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/MangaReaderParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/MangaReaderParser.kt @@ -15,6 +15,7 @@ import org.koitharu.kotatsu.parsers.util.* import java.text.SimpleDateFormat import java.util.* + internal abstract class MangaReaderParser( context: MangaLoaderContext, source: MangaSource, @@ -56,11 +57,19 @@ internal abstract class MangaReaderParser( } open suspend fun parseInfoTable(docs: Document, manga: Manga, chapters: List): Manga { - val mangaInfo = docs.selectFirst("div.seriestucontent > div.seriestucontentr") + val mangaInfo = + docs.selectFirst("div.seriestucontent > div.seriestucontentr") ?: + docs.selectFirst("div.seriestucontentr") ?: + docs.selectFirst("div.seriestucon") + val mangaState = mangaInfo?.selectFirst(".infotable td:contains(Status)")?.lastElementSibling()?.let { when (it.text()) { - "Ongoing" -> MangaState.ONGOING - "Completed" -> MangaState.FINISHED + "Ongoing", + "Devam Ediyor" + -> MangaState.ONGOING + "Completed", + "Tamamlandı" + -> MangaState.FINISHED else -> null } } @@ -78,26 +87,46 @@ internal abstract class MangaReaderParser( } open suspend fun parseInfoList(docs: Document, manga: Manga, chapters: List): Manga { - val mangaState = docs.selectFirst(".info-left .tsinfo div:contains(Status)")?.lastElementChild()?.let { + + val state_select = + docs.selectFirst(".tsinfo div:contains(Status)") ?: + docs.selectFirst(".tsinfo div:contains(Durum)") + + val mangaState = state_select?.lastElementChild()?.let { when (it.text()) { - "Ongoing" -> MangaState.ONGOING - "Completed" -> MangaState.FINISHED + "Ongoing", + "Devam Ediyor" + -> MangaState.ONGOING + "Completed", + "Tamamlandı" + -> MangaState.FINISHED else -> null } } - val tagMap = getOrCreateTagMap() - val tags = docs.select(".info-right .mgen > a").mapNotNullToSet { tagMap[it.text()] } + + val tags = docs.select(".wd-full .mgen > a").mapNotNullToSet { getOrCreateTagMap()[it.text()] } return manga.copy( - description = docs.selectFirst(".info-right div.entry-content > p")?.html(), + description = + docs.selectFirst("div.entry-content")?.html(), + state = mangaState, - author = docs.selectFirst(".info-left .tsinfo div:contains(Author)")?.lastElementChild()?.text(), - isNsfw = manga.isNsfw || docs.selectFirst(".info-right .alr") != null, + author = + docs.selectFirst(".tsinfo div:contains(Author)")?.lastElementChild()?.text() ?: + docs.selectFirst(".tsinfo div:contains(Auteur)")?.lastElementChild()?.text() ?: + docs.selectFirst(".tsinfo div:contains(Artist)")?.lastElementChild()?.text() ?: + docs.selectFirst(".tsinfo div:contains(Durum)")?.lastElementChild()?.text() , + + isNsfw = manga.isNsfw + || docs.selectFirst(".info-right .alr") != null + || docs.selectFirst(".postbody .alr") != null, tags = tags, chapters = chapters, ) } + + override suspend fun getListPage( page: Int, query: String?, @@ -228,58 +257,74 @@ internal abstract class MangaReaderParser( ?: "" } - @MangaSourceParser("MANHWALAND", "Manhwaland", "id") - class ManhwaLandParser(context: MangaLoaderContext) : - MangaReaderParser(context, MangaSource.MANHWALAND, pageSize = 20, searchPageSize = 10) { - override val configKeyDomain: ConfigKey.Domain = ConfigKey.Domain("manhwaland.us", "manhwaland.guru") - override val listUrl: String = "/manga" - override val tableMode: Boolean = false - } + /* + laguage : + ar + ja + tr + es + en + th + fr + id + pt + it + */ + + // Ar site // + + @MangaSourceParser("OZULSCANS", "Ozulscans", "ar") + class Ozulscans(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.OZULSCANS, pageSize = 30, searchPageSize = 30) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("ozulscans.com") - @MangaSourceParser("SEKAIKOMIK", "Sekaikomik", "id") - class SekaikomikParser(context: MangaLoaderContext) : - MangaReaderParser(context, MangaSource.SEKAIKOMIK, pageSize = 20, searchPageSize = 100) { - override val configKeyDomain: ConfigKey.Domain = ConfigKey.Domain("sekaikomik.pro") + override val listUrl: String get() = "/manga" + override val tableMode: Boolean get() = false - override val listUrl: String = "/manga" - override val tableMode: Boolean = false - override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMMM D, yyyy", idLocale) + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("yyyy,d MMM", Locale("ar", "AR")) } - @MangaSourceParser("MANHWAINDO", "Manhwaindo", "id") - class ManhwaIndoParser(context: MangaLoaderContext) : - MangaReaderParser(context, MangaSource.MANHWAINDO, pageSize = 30, searchPageSize = 10) { + // Ja site // + + + @MangaSourceParser("RAWKUMA", "Rawkuma", "ja") + class Rawkuma(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.RAWKUMA, pageSize = 54, searchPageSize = 54) { override val configKeyDomain: ConfigKey.Domain - get() = ConfigKey.Domain("manhwaindo.id") + get() = ConfigKey.Domain("rawkuma.com") - override val chapterDateFormat = SimpleDateFormat("MMMM dd, yyyy", Locale.ENGLISH) - override val listUrl: String get() = "/series" + override val listUrl: String get() = "/manga" override val tableMode: Boolean get() = false + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) } - @MangaSourceParser("MANHWALIST", "Manhwalist", "id") - class ManhwalistParser(context: MangaLoaderContext) : - MangaReaderParser(context, MangaSource.MANHWALIST, pageSize = 24, searchPageSize = 10) { + // Tr site // + + @MangaSourceParser("MANGACIM", "Mangacim", "tr") + class Mangacim(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.MANGACIM, pageSize = 20, searchPageSize = 20) { override val configKeyDomain: ConfigKey.Domain - get() = ConfigKey.Domain("manhwalist.in") + get() = ConfigKey.Domain("mangacim.com") - override val listUrl: String = "/manga" + override val listUrl: String get() = "/manga" override val tableMode: Boolean get() = false - override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMMM d, yyyy", Locale.ENGLISH) + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale("tr")) } - @MangaSourceParser("KIRYUU", "Kiryuu", "id") - class KiryuuParser(context: MangaLoaderContext) : - MangaReaderParser(context, MangaSource.KIRYUU, pageSize = 30, searchPageSize = 10) { + @MangaSourceParser("ASURATR", "Asura Scans (tr)", "tr") + class AsuraTRParser(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.ASURATR, pageSize = 30, searchPageSize = 10) { override val configKeyDomain: ConfigKey.Domain - get() = ConfigKey.Domain("kiryuu.id") + get() = ConfigKey.Domain("asurascanstr.com") - override val listUrl: String - get() = "/manga" - override val tableMode: Boolean - get() = true - override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMMM d, yyyy", idLocale) + override val listUrl: String get() = "/manga" + override val tableMode: Boolean get() = false + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale("tr")) } @MangaSourceParser("TURKTOON", "Turktoon", "tr") @@ -294,89 +339,78 @@ internal abstract class MangaReaderParser( get() = false override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMMM d, yyyy", Locale("tr", "TR")) - override suspend fun parseInfoList(docs: Document, manga: Manga, chapters: List): Manga { - val mangaState = docs.selectFirst(".info-left .tsinfo div:contains(Durum)")?.lastElementChild()?.let { - when (it.text()) { - "Devam Ediyor" -> MangaState.ONGOING - "Tamamlandı" -> MangaState.FINISHED - else -> null - } - } + } + + @MangaSourceParser("TEMPESTFANSUB", "Tempestfansub", "tr") + class TempestfansubParser(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.TEMPESTFANSUB, pageSize = 25, searchPageSize = 40) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("manga.tempestfansub.com") + + override val listUrl: String get() = "/manga" + override val tableMode: Boolean get() = false + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMMM d, yyyy", Locale.ENGLISH) - return super.parseInfoList(docs, manga, chapters).copy(state = mangaState) - } } - @MangaSourceParser("WESTMANGA", "Westmanga", "id") - class WestmangaParser(context: MangaLoaderContext) : - MangaReaderParser(context, MangaSource.WESTMANGA, pageSize = 20, searchPageSize = 10) { + + // Es site // + + @MangaSourceParser("SHADOWMANGAS", "Shadowmangas", "es") + class Shadowmangas(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.SHADOWMANGAS, pageSize = 10, searchPageSize = 10) { override val configKeyDomain: ConfigKey.Domain - get() = ConfigKey.Domain("westmanga.info") + get() = ConfigKey.Domain("shadowmangas.com") override val listUrl: String get() = "/manga" override val tableMode: Boolean - get() = true - override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMMM d, yyyy", Locale.ENGLISH) + get() = false + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale("es", "ES")) } - @MangaSourceParser("TEMPESTFANSUB", "Tempestfansub", "tr") - class TempestfansubParser(context: MangaLoaderContext) : - MangaReaderParser(context, MangaSource.TEMPESTFANSUB, pageSize = 25, searchPageSize = 40) { + + @MangaSourceParser("SENPAIEDICIONES", "Senpaiediciones", "es") + class Senpaiediciones(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.SENPAIEDICIONES, pageSize = 20, searchPageSize = 20) { override val configKeyDomain: ConfigKey.Domain - get() = ConfigKey.Domain("tempestscans.com") + get() = ConfigKey.Domain("senpaiediciones.com") - override val listUrl: String get() = "/manga" - override val tableMode: Boolean get() = true - override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMMM d, yyyy", Locale("tr", "TR")) + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false - override suspend fun parseInfoTable(docs: Document, manga: Manga, chapters: List): Manga { - val infoElement = docs.selectFirst("div.infox") - return manga.copy( - chapters = chapters, - description = infoElement?.selectFirst("div.entry-content")?.html(), - author = infoElement?.selectFirst(".flex-wrap div:contains(Artist)")?.lastElementSibling()?.text(), - tags = infoElement?.select(".wd-full .mgen > a") - ?.mapNotNullToSet { getOrCreateTagMap()[it.text()] } - .orEmpty(), - isNsfw = manga.isNsfw || docs.selectFirst(".postbody .alr") != null, - ) - } + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale("es", "ES")) } - @MangaSourceParser("MANHWADESU", "ManhwaDesu", "id") - class ManhwadesuParser(context: MangaLoaderContext) : - MangaReaderParser(context, MangaSource.MANHWADESU, pageSize = 20, searchPageSize = 10) { + @MangaSourceParser("RAIKISCAN", "Raikiscan", "es") + class Raikiscan(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.RAIKISCAN, pageSize = 20, searchPageSize = 20) { override val configKeyDomain: ConfigKey.Domain - get() = ConfigKey.Domain("manhwadesu.pro", "manhwadesu.org") + get() = ConfigKey.Domain("raikiscan.com") - override val listUrl: String get() = "/komik" - override val tableMode: Boolean get() = false + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale("es", "ES")) } - @MangaSourceParser("MANGATALE", "MangaTale", "id") - class MangaTaleParser(context: MangaLoaderContext) : - MangaReaderParser(context, MangaSource.MANGATALE, pageSize = 20, searchPageSize = 10) { + @MangaSourceParser("CARTELDEMANHWAS", "Cartel De Manhwas", "es") + class CartelDeManhwas(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.CARTELDEMANHWAS, pageSize = 20, searchPageSize = 20) { override val configKeyDomain: ConfigKey.Domain - get() = ConfigKey.Domain("mangatale.co") - - override val listUrl: String get() = "/manga" - override val tableMode: Boolean get() = false + get() = ConfigKey.Domain("carteldemanhwas.com") - override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMMM d, yyyy", Locale.ENGLISH) + override val listUrl: String + get() = "/series" + override val tableMode: Boolean + get() = false - override suspend fun parseInfoList(docs: Document, manga: Manga, chapters: List): Manga { - val infoElement = docs.selectFirst("div.infox") - return manga.copy( - chapters = chapters, - description = infoElement?.selectFirst("div.entry-content")?.html(), - author = infoElement?.selectFirst(".flex-wrap div:contains(Author)")?.lastElementSibling()?.text(), - tags = infoElement?.select(".wd-full .mgen > a") - ?.mapNotNullToSet { getOrCreateTagMap()[it.text()] } - .orEmpty(), - isNsfw = manga.isNsfw || docs.selectFirst(".postbody .alr") != null, - ) - } + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale("es", "ES")) } @MangaSourceParser("DRAGONTRANSLATION", "DragonTranslation", "es") @@ -390,78 +424,57 @@ internal abstract class MangaReaderParser( override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMMM d, yyyy", Locale.ENGLISH) - override suspend fun parseInfoList(docs: Document, manga: Manga, chapters: List): Manga { - val infoElement = docs.selectFirst("div.infox") - return manga.copy( - chapters = chapters, - description = infoElement?.selectFirst("div.entry-content")?.html(), - author = infoElement?.selectFirst(".flex-wrap div:contains(Author)")?.lastElementSibling()?.text(), - tags = infoElement?.select(".wd-full .mgen > a") - ?.mapNotNullToSet { getOrCreateTagMap()[it.text()] } - .orEmpty(), - isNsfw = manga.isNsfw || docs.selectFirst(".postbody .alr") != null, - ) - } } - @MangaSourceParser("ASURATR", "Asura Scans (tr)", "tr") - class AsuraTRParser(context: MangaLoaderContext) : - MangaReaderParser(context, MangaSource.ASURATR, pageSize = 30, searchPageSize = 10) { + @MangaSourceParser("MIAUSCAN", "Miau Scan", "es") + class MiauScan(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.MIAUSCAN, pageSize = 20, searchPageSize = 20) { override val configKeyDomain: ConfigKey.Domain - get() = ConfigKey.Domain("asurascanstr.com") + get() = ConfigKey.Domain("miauscan.com") override val listUrl: String get() = "/manga" override val tableMode: Boolean get() = false - override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale("tr")) + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMMM d, yyyy", Locale("es", "ES")) - override suspend fun parseInfoList(docs: Document, manga: Manga, chapters: List): Manga { - val infoElement = docs.selectFirst("div.infox") - return manga.copy( - chapters = chapters, - description = infoElement?.selectFirst("div.entry-content")?.html(), - author = infoElement?.selectFirst(".flex-wrap div:contains(Yazar)")?.lastElementSibling()?.text(), - tags = infoElement?.select(".wd-full .mgen > a") - ?.mapNotNullToSet { getOrCreateTagMap()[it.text()] } - .orEmpty(), - isNsfw = manga.isNsfw || docs.selectFirst(".postbody .alr") != null, - ) - } } - @MangaSourceParser("KOMIKTAP", "KomikTap", "id") - class KomikTapParser(context: MangaLoaderContext) : - MangaReaderParser(context, MangaSource.KOMIKTAP, pageSize = 25, searchPageSize = 10) { + @MangaSourceParser("GREMORYMANGAS", "Gremory Mangas", "es") + class GREMORYMANGAS(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.GREMORYMANGAS, pageSize = 20, searchPageSize = 20) { override val configKeyDomain: ConfigKey.Domain - get() = ConfigKey.Domain("92.87.6.124", "komiktap.in") + get() = ConfigKey.Domain("gremorymangas.com") + + override val listUrl: String get() = "/manga" - override val listUrl: String - get() = "/manga" override val tableMode: Boolean get() = true - override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", idLocale) + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMMM d, yyyy", Locale("es", "ES")) } - @MangaSourceParser("KUMAPOI", "KumaPoi", "id") - class KumaPoiParser(context: MangaLoaderContext) : - MangaReaderParser(context, MangaSource.KUMAPOI, pageSize = 20, searchPageSize = 10) { + // En site // + + + @MangaSourceParser("READKOMIK", "Readkomik", "en") + class Readkomik(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.READKOMIK, pageSize = 20, searchPageSize = 20) { override val configKeyDomain: ConfigKey.Domain - get() = ConfigKey.Domain("kumapoi.me") + get() = ConfigKey.Domain("readkomik.com") override val listUrl: String get() = "/manga" override val tableMode: Boolean - get() = true + get() = false override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) } - @MangaSourceParser("ASURASCANS", "Asura Scans", "en") - class AsuraScansParser(context: MangaLoaderContext) : - MangaReaderParser(context, MangaSource.ASURASCANS, pageSize = 20, searchPageSize = 10) { + @MangaSourceParser("NIGHTSCANS", "Nightscans", "en") + class Nightscans(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.NIGHTSCANS, pageSize = 20, searchPageSize = 20) { override val configKeyDomain: ConfigKey.Domain - get() = ConfigKey.Domain("asurascans.com") + get() = ConfigKey.Domain("nightscans.org") override val listUrl: String get() = "/manga" @@ -469,50 +482,28 @@ internal abstract class MangaReaderParser( get() = false override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) - - override suspend fun parseInfoList(docs: Document, manga: Manga, chapters: List): Manga { - val infoElement = docs.selectFirst("div.infox") - return manga.copy( - chapters = chapters, - description = infoElement?.selectFirst("div.entry-content")?.html(), - author = infoElement?.selectFirst(".flex-wrap div:contains(Author)")?.lastElementSibling()?.text(), - tags = infoElement?.select(".wd-full .mgen > a") - ?.mapNotNullToSet { getOrCreateTagMap()[it.text()] } - .orEmpty(), - isNsfw = manga.isNsfw || docs.selectFirst(".postbody .alr") != null, - ) - } } - @MangaSourceParser("TOONHUNTER", "Toon Hunter", "th") - class ToonHunterParser(context: MangaLoaderContext) : - MangaReaderParser(context, MangaSource.TOONHUNTER, pageSize = 30, searchPageSize = 10) { + + @MangaSourceParser("PHANTOMSCANS", "Phantomscans", "en") + class Phantomscans(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.PHANTOMSCANS, pageSize = 20, searchPageSize = 20) { override val configKeyDomain: ConfigKey.Domain - get() = ConfigKey.Domain("toonhunter.com") + get() = ConfigKey.Domain("phantomscans.com") override val listUrl: String get() = "/manga" override val tableMode: Boolean get() = false - override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", sourceLocale) - - override suspend fun parseInfoList(docs: Document, manga: Manga, chapters: List): Manga { - val infoElement = docs.selectFirst("div.infox") - return manga.copy( - chapters = chapters, - description = infoElement?.selectFirst("div.entry-content")?.html(), - author = infoElement?.selectFirst(".flex-wrap div:contains(Author)")?.lastElementSibling()?.text(), - isNsfw = manga.isNsfw || docs.selectFirst(".postbody .alr") != null, - ) - } + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) } - @MangaSourceParser("COSMICSCANS", "CosmicScans", "en") - class CosmicScansParser(context: MangaLoaderContext) : - MangaReaderParser(context, MangaSource.COSMICSCANS, pageSize = 20, searchPageSize = 10) { + @MangaSourceParser("SURYASCANS", "Suryascans", "en") + class Suryascans(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.SURYASCANS, pageSize = 5, searchPageSize = 5) { override val configKeyDomain: ConfigKey.Domain - get() = ConfigKey.Domain("cosmicscans.com") + get() = ConfigKey.Domain("suryascans.com") override val listUrl: String get() = "/manga" @@ -520,104 +511,60 @@ internal abstract class MangaReaderParser( get() = false override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) - - override suspend fun parseInfoList(docs: Document, manga: Manga, chapters: List): Manga { - val infoElement = docs.selectFirst("div.infox") - return manga.copy( - chapters = chapters, - description = infoElement?.selectFirst("div.entry-content")?.html(), - author = infoElement?.selectFirst(".flex-wrap div:contains(Author)")?.lastElementSibling()?.text(), - tags = infoElement?.select(".wd-full .mgen > a") - ?.mapNotNullToSet { getOrCreateTagMap()[it.text()] } - .orEmpty(), - ) - } } - @MangaSourceParser("PHENIXSCANS", "Phenixscans", "fr") - class PhenixscansParser(context: MangaLoaderContext) : - MangaReaderParser(context, MangaSource.PHENIXSCANS, pageSize = 20, searchPageSize = 10) { + + @MangaSourceParser("RAVENSCANS", "Ravenscans", "en") + class Ravenscans(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.RAVENSCANS, pageSize = 10, searchPageSize = 10) { override val configKeyDomain: ConfigKey.Domain - get() = ConfigKey.Domain("phenixscans.fr") + get() = ConfigKey.Domain("ravenscans.com") override val listUrl: String get() = "/manga" override val tableMode: Boolean get() = false - override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.FRENCH) - - override suspend fun parseInfoList(docs: Document, manga: Manga, chapters: List): Manga { - val infoElement = docs.selectFirst("div.infox") - return manga.copy( - chapters = chapters, - description = infoElement?.selectFirst("div.entry-content")?.html(), - author = infoElement?.selectFirst(".flex-wrap div:contains(Auteur)")?.lastElementSibling()?.text(), - tags = infoElement?.select(".wd-full .mgen > a") - ?.mapNotNullToSet { getOrCreateTagMap()[it.text()] } - .orEmpty(), - ) - } + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) } - @MangaSourceParser("EPSILONSCAN", "Epsilonscan", "fr") - class EpsilonscanParser(context: MangaLoaderContext) : - MangaReaderParser(context, MangaSource.EPSILONSCAN, pageSize = 20, searchPageSize = 10) { + @MangaSourceParser("MANHWALOVER", "ManhwaLover", "en") + class ManhwaLover(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.MANHWALOVER, pageSize = 20, searchPageSize = 20) { override val configKeyDomain: ConfigKey.Domain - get() = ConfigKey.Domain("epsilonscan.fr") + get() = ConfigKey.Domain("manhwalover.com") override val listUrl: String get() = "/manga" override val tableMode: Boolean get() = false - override val isNsfwSource: Boolean = true - override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMMM d, yyyy", Locale.FRENCH) + override val isNsfwSource: Boolean = true - override suspend fun parseInfoList(docs: Document, manga: Manga, chapters: List): Manga { - val infoElement = docs.selectFirst("div.infox") - return manga.copy( - chapters = chapters, - description = infoElement?.selectFirst("div.entry-content")?.html(), - author = infoElement?.selectFirst(".flex-wrap div:contains(Auteur)")?.lastElementSibling()?.text(), - tags = infoElement?.select(".wd-full .mgen > a") - ?.mapNotNullToSet { getOrCreateTagMap()[it.text()] } - .orEmpty(), - ) - } + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) } - @MangaSourceParser("LEGACY_SCANS", "Legacy Scans", "fr") - class LegacyScansParser(context: MangaLoaderContext) : - MangaReaderParser(context, MangaSource.LEGACY_SCANS, pageSize = 20, searchPageSize = 10) { + @MangaSourceParser("MANHWAX", "Manhwax", "en") + class Manhwax(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.MANHWAX, pageSize = 20, searchPageSize = 20) { override val configKeyDomain: ConfigKey.Domain - get() = ConfigKey.Domain("legacy-scans.com") + get() = ConfigKey.Domain("manhwax.org") override val listUrl: String get() = "/manga" override val tableMode: Boolean get() = false - override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMMM d, yyyy", Locale.FRENCH) + override val isNsfwSource: Boolean = true - override suspend fun parseInfoList(docs: Document, manga: Manga, chapters: List): Manga { - val infoElement = docs.selectFirst("div.main-info") - return manga.copy( - chapters = chapters, - description = infoElement?.selectFirst("div.entry-content")?.html(), - author = infoElement?.selectFirst(".flex-wrap div:contains(Auteur(s))")?.lastElementSibling()?.text(), - tags = infoElement?.select(".wd-full .mgen > a") - ?.mapNotNullToSet { getOrCreateTagMap()[it.text()] } - .orEmpty(), - ) - } + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) } - @MangaSourceParser("KOMIKLOKAL", "KomikLokal", "id") - class KomikLokalParser(context: MangaLoaderContext) : - MangaReaderParser(context, MangaSource.KOMIKLOKAL, pageSize = 20, searchPageSize = 10) { + @MangaSourceParser("COSMICSCANS", "CosmicScans", "en") + class CosmicScansParser(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.COSMICSCANS, pageSize = 20, searchPageSize = 10) { override val configKeyDomain: ConfigKey.Domain - get() = ConfigKey.Domain("komikmirror.art") + get() = ConfigKey.Domain("cosmicscans.com") override val listUrl: String get() = "/manga" @@ -625,101 +572,295 @@ internal abstract class MangaReaderParser( get() = false override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) - - override suspend fun parseInfoList(docs: Document, manga: Manga, chapters: List): Manga { - val infoElement = docs.selectFirst("div.infox") - return manga.copy( - chapters = chapters, - tags = infoElement?.select(".wd-full .mgen > a") - ?.mapNotNullToSet { getOrCreateTagMap()[it.text()] } - .orEmpty(), - ) - } } - @MangaSourceParser("KOMIKAV", "KomiKav", "id") - class KomiKavParser(context: MangaLoaderContext) : - MangaReaderParser(context, MangaSource.KOMIKAV, pageSize = 20, searchPageSize = 10) { + @MangaSourceParser("ARENASCANS", "Arena Scans", "en") + class ArenaScans(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.ARENASCANS, pageSize = 20, searchPageSize = 20) { override val configKeyDomain: ConfigKey.Domain - get() = ConfigKey.Domain("komikav.com") + get() = ConfigKey.Domain("arenascans.net") - override val listUrl: String = "/manga" - override val tableMode: Boolean = false + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) - - override suspend fun parseInfoList(docs: Document, manga: Manga, chapters: List): Manga { - val infoElement = docs.selectFirst("div.infox") - return manga.copy( - chapters = chapters, - description = infoElement?.selectFirst("div.entry-content")?.html(), - author = infoElement?.selectFirst(".flex-wrap div:contains(Author)")?.lastElementSibling()?.text(), - tags = infoElement?.select(".wd-full .mgen > a") - ?.mapNotNullToSet { getOrCreateTagMap()[it.text()] } - .orEmpty(), - ) - } } - @MangaSourceParser("KOMIKDEWASA", "KomikDewasa", "id") - class KomikDewasaParser(context: MangaLoaderContext) : - MangaReaderParser(context, MangaSource.KOMIKDEWASA, pageSize = 20, searchPageSize = 10) { + @MangaSourceParser("ASURASCANS", "Asura Scans", "en") + class AsuraScansParser(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.ASURASCANS, pageSize = 20, searchPageSize = 10) { override val configKeyDomain: ConfigKey.Domain - get() = ConfigKey.Domain("komikdewasa.us", "komikdewasa.info") + get() = ConfigKey.Domain("asurascans.com") - override val listUrl: String = "/manga" - override val tableMode: Boolean = false - override val isNsfwSource: Boolean = true + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) - override suspend fun parseInfoList(docs: Document, manga: Manga, chapters: List): Manga { - val infoElement = docs.selectFirst("div.infox") - return manga.copy( - chapters = chapters, - description = infoElement?.selectFirst("div.entry-content")?.html(), - ) - } } - @MangaSourceParser("MANGASUSU", "Mangasusu", "id") - class MangasusuParser(context: MangaLoaderContext) : - MangaReaderParser(context, MangaSource.MANGASUSU, pageSize = 20, searchPageSize = 10) { + @MangaSourceParser("FLAMESCANS", "Flame Scans", "en") + class FlameScans(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.FLAMESCANS, pageSize = 20, searchPageSize = 20) { override val configKeyDomain: ConfigKey.Domain - get() = ConfigKey.Domain("mangasusu.co.in") + get() = ConfigKey.Domain("flamescans.org") override val listUrl: String - get() = "/project" + get() = "/series" override val tableMode: Boolean - get() = true + get() = false override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) } - @MangaSourceParser("KOMIKLAB", "KomikLab", "id") - class KomikLabParser(context: MangaLoaderContext) : - MangaReaderParser(context, MangaSource.KOMIKLAB, pageSize = 20, searchPageSize = 10) { + @MangaSourceParser("ANIGLISCANS", "Anigli Scans", "en") + class AnigliScans(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.ANIGLISCANS, pageSize = 47, searchPageSize = 47) { override val configKeyDomain: ConfigKey.Domain - get() = ConfigKey.Domain("komiklab.com") + get() = ConfigKey.Domain("anigliscans.com") override val listUrl: String - get() = "/project" + get() = "/series" override val tableMode: Boolean - get() = true + get() = false override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) } - @MangaSourceParser("KOMIKINDO", "KomikIndo", "id") - class KomikIndoParser(context: MangaLoaderContext) : - MangaReaderParser(context, MangaSource.KOMIKINDO, pageSize = 20, searchPageSize = 10) { + @MangaSourceParser("AZUREMANGA", "Azure Manga", "en") + class AzureManga(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.AZUREMANGA, pageSize = 20, searchPageSize = 10) { override val configKeyDomain: ConfigKey.Domain - get() = ConfigKey.Domain("komikindo.co") + get() = ConfigKey.Domain("azuremanga.com") override val listUrl: String - get() = "/project" + get() = "/manga" override val tableMode: Boolean - get() = true + get() = false + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) + } + + @MangaSourceParser("ELARCPAGE", "Elarcpage", "en") + class Elarcpage(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.ELARCPAGE, pageSize = 20, searchPageSize = 10) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("elarcpage.com") + + override val listUrl: String + get() = "/series" + override val tableMode: Boolean + get() = false + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) + } + + @MangaSourceParser("VOIDSCANS", "Void Scans", "en") + class VoidScans(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.VOIDSCANS, pageSize = 150, searchPageSize = 150) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("void-scans.com") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) + } + + @MangaSourceParser("KUMASCANS", "Kuma Scans", "en") + class KumaScans(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.KUMASCANS, pageSize = 20, searchPageSize = 20) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("kumascans.com") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) + } + + + // Th Site // + + @MangaSourceParser("TOONHUNTER", "Toon Hunter", "th") + class ToonHunterParser(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.TOONHUNTER, pageSize = 30, searchPageSize = 10) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("toonhunter.com") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", sourceLocale) + } + + + // Fr site // + + @MangaSourceParser("PHENIXSCANS", "Phenixscans", "fr") + class PhenixscansParser(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.PHENIXSCANS, pageSize = 20, searchPageSize = 10) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("phenixscans.fr") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.FRENCH) + + } + + @MangaSourceParser("SUSHISCAN", "SushiScan", "fr") + class SushiScan(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.SUSHISCAN, pageSize = 20, searchPageSize = 10) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("sushiscan.net") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.FRENCH) + } + + @MangaSourceParser("BANANASCAN", "Banana Scan", "fr") + class BananaScan(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.BANANASCAN, pageSize = 20, searchPageSize = 20) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("banana-scan.com") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.FRENCH) + + } + + @MangaSourceParser("EPSILONSCAN", "Epsilonscan", "fr") + class EpsilonscanParser(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.EPSILONSCAN, pageSize = 20, searchPageSize = 10) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("epsilonscan.fr") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false + override val isNsfwSource: Boolean = true + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMMM d, yyyy", Locale.FRENCH) + } + + @MangaSourceParser("LEGACY_SCANS", "Legacy Scans", "fr") + class LegacyScansParser(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.LEGACY_SCANS, pageSize = 20, searchPageSize = 10) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("legacy-scans.com") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMMM d, yyyy", Locale.FRENCH) + } + + + // Id site // + + + @MangaSourceParser("KOMIKLOKAL", "Komik Lokal", "id") + class KomikLokalParser(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.KOMIKLOKAL, pageSize = 20, searchPageSize = 10) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("komikmirror.art") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) + } + + @MangaSourceParser("KOMIKAV", "Komik Av", "id") + class KomikAvParser(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.KOMIKAV, pageSize = 20, searchPageSize = 10) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("komikav.com") + + override val listUrl: String = "/manga" + override val tableMode: Boolean = false + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) + } + + @MangaSourceParser("KOMIKDEWASA", "KomikDewasa", "id") + class KomikDewasaParser(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.KOMIKDEWASA, pageSize = 20, searchPageSize = 20) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("komikdewasa.cfd") + + override val listUrl: String = "/komik" + override val tableMode: Boolean = true + override val isNsfwSource: Boolean = true + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) + } + + @MangaSourceParser("MANGASUSU", "Mangasusu", "id") + class MangasusuParser(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.MANGASUSU, pageSize = 20, searchPageSize = 10) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("mangasusu.co.in") + + override val listUrl: String + get() = "/project" + override val tableMode: Boolean + get() = true + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) + } + + @MangaSourceParser("KOMIKLAB", "KomikLab", "id") + class KomikLabParser(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.KOMIKLAB, pageSize = 20, searchPageSize = 10) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("komiklab.com") + + override val listUrl: String + get() = "/project" + override val tableMode: Boolean + get() = false + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) + } + + @MangaSourceParser("KOMIKINDO", "KomikIndo", "id") + class KomikIndoParser(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.KOMIKINDO, pageSize = 20, searchPageSize = 10) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("komikindo.co") + + override val listUrl: String + get() = "/project" + override val tableMode: Boolean + get() = true override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", idLocale) } @@ -737,4 +878,582 @@ internal abstract class MangaReaderParser( override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) } + + @MangaSourceParser("MANHWALAND", "Manhwaland", "id") + class ManhwaLandParser(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.MANHWALAND, pageSize = 20, searchPageSize = 10) { + + override val configKeyDomain: ConfigKey.Domain = ConfigKey.Domain("manhwaland.us", "manhwaland.guru") + override val listUrl: String = "/manga" + override val tableMode: Boolean = false + } + + @MangaSourceParser("SEKAIKOMIK", "Sekaikomik", "id") + class SekaikomikParser(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.SEKAIKOMIK, pageSize = 20, searchPageSize = 100) { + override val configKeyDomain: ConfigKey.Domain = ConfigKey.Domain("sekaikomik.pro") + + override val listUrl: String = "/manga" + override val tableMode: Boolean = false + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMMM D, yyyy", idLocale) + } + + @MangaSourceParser("MANHWAINDO", "Manhwaindo", "id") + class ManhwaIndoParser(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.MANHWAINDO, pageSize = 30, searchPageSize = 10) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("manhwaindo.id") + + override val chapterDateFormat = SimpleDateFormat("MMMM dd, yyyy", Locale.ENGLISH) + override val listUrl: String get() = "/series" + override val tableMode: Boolean get() = false + } + + @MangaSourceParser("MANHWALIST", "Manhwalist", "id") + class ManhwalistParser(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.MANHWALIST, pageSize = 24, searchPageSize = 10) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("manhwalist.in") + + override val listUrl: String = "/manga" + override val tableMode: Boolean get() = false + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMMM d, yyyy", Locale.ENGLISH) + } + + @MangaSourceParser("KIRYUU", "Kiryuu", "id") + class KiryuuParser(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.KIRYUU, pageSize = 30, searchPageSize = 10) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("kiryuu.id") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = true + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMMM d, yyyy", idLocale) + } + + @MangaSourceParser("WESTMANGA", "Westmanga", "id") + class WestmangaParser(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.WESTMANGA, pageSize = 20, searchPageSize = 10) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("westmanga.info") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = true + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMMM d, yyyy", Locale.ENGLISH) + } + + @MangaSourceParser("MANHWADESU", "ManhwaDesu", "id") + class ManhwadesuParser(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.MANHWADESU, pageSize = 20, searchPageSize = 10) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("manhwadesu.pro", "manhwadesu.org") + + override val listUrl: String get() = "/komik" + override val tableMode: Boolean get() = false + } + + @MangaSourceParser("MANGATALE", "MangaTale", "id") + class MangaTaleParser(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.MANGATALE, pageSize = 20, searchPageSize = 10) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("mangatale.co") + + override val listUrl: String get() = "/manga" + override val tableMode: Boolean get() = false + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMMM d, yyyy", Locale.ENGLISH) + } + + @MangaSourceParser("KUMAPOI", "KumaPoi", "id") + class KumaPoiParser(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.KUMAPOI, pageSize = 20, searchPageSize = 10) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("kumapoi.me") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = true + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) + } + + @MangaSourceParser("KOMIKTAP", "KomikTap", "id") + class KomikTapParser(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.KOMIKTAP, pageSize = 25, searchPageSize = 10) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("92.87.6.124", "komiktap.in") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = true + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", idLocale) + } + + @MangaSourceParser("SOULSCANS", "Soul Scans", "id") + class SoulScans(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.SOULSCANS, pageSize = 30, searchPageSize = 30) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("soulscans.my.id") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = true + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) + } + + @MangaSourceParser("BOOSEI", "Boosei", "id") + class Boosei(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.BOOSEI, pageSize = 30, searchPageSize = 30) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("boosei.net") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", idLocale) + } + + @MangaSourceParser("DOJING", "Dojing", "id") + class Dojing(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.DOJING, pageSize = 12, searchPageSize = 12) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("dojing.net") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = true + + override val isNsfwSource = true + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", idLocale) + + } + + @MangaSourceParser("DUNIAKOMIK", "Duniakomik", "id") + class Duniakomik(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.DUNIAKOMIK, pageSize = 12, searchPageSize = 12) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("duniakomik.id") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = true + + override val isNsfwSource = true + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", idLocale) + + } + + @MangaSourceParser("KATAKOMIK", "Katakomik", "id") + class Katakomik(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.KATAKOMIK, pageSize = 20, searchPageSize = 20) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("katakomik.online") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) + } + + @MangaSourceParser("KANZENIN", "Kanzenin", "id") + class Kanzenin(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.KANZENIN, pageSize = 25, searchPageSize = 25) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("kanzenin.xyz") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false + + override val isNsfwSource = true + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) + } + + @MangaSourceParser("KOMIKSTATION", "Komikstation", "id") + class Komikstation(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.KOMIKSTATION, pageSize = 30, searchPageSize = 30) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("komikstation.co") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) + } + + + @MangaSourceParser("KOMIKMAMA", "Komik Mama", "id") + class KomikMama(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.KOMIKMAMA, pageSize = 20, searchPageSize = 20) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("komikmama.co") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = true + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) + + } + + @MangaSourceParser("KOMIKMANHWA", "Komik Manhwa", "id") + class KomikManhwa(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.KOMIKMANHWA, pageSize = 20, searchPageSize = 20) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("komikmanhwa.me") + + override val listUrl: String + get() = "/series" + override val tableMode: Boolean + get() = true + + override val isNsfwSource = true + + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", idLocale) + + } + + @MangaSourceParser("KOMIKU", "Komiku", "id") + class Komiku(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.KOMIKU, pageSize = 20, searchPageSize = 20) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("komiku.com") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = true + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", idLocale) + + } + + + @MangaSourceParser("MANGAYARO", "Mangayaro", "id") + class Mangayaro(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.MANGAYARO, pageSize = 20, searchPageSize = 20) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("mangayaro.net") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) + + } + + @MangaSourceParser("MANGAKITA", "MangaKita", "id") + class MangakKita(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.MANGAKITA, pageSize = 20, searchPageSize = 20) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("mangakita.net") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = true + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) + + } + + + @MangaSourceParser("MANGASUSUKU", "MangaSusuku", "id") + class MangaSusuku(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.MANGASUSUKU, pageSize = 20, searchPageSize = 20) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("mangasusuku.xyz") + + override val listUrl: String + get() = "/komik" + override val tableMode: Boolean + get() = true + + override val isNsfwSource = true + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) + + } + + @MangaSourceParser("MASTERKOMIK", "MasterKomik", "id") + class MasterKomik(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.MASTERKOMIK, pageSize = 20, searchPageSize = 20) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("masterkomik.com") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) + + } + + + @MangaSourceParser("MELOKOMIK", "Melokomik", "id") + class Melokomik(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.MELOKOMIK, pageSize = 20, searchPageSize = 20) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("melokomik.xyz") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", idLocale) + + } + + @MangaSourceParser("MIRRORDESU", "Mirrordesu", "id") + class Mirrordesu(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.MIRRORDESU, pageSize = 20, searchPageSize = 20) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("mirrordesu.ink") + + override val listUrl: String + get() = "/komik" + override val tableMode: Boolean + get() = false + + override val isNsfwSource = true + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", idLocale) + + } + + @MangaSourceParser("LIANSCANS", "Lianscans", "id") + class Lianscans(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.LIANSCANS, pageSize = 10, searchPageSize = 10) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("www.lianscans.my.id") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false + + override val isNsfwSource = true + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", idLocale) + + } + + @MangaSourceParser("MANGAINDO", "Mangaindo", "id") + class Mangaindo(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.MANGAINDO, pageSize = 26, searchPageSize = 26) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("mangaindo.me") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) + + } + + + @MangaSourceParser("PISCANS", "Piscans", "id") + class Piscans(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.PISCANS, pageSize = 24, searchPageSize = 24) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("piscans.in") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) + + } + + @MangaSourceParser("SEKTEDOUJIN", "Sektedoujin", "id") + class Sektedoujin(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.SEKTEDOUJIN, pageSize = 20, searchPageSize = 20) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("sektedoujin.cc") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false + + override val isNsfwSource = true + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", idLocale) + + } + + @MangaSourceParser("SHEAKOMIK", "Sheakomik", "id") + class Sheakomik(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.SHEAKOMIK, pageSize = 40, searchPageSize = 40) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("sheakomik.com") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", idLocale) + + } + + + @MangaSourceParser("TUKANGKOMIK", "Tukangkomik", "id") + class Tukangkomik(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.TUKANGKOMIK, pageSize = 20, searchPageSize = 20) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("tukangkomik.id") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale.ENGLISH) + + } + + // Pt Site // + + @MangaSourceParser("FRANXXMANGAS", "Franxx Mangas", "pt") + class FranxxMangas(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.FRANXXMANGAS, pageSize = 20, searchPageSize = 20) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("franxxmangas.net") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false + + override val isNsfwSource = true + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale("pt", "PT")) + + } + + @MangaSourceParser("MANGASCHAN", "Mangaschan", "pt") + class Mangaschan(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.MANGASCHAN, pageSize = 20, searchPageSize = 20) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("mangaschan.com") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale("pt", "PT")) + + } + + @MangaSourceParser("SILENCESCAN", "Silencescan", "pt") + class Silencescan(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.SILENCESCAN, pageSize = 35, searchPageSize = 35) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("silencescan.com.br") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false + + override val isNsfwSource = true + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale("pt", "PT")) + + } + + @MangaSourceParser("TSUNDOKU", "Tsundoku", "pt") + class Tsundoku(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.TSUNDOKU, pageSize = 50, searchPageSize = 50) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("tsundoku.com.br") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale("pt", "PT")) + + } + + @MangaSourceParser("ORIGAMIORPHEANS", "Origami orpheans", "pt") + class Origamiorpheans(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.ORIGAMIORPHEANS, pageSize = 20, searchPageSize = 20) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("origami-orpheans.com.br") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = true + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale("pt", "PT")) + + } + + @MangaSourceParser("MUNDOMANGAKUN", "Mundomangakun", "pt") + class Mundomangakun(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.MUNDOMANGAKUN, pageSize = 20, searchPageSize = 20) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("mundomangakun.com.br") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale("pt", "PT")) + + } + + // It Site // + + @MangaSourceParser("WALPURGISCAN", "Walpurgiscan", "it") + class Walpurgiscan(context: MangaLoaderContext) : + MangaReaderParser(context, MangaSource.WALPURGISCAN, pageSize = 20, searchPageSize = 20) { + override val configKeyDomain: ConfigKey.Domain + get() = ConfigKey.Domain("walpurgiscan.it") + + override val listUrl: String + get() = "/manga" + override val tableMode: Boolean + get() = false + + override val chapterDateFormat: SimpleDateFormat = SimpleDateFormat("MMM d, yyyy", Locale("it", "IT")) + + } } From c17c9d9ccc0342687d4e952712b9295324e4722f Mon Sep 17 00:00:00 2001 From: devi <70220050+davvarrr@users.noreply.github.com> Date: Mon, 26 Jun 2023 07:07:01 +0200 Subject: [PATCH 02/14] Update MangaReaderParser.kt Add long for parse onging / finished --- .../kotatsu/parsers/site/mangareader/MangaReaderParser.kt | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/MangaReaderParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/MangaReaderParser.kt index 21267241..e59c591e 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/MangaReaderParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/MangaReaderParser.kt @@ -65,10 +65,16 @@ internal abstract class MangaReaderParser( val mangaState = mangaInfo?.selectFirst(".infotable td:contains(Status)")?.lastElementSibling()?.let { when (it.text()) { "Ongoing", + "En Cours", + "OnGoing", "Devam Ediyor" -> MangaState.ONGOING "Completed", - "Tamamlandı" + "Complété", + "Fini", + "Terminé", + "Tamamlandı", + "Finished" -> MangaState.FINISHED else -> null } From c4fad321db3396627870e38998a25d6e0b926f70 Mon Sep 17 00:00:00 2001 From: devi <70220050+davvarrr@users.noreply.github.com> Date: Mon, 26 Jun 2023 07:08:25 +0200 Subject: [PATCH 03/14] Update MangaReaderParser.kt --- .../kotatsu/parsers/site/mangareader/MangaReaderParser.kt | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/MangaReaderParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/MangaReaderParser.kt index e59c591e..e7d0f041 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/MangaReaderParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/MangaReaderParser.kt @@ -101,10 +101,16 @@ internal abstract class MangaReaderParser( val mangaState = state_select?.lastElementChild()?.let { when (it.text()) { "Ongoing", + "En Cours", + "OnGoing", "Devam Ediyor" -> MangaState.ONGOING "Completed", - "Tamamlandı" + "Complété", + "Fini", + "Terminé", + "Tamamlandı", + "Finished" -> MangaState.FINISHED else -> null } From 87abdf6346ecfee472d9ddd4843784299bfc3b0b Mon Sep 17 00:00:00 2001 From: devi <70220050+davvarrr@users.noreply.github.com> Date: Mon, 26 Jun 2023 08:08:36 +0200 Subject: [PATCH 04/14] Update MangaReaderParser.kt --- .../site/mangareader/MangaReaderParser.kt | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/MangaReaderParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/MangaReaderParser.kt index e7d0f041..b912e94c 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/MangaReaderParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/MangaReaderParser.kt @@ -65,15 +65,24 @@ internal abstract class MangaReaderParser( val mangaState = mangaInfo?.selectFirst(".infotable td:contains(Status)")?.lastElementSibling()?.let { when (it.text()) { "Ongoing", + "On going", + "Ativo", "En Cours", "OnGoing", + "Đang tiến hành", + "em lançamento", + "Онгоінг", + "Publishing", "Devam Ediyor" -> MangaState.ONGOING "Completed", + "Completo", "Complété", "Fini", "Terminé", "Tamamlandı", + "Đã hoàn thành", + "Завершено", "Finished" -> MangaState.FINISHED else -> null @@ -101,15 +110,24 @@ internal abstract class MangaReaderParser( val mangaState = state_select?.lastElementChild()?.let { when (it.text()) { "Ongoing", + "On going", + "Ativo", "En Cours", "OnGoing", + "Đang tiến hành", + "em lançamento", + "Онгоінг", + "Publishing", "Devam Ediyor" -> MangaState.ONGOING "Completed", + "Completo", "Complété", "Fini", "Terminé", "Tamamlandı", + "Đã hoàn thành", + "Завершено", "Finished" -> MangaState.FINISHED else -> null From 13881962880a0f16c46b81e27957b2c571d49c36 Mon Sep 17 00:00:00 2001 From: Koitharu Date: Mon, 26 Jun 2023 13:27:31 +0300 Subject: [PATCH 05/14] Update gradle config --- .github/workflows/test-parsers.yml | 2 +- .idea/kotlinc.xml | 2 +- build.gradle | 12 ++++++------ buildSrc/build.gradle | 8 ++++---- buildSrc/src/main/kotlin/tasks/ReportGenerateTask.kt | 2 +- gradle/wrapper/gradle-wrapper.properties | 2 +- kotatsu-parsers-ksp/build.gradle | 6 +++--- .../koitharu/kotatsu/parsers/ksp/ParserProcessor.kt | 1 + settings.gradle | 9 +++------ .../koitharu/kotatsu/parsers/MangaLoaderContext.kt | 3 ++- 10 files changed, 23 insertions(+), 24 deletions(-) diff --git a/.github/workflows/test-parsers.yml b/.github/workflows/test-parsers.yml index 8ac54760..0bfc0021 100644 --- a/.github/workflows/test-parsers.yml +++ b/.github/workflows/test-parsers.yml @@ -16,7 +16,7 @@ jobs: - uses: actions/checkout@v3 - uses: actions/setup-java@v3 with: - java-version: '17' + java-version: '11' distribution: 'temurin' cache: 'gradle' - run: ./gradlew :test --tests "org.koitharu.kotatsu.parsers.MangaParserTest" || true diff --git a/.idea/kotlinc.xml b/.idea/kotlinc.xml index fbd3b0a1..9a55c2de 100644 --- a/.idea/kotlinc.xml +++ b/.idea/kotlinc.xml @@ -3,4 +3,4 @@ - + \ No newline at end of file diff --git a/build.gradle b/build.gradle index ecebca93..447722d7 100644 --- a/build.gradle +++ b/build.gradle @@ -2,8 +2,8 @@ import tasks.ReportGenerateTask plugins { id 'java-library' - id 'org.jetbrains.kotlin.jvm' - id 'com.google.devtools.ksp' + id 'org.jetbrains.kotlin.jvm' version '1.8.21' + id 'com.google.devtools.ksp' version '1.8.22-1.0.11' id 'maven-publish' } @@ -16,7 +16,6 @@ test { compileKotlin { kotlinOptions { - jvmTarget = '1.8' freeCompilerArgs += [ '-opt-in=kotlin.RequiresOptIn', '-opt-in=kotlin.contracts.ExperimentalContracts', @@ -28,7 +27,6 @@ compileKotlin { compileTestKotlin { kotlinOptions { - jvmTarget = '1.8' freeCompilerArgs += [ '-opt-in=kotlin.RequiresOptIn', '-opt-in=kotlinx.coroutines.ExperimentalCoroutinesApi', @@ -38,6 +36,7 @@ compileTestKotlin { } kotlin { + jvmToolchain(11) sourceSets { main.kotlin.srcDirs += 'build/generated/ksp/main/kotlin' } @@ -70,5 +69,6 @@ dependencies { testImplementation 'io.webfolder:quickjs:1.1.0' } -//noinspection ConfigurationAvoidance -task generateTestsReport(type: ReportGenerateTask) +tasks.register('generateTestsReport', ReportGenerateTask) { + dependsOn test +} diff --git a/buildSrc/build.gradle b/buildSrc/build.gradle index fe719039..c01928d5 100644 --- a/buildSrc/build.gradle +++ b/buildSrc/build.gradle @@ -1,5 +1,5 @@ plugins { - id('org.jetbrains.kotlin.jvm') version '1.6.21' + id 'org.jetbrains.kotlin.jvm' version '1.8.21' } repositories { mavenCentral() @@ -8,6 +8,6 @@ repositories { dependencies { implementation gradleApi() implementation 'org.simpleframework:simple-xml:2.7.1' - implementation 'com.soywiz.korlibs.korte:korte-jvm:3.0.0-Beta5' - implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.3' -} \ No newline at end of file + implementation 'com.soywiz.korlibs.korte:korte-jvm:4.0.6' + implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.7.1' +} diff --git a/buildSrc/src/main/kotlin/tasks/ReportGenerateTask.kt b/buildSrc/src/main/kotlin/tasks/ReportGenerateTask.kt index 72b1587a..078fefe1 100644 --- a/buildSrc/src/main/kotlin/tasks/ReportGenerateTask.kt +++ b/buildSrc/src/main/kotlin/tasks/ReportGenerateTask.kt @@ -1,6 +1,6 @@ package tasks -import com.soywiz.korte.Template +import korlibs.template.Template import kotlinx.coroutines.runBlocking import org.gradle.api.DefaultTask import org.gradle.api.tasks.TaskAction diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index 2e6e5897..fae08049 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,5 +1,5 @@ distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-7.3.3-bin.zip +distributionUrl=https\://services.gradle.org/distributions/gradle-8.1.1-bin.zip zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists diff --git a/kotatsu-parsers-ksp/build.gradle b/kotatsu-parsers-ksp/build.gradle index e6317098..2ac8590a 100644 --- a/kotatsu-parsers-ksp/build.gradle +++ b/kotatsu-parsers-ksp/build.gradle @@ -1,7 +1,7 @@ plugins { - id 'org.jetbrains.kotlin.jvm' + id 'org.jetbrains.kotlin.jvm' version '1.8.21' } dependencies { - implementation 'com.google.devtools.ksp:symbol-processing-api:1.6.21-1.0.5' -} \ No newline at end of file + implementation 'com.google.devtools.ksp:symbol-processing-api:1.8.22-1.0.11' +} diff --git a/kotatsu-parsers-ksp/src/main/kotlin/org/koitharu/kotatsu/parsers/ksp/ParserProcessor.kt b/kotatsu-parsers-ksp/src/main/kotlin/org/koitharu/kotatsu/parsers/ksp/ParserProcessor.kt index cdce07a1..c89c4d2e 100644 --- a/kotatsu-parsers-ksp/src/main/kotlin/org/koitharu/kotatsu/parsers/ksp/ParserProcessor.kt +++ b/kotatsu-parsers-ksp/src/main/kotlin/org/koitharu/kotatsu/parsers/ksp/ParserProcessor.kt @@ -70,6 +70,7 @@ class ParserProcessor( import org.koitharu.kotatsu.parsers.model.MangaSource @Suppress("DEPRECATION") + @InternalParsersApi @Deprecated("", replaceWith = ReplaceWith("context.newParserInstance(this)")) fun MangaSource.newParser(context: MangaLoaderContext): MangaParser = when (this) { diff --git a/settings.gradle b/settings.gradle index 95cda867..0ffa7a43 100644 --- a/settings.gradle +++ b/settings.gradle @@ -1,19 +1,16 @@ pluginManagement { - plugins { - id 'com.google.devtools.ksp' version '1.8.22-1.0.11' - id 'org.jetbrains.kotlin.jvm' version '1.8.22' - } repositories { - gradlePluginPortal() google() + mavenCentral() + gradlePluginPortal() } } dependencyResolutionManagement { - repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS) repositories { google() mavenCentral() + gradlePluginPortal() } } diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/MangaLoaderContext.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/MangaLoaderContext.kt index dc6ce96f..9af4edd8 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/MangaLoaderContext.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/MangaLoaderContext.kt @@ -12,7 +12,8 @@ abstract class MangaLoaderContext { abstract val cookieJar: CookieJar - fun newParserInstance(source: MangaSource): MangaParser = this.newParserInstance(source) + @Suppress("DEPRECATION") + fun newParserInstance(source: MangaSource): MangaParser = source.newParser(this) open fun encodeBase64(data: ByteArray): String = Base64.getEncoder().encodeToString(data) From 2311a5665810245ed1efef5a6b79f3d888ed2410 Mon Sep 17 00:00:00 2001 From: devi <70220050+davvarrr@users.noreply.github.com> Date: Mon, 26 Jun 2023 22:00:36 +0200 Subject: [PATCH 06/14] add new parse language for status --- .../site/mangareader/MangaReaderParser.kt | 38 ++++++++++++++++--- 1 file changed, 33 insertions(+), 5 deletions(-) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/MangaReaderParser.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/MangaReaderParser.kt index b912e94c..dbe02124 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/MangaReaderParser.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/mangareader/MangaReaderParser.kt @@ -62,8 +62,19 @@ internal abstract class MangaReaderParser( docs.selectFirst("div.seriestucontentr") ?: docs.selectFirst("div.seriestucon") - val mangaState = mangaInfo?.selectFirst(".infotable td:contains(Status)")?.lastElementSibling()?.let { + val state_select = + docs.selectFirst(".tsinfo div:contains(Status)") ?: + docs.selectFirst(".tsinfo div:contains(Statut)") ?: + docs.selectFirst(".tsinfo div:contains(حالة العمل)") ?: + docs.selectFirst(".tsinfo div:contains(Estado)") ?: + docs.selectFirst(".tsinfo div:contains(สถานะ)") ?: + docs.selectFirst(".tsinfo div:contains(Stato )") ?: + docs.selectFirst(".tsinfo div:contains(Durum)") + + val mangaState = state_select?.lastElementChild()?.let { when (it.text()) { + "مستمرةا", + "En curso", "Ongoing", "On going", "Ativo", @@ -73,7 +84,9 @@ internal abstract class MangaReaderParser( "em lançamento", "Онгоінг", "Publishing", - "Devam Ediyor" + "Devam Ediyor", + "Em Andamento", + "In Corso" -> MangaState.ONGOING "Completed", "Completo", @@ -82,8 +95,11 @@ internal abstract class MangaReaderParser( "Terminé", "Tamamlandı", "Đã hoàn thành", + "مكتملة", "Завершено", - "Finished" + "Finished", + "Finalizado", + "Completata" -> MangaState.FINISHED else -> null } @@ -105,10 +121,17 @@ internal abstract class MangaReaderParser( val state_select = docs.selectFirst(".tsinfo div:contains(Status)") ?: + docs.selectFirst(".tsinfo div:contains(Statut)") ?: + docs.selectFirst(".tsinfo div:contains(حالة العمل)") ?: + docs.selectFirst(".tsinfo div:contains(Estado)") ?: + docs.selectFirst(".tsinfo div:contains(สถานะ)") ?: + docs.selectFirst(".tsinfo div:contains(Stato )") ?: docs.selectFirst(".tsinfo div:contains(Durum)") val mangaState = state_select?.lastElementChild()?.let { when (it.text()) { + "مستمرةا", + "En curso", "Ongoing", "On going", "Ativo", @@ -118,7 +141,9 @@ internal abstract class MangaReaderParser( "em lançamento", "Онгоінг", "Publishing", - "Devam Ediyor" + "Devam Ediyor", + "Em Andamento", + "In Corso" -> MangaState.ONGOING "Completed", "Completo", @@ -127,8 +152,11 @@ internal abstract class MangaReaderParser( "Terminé", "Tamamlandı", "Đã hoàn thành", + "مكتملة", "Завершено", - "Finished" + "Finished", + "Finalizado", + "Completata" -> MangaState.FINISHED else -> null } From 591291e9d6cd116c8b153d3a9abb435dfa2f8058 Mon Sep 17 00:00:00 2001 From: devi <70220050+davvarrr@users.noreply.github.com> Date: Mon, 26 Jun 2023 22:25:35 +0200 Subject: [PATCH 07/14] fix status --- .../org/koitharu/kotatsu/parsers/site/madara/Hentaizone.kt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/Hentaizone.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/Hentaizone.kt index 3fcd44bf..61f303ed 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/Hentaizone.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/Hentaizone.kt @@ -23,10 +23,10 @@ internal class Hentaizone(context: MangaLoaderContext) : override val isNsfwSource = true override fun String.asMangaState(): MangaState? = when (this) { - "OnGoing", + "En Cours", -> MangaState.ONGOING - "finished", + "Terminé", -> MangaState.FINISHED else -> null From aa734e5ad30f0606779af143f9f844d4f2d1f3d9 Mon Sep 17 00:00:00 2001 From: devi <70220050+davvarrr@users.noreply.github.com> Date: Mon, 26 Jun 2023 23:21:24 +0200 Subject: [PATCH 08/14] fix --- .../org/koitharu/kotatsu/parsers/site/madara/Atlantisscan.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/Atlantisscan.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/Atlantisscan.kt index 38287ce0..e1e89fec 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/Atlantisscan.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/Atlantisscan.kt @@ -31,7 +31,7 @@ internal class Atlantisscan(context: MangaLoaderContext) : override fun parseDetails(manga: Manga, body: Element, chapters: List): Manga { val root = body.selectFirstOrThrow(".site-content") - val postContent = root.selectFirstOrThrow(".post-content") + val postContent = root.selectFirstOrThrow(".summary_content") val tags = postContent.getElementsContainingOwnText("Genre(s) ") .firstOrNull()?.tableValue() ?.getElementsByAttributeValueContaining("href", tagPrefix) From f6d264f37d40e7ccbce8a9527ab18bee2ec93783 Mon Sep 17 00:00:00 2001 From: devi <70220050+davvarrr@users.noreply.github.com> Date: Mon, 26 Jun 2023 23:22:00 +0200 Subject: [PATCH 09/14] Update MangaScantrad.kt --- .../org/koitharu/kotatsu/parsers/site/madara/MangaScantrad.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/MangaScantrad.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/MangaScantrad.kt index 0c2f8eb7..8b4357f4 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/MangaScantrad.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/MangaScantrad.kt @@ -32,7 +32,7 @@ internal class MangaScantrad(context: MangaLoaderContext) : override fun parseDetails(manga: Manga, body: Element, chapters: List): Manga { val root = body.selectFirstOrThrow(".site-content") - val postContent = root.selectFirstOrThrow(".post-content") + val postContent = root.selectFirstOrThrow(".summary_content") val tags = postContent.getElementsContainingOwnText("Genre(s)") .firstOrNull()?.tableValue() ?.getElementsByAttributeValueContaining("href", tagPrefix) From e4f12149edacc23eef258d20c55cd16f7ced8966 Mon Sep 17 00:00:00 2001 From: devi <70220050+davvarrr@users.noreply.github.com> Date: Mon, 26 Jun 2023 23:22:44 +0200 Subject: [PATCH 10/14] fix --- .../org/koitharu/kotatsu/parsers/site/madara/Hentaiteca.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/Hentaiteca.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/Hentaiteca.kt index a92c7ba3..36143777 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/Hentaiteca.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/Hentaiteca.kt @@ -34,7 +34,7 @@ internal class Hentaiteca(context: MangaLoaderContext) : override fun parseDetails(manga: Manga, body: Element, chapters: List): Manga { val root = body.selectFirstOrThrow(".site-content") - val postContent = root.selectFirstOrThrow(".post-content") + val postContent = root.selectFirstOrThrow(".summary_content") val tags = postContent.getElementsContainingOwnText("Gênero(s)") .firstOrNull()?.tableValue() ?.getElementsByAttributeValueContaining("href", tagPrefix) From 9c71d1b57c91d003fc82139c19ec212daa22353d Mon Sep 17 00:00:00 2001 From: devi <70220050+davvarrr@users.noreply.github.com> Date: Mon, 26 Jun 2023 23:23:09 +0200 Subject: [PATCH 11/14] Update Hentaizone.kt --- .../org/koitharu/kotatsu/parsers/site/madara/Hentaizone.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/Hentaizone.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/Hentaizone.kt index 61f303ed..e9b35446 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/Hentaizone.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/Hentaizone.kt @@ -34,7 +34,7 @@ internal class Hentaizone(context: MangaLoaderContext) : override fun parseDetails(manga: Manga, body: Element, chapters: List): Manga { val root = body.selectFirstOrThrow(".site-content") - val postContent = root.selectFirstOrThrow(".post-content") + val postContent = root.selectFirstOrThrow(".summary_content") val tags = postContent.getElementsContainingOwnText("Genre(s)") .firstOrNull()?.tableValue() ?.getElementsByAttributeValueContaining("href", tagPrefix) From 6c31cea155280fed91c194ce060d25e81b244a5e Mon Sep 17 00:00:00 2001 From: devi <70220050+davvarrr@users.noreply.github.com> Date: Mon, 26 Jun 2023 23:23:41 +0200 Subject: [PATCH 12/14] Update HhentaiFr.kt --- .../org/koitharu/kotatsu/parsers/site/madara/HhentaiFr.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/HhentaiFr.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/HhentaiFr.kt index 1b2ce041..367c8468 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/HhentaiFr.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/HhentaiFr.kt @@ -42,7 +42,7 @@ internal class HhentaiFr(context: MangaLoaderContext) : override fun parseDetails(manga: Manga, body: Element, chapters: List): Manga { val root = body.selectFirstOrThrow(".site-content") - val postContent = root.selectFirstOrThrow(".post-content") + val postContent = root.selectFirstOrThrow(".summary_content") val tags = postContent.getElementsContainingOwnText("Genre(s)") .firstOrNull()?.tableValue() ?.getElementsByAttributeValueContaining("href", tagPrefix) From b0e455e163480a145de89a6a7e3b8172eebe244f Mon Sep 17 00:00:00 2001 From: devi <70220050+davvarrr@users.noreply.github.com> Date: Mon, 26 Jun 2023 23:24:09 +0200 Subject: [PATCH 13/14] Update ScantradVf.kt --- .../org/koitharu/kotatsu/parsers/site/madara/ScantradVf.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ScantradVf.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ScantradVf.kt index d7a87554..818d8aac 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ScantradVf.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/ScantradVf.kt @@ -27,7 +27,7 @@ internal class ScantradVf(context: MangaLoaderContext) : override fun parseDetails(manga: Manga, body: Element, chapters: List): Manga { val root = body.selectFirstOrThrow(".site-content") - val postContent = root.selectFirstOrThrow(".post-content") + val postContent = root.selectFirstOrThrow(".summary_content") val tags = postContent.getElementsContainingOwnText("Genre(s)") .firstOrNull()?.tableValue() ?.getElementsByAttributeValueContaining("href", tagPrefix) From e617904b62821e24d7a4136a2badd23066bfa494 Mon Sep 17 00:00:00 2001 From: devi <70220050+davvarrr@users.noreply.github.com> Date: Mon, 26 Jun 2023 23:25:49 +0200 Subject: [PATCH 14/14] Update MangaScantrad.kt --- .../org/koitharu/kotatsu/parsers/site/madara/MangaScantrad.kt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/MangaScantrad.kt b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/MangaScantrad.kt index 8b4357f4..743f79d8 100644 --- a/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/MangaScantrad.kt +++ b/src/main/kotlin/org/koitharu/kotatsu/parsers/site/madara/MangaScantrad.kt @@ -50,7 +50,7 @@ internal class MangaScantrad(context: MangaLoaderContext) : .firstOrNull()?.tableValue()?.text()?.trim(), altTitle = postContent.getElementsContainingOwnText("Alternatif") .firstOrNull()?.tableValue()?.text()?.trim(), - state = postContent.getElementsContainingOwnText("Statut") + state = postContent.getElementsContainingOwnText("État") .firstOrNull()?.tableValue()?.text()?.asMangaState(), tags = tags, isNsfw = body.hasClass("adult-content"),