ReadAllComics: fix search & missing chapters (#13875)

* fix: popular page asks user to use search

* fix: bug in searching titles

* fix: comic description

* chore: bump extVersionCode from 6 to 7

* fear: migrate from ParsedHttpSource to HttpSource

* fix: proper server-side search pagination

* fix: address pr review comments

Author: al-shamiry

src/en/readallcomicscom/build.gradle

@@ -1,7 +1,7 @@
 ext {
     extName = 'ReadAllComics'
     extClass = '.ReadAllComics'
-    extVersionCode = 6
+    extVersionCode = 7
 }
 
 apply from: "$rootDir/common.gradle"

src/en/readallcomicscom/src/eu/kanade/tachiyomi/extension/en/readallcomicscom/ReadAllComics.kt

@@ -1,27 +1,24 @@
 package eu.kanade.tachiyomi.extension.en.readallcomicscom
 
 import eu.kanade.tachiyomi.network.GET
-import eu.kanade.tachiyomi.network.asObservableSuccess
 import eu.kanade.tachiyomi.source.model.FilterList
 import eu.kanade.tachiyomi.source.model.MangasPage
 import eu.kanade.tachiyomi.source.model.Page
 import eu.kanade.tachiyomi.source.model.SChapter
 import eu.kanade.tachiyomi.source.model.SManga
-import eu.kanade.tachiyomi.source.online.ParsedHttpSource
+import eu.kanade.tachiyomi.source.online.HttpSource
 import eu.kanade.tachiyomi.util.asJsoup
 import keiyoushi.utils.tryParse
 import okhttp3.HttpUrl.Companion.toHttpUrl
 import okhttp3.Request
 import okhttp3.Response
-import org.jsoup.nodes.Document
 import org.jsoup.nodes.Element
-import org.jsoup.select.Elements
 import rx.Observable
 import java.text.SimpleDateFormat
 import java.util.Locale
 import java.util.TimeZone
 
-class ReadAllComics : ParsedHttpSource() {
+class ReadAllComics : HttpSource() {
 
     override val name = "ReadAllComics"
 
@@ -31,125 +28,81 @@ class ReadAllComics : ParsedHttpSource() {
 
     override val supportsLatest = false
 
-    private lateinit var searchPageElements: Elements
-
     override val client = network.cloudflareClient
 
-    override fun popularMangaRequest(page: Int): Request {
-        val url = baseUrl.toHttpUrl().newBuilder().apply {
-            addPathSegments("page/$page")
-        }.build()
+    // Popular
 
-        return GET(url, headers)
-    }
+    override fun fetchPopularManga(page: Int): Observable<MangasPage> = throw Exception("Use search to find comics.")
 
-    override fun popularMangaFromElement(element: Element): SManga {
-        val manga = SManga.create().apply {
-            val category = element.classNames()
-                .firstOrNull { it.startsWith("category-") }!!
-                .substringAfter("category-")
-            setUrlWithoutDomain("/category/$category")
-            title = category.replace("-", " ").titleCaseWords()
-            thumbnail_url = element.selectFirst("img")?.attr("src")
-        }
-
-        return manga
-    }
+    override fun popularMangaRequest(page: Int) = throw UnsupportedOperationException()
+    override fun popularMangaParse(response: Response) = throw UnsupportedOperationException()
 
-    override fun popularMangaSelector() = "#post-area > div"
-    override fun popularMangaNextPageSelector() = "a.page-numbers.next"
-
-    override fun fetchSearchManga(page: Int, query: String, filters: FilterList): Observable<MangasPage> = if (page == 1) {
-        client.newCall(searchMangaRequest(page, query, filters))
-            .asObservableSuccess()
-            .map { searchMangaParse(it) }
-    } else {
-        Observable.just(searchPageParse(page))
-    }
+    // Search
 
     override fun searchMangaRequest(page: Int, query: String, filters: FilterList): Request {
         val url = baseUrl.toHttpUrl().newBuilder().apply {
             addQueryParameter("story", query)
             addQueryParameter("s", "")
             addQueryParameter("type", "comic")
+            if (page > 1) addQueryParameter("paged", page.toString())
         }.build()
 
         return GET(url, headers)
     }
 
     override fun searchMangaParse(response: Response): MangasPage {
-        searchPageElements = response.asJsoup().select(searchMangaSelector())
-
-        return searchPageParse(1)
+        val document = response.asJsoup()
+        val mangas = document.select("ul.list-story.categories li").map { mangaFromElement(it) }
+        val hasNextPage = document.selectFirst("a.next") != null
+        return MangasPage(mangas, hasNextPage)
     }
 
-    private fun searchPageParse(page: Int): MangasPage {
-        val mangas = mutableListOf<SManga>()
-        val endRange = ((page * 24) - 1).let { if (it <= searchPageElements.lastIndex) it else searchPageElements.lastIndex }
+    private fun mangaFromElement(element: Element) = SManga.create().apply {
+        val titleAnchor = element.selectFirst("a.cat-title")!!
+        setUrlWithoutDomain(titleAnchor.attr("abs:href"))
+        title = titleAnchor.text()
+        thumbnail_url = element.selectFirst("img.book-cover")?.attr("abs:src")
+    }
 
-        for (i in (((page - 1) * 24)..endRange)) {
-            mangas.add(
-                searchMangaFromElement(searchPageElements[i]),
-            )
-        }
+    // Manga details
 
-        return MangasPage(mangas, endRange < searchPageElements.lastIndex)
+    override fun mangaDetailsParse(response: Response) = SManga.create().apply {
+        val archive = response.asJsoup().selectFirst(".description-archive")!!
+        title = archive.selectFirst("h1")!!.text()
+        thumbnail_url = archive.selectFirst("p img")?.attr("abs:src")
+        val infoStrongs = archive.select(".b > p strong")
+        genre = infoStrongs.firstOrNull()?.text()
+        author = infoStrongs.lastOrNull()?.text()
+        description = archive.selectFirst("#hidden-description")?.wholeText()?.trim()
     }
 
-    override fun searchMangaFromElement(element: Element) = SManga.create().apply {
-        setUrlWithoutDomain(element.attr("href"))
-        title = element.text()
-        thumbnail_url = ""
-    }
+    // Chapters
 
-    override fun searchMangaSelector() = ".categories a"
-    override fun searchMangaNextPageSelector() = null
-
-    override fun mangaDetailsParse(document: Document) = SManga.create().apply {
-        title = document.selectFirst("h1")!!.text()
-        genre = document.select("p strong").joinToString { it.text() }
-        author = document.select("p > strong").last()?.text()
-        description = buildString {
-            document.select(".b > strong").forEach { element ->
-                val vol = element.previousElementSibling()
-                if (isNotBlank()) {
-                    append("\n\n")
-                }
-                if (vol?.tagName() == "span") {
-                    append(vol.text(), "\n")
-                }
-                append(element.text())
-            }
+    override fun chapterListParse(response: Response): List<SChapter> = response.asJsoup().select(".list-story a").map { element ->
+        SChapter.create().apply {
+            setUrlWithoutDomain(element.attr("abs:href"))
+            name = element.text()
+            val year = name.substringAfterLast('(').substringBefore(')')
+            date_upload = dateFormat.tryParse("$year-1-1")
         }
-        thumbnail_url = document.select("p img").attr("abs:src")
     }
 
-    override fun chapterListSelector() = ".list-story a"
+    // Pages
 
-    override fun chapterFromElement(element: Element) = SChapter.create().apply {
-        setUrlWithoutDomain(element.attr("href"))
-        name = element.text()
-        // can only get the year from chapter title
-        val year = name.substringAfterLast('(').substringBefore(')')
-        date_upload = dateFormat.tryParse("$year-1-1")
+    override fun pageListParse(response: Response): List<Page> = response.asJsoup().select("body img:not(div[id=logo] img)").mapIndexed { idx, element ->
+        Page(idx, imageUrl = element.attr("abs:src"))
     }
 
-    override fun pageListParse(document: Document): List<Page> = document.select("body img:not(body div[id=\"logo\"] img)").mapIndexed { idx, element ->
-        Page(idx, "", element.attr("abs:src"))
-    }
+    override fun imageUrlParse(response: Response) = throw UnsupportedOperationException()
 
-    private fun String.titleCaseWords(): String {
-        val words = this.split(" ")
-        return words.joinToString(" ") { word -> word.replaceFirstChar { it.titlecase() } }
-    }
+    // Latest (unsupported)
 
-    override fun imageUrlParse(document: Document) = throw UnsupportedOperationException()
     override fun latestUpdatesRequest(page: Int) = throw UnsupportedOperationException()
-    override fun latestUpdatesFromElement(element: Element) = throw UnsupportedOperationException()
-    override fun latestUpdatesSelector() = throw UnsupportedOperationException()
-    override fun latestUpdatesNextPageSelector() = throw UnsupportedOperationException()
+    override fun latestUpdatesParse(response: Response) = throw UnsupportedOperationException()
 
     companion object {
-        val dateFormat = SimpleDateFormat("yyyy-MM-dd", Locale.US).apply { timeZone = TimeZone.getTimeZone("UTC") }
+        val dateFormat = SimpleDateFormat("yyyy-MM-dd", Locale.US).apply {
+            timeZone = TimeZone.getTimeZone("UTC")
+        }
     }
 }