goyomi/sources/base/fmreader/fmreader.go

// Package fmreader implements the Flat-Manga CMS base (FMReader).
// GET {base}/{requestPath}?listType=pagination&page={n}&sort=views
package fmreader

import (
	"context"
	"fmt"
	"net/http"
	"net/url"
	"strings"

	"github.com/PuerkitoBio/goquery"

	"goyomi/internal/httpclient/flare"
	"goyomi/internal/source"
	"goyomi/sources/base/util"
)

type Config struct {
	Name        string
	BaseURL     string
	Lang        string
	RequestPath string // default "manga-list.html"
}

type Source struct {
	cfg    Config
	client *flare.Client
	id     int64
}

func New(cfg Config) *Source {
	if cfg.RequestPath == "" {
		cfg.RequestPath = "manga-list.html"
	}
	c := flare.NewClient(flare.WithRateLimit(1, 2))
	return &Source{cfg: cfg, client: c, id: source.GenerateSourceID(cfg.Name, cfg.Lang)}
}

func (s *Source) ID() int64           { return s.id }
func (s *Source) Name() string        { return s.cfg.Name }
func (s *Source) Lang() string        { return s.cfg.Lang }
func (s *Source) SupportsLatest() bool { return true }

func (s *Source) get(ctx context.Context, rawURL string) (*goquery.Document, error) {
	resp, err := s.client.Get(ctx, rawURL)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	if resp.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("fmreader: HTTP %d", resp.StatusCode)
	}
	return goquery.NewDocumentFromReader(resp.Body)
}

func (s *Source) listURL(page int, sort, query string) string {
	base := strings.TrimRight(s.cfg.BaseURL, "/")
	u, _ := url.Parse(fmt.Sprintf("%s/%s", base, s.cfg.RequestPath))
	q := u.Query()
	q.Set("listType", "pagination")
	q.Set("page", fmt.Sprintf("%d", page))
	q.Set("sort", sort)
	q.Set("sort_type", "DESC")
	if query != "" {
		q.Set("name", query)
	}
	u.RawQuery = q.Encode()
	return u.String()
}

func (s *Source) parseMangaList(doc *goquery.Document) source.MangasPage {
	var mangas []source.SManga
	doc.Find("div.media, .thumb-item-flow").Each(func(_ int, el *goquery.Selection) {
		m := source.SManga{}
		el.Find("a").First().Each(func(_ int, a *goquery.Selection) {
			if href, ok := a.Attr("href"); ok {
				m.URL = stripDomain(href, s.cfg.BaseURL)
			}
			m.Title = strings.TrimSpace(a.AttrOr("title", a.Text()))
		})
		el.Find("img").First().Each(func(_ int, img *goquery.Selection) {
			m.ThumbnailURL = imgAttr(img, s.cfg.BaseURL)
		})
		if m.URL != "" {
			mangas = append(mangas, m)
		}
	})
	// FMReader uses "page x of y" text or standard next pagination
	hasNext := doc.Find("div.col-lg-9 button.btn-info, .pagination a:contains(»):not(.disabled)").Length() > 0
	return source.MangasPage{Mangas: mangas, HasNextPage: hasNext}
}

func (s *Source) GetPopularManga(page int) (source.MangasPage, error) {
	doc, err := s.get(context.Background(), s.listURL(page, "views", ""))
	if err != nil {
		return source.MangasPage{}, err
	}
	return s.parseMangaList(doc), nil
}

func (s *Source) GetLatestUpdates(page int) (source.MangasPage, error) {
	doc, err := s.get(context.Background(), s.listURL(page, "last_update", ""))
	if err != nil {
		return source.MangasPage{}, err
	}
	return s.parseMangaList(doc), nil
}

func (s *Source) GetSearchManga(page int, query string, filters []source.Filter) (source.MangasPage, error) {
	doc, err := s.get(context.Background(), s.listURL(page, "views", query))
	if err != nil {
		return source.MangasPage{}, err
	}
	return s.parseMangaList(doc), nil
}

func (s *Source) GetMangaDetails(manga source.SManga) (source.SManga, error) {
	doc, err := s.get(context.Background(), util.AbsURL(s.cfg.BaseURL, manga.URL))
	if err != nil {
		return manga, err
	}
	result := source.SManga{URL: manga.URL}
	doc.Find("h1, h2.title").First().Each(func(_ int, el *goquery.Selection) { result.Title = strings.TrimSpace(el.Text()) })
	doc.Find("li a.btn-info").First().Each(func(_ int, el *goquery.Selection) { result.Author = strings.TrimSpace(el.Text()) })
	doc.Find("div.description-update, .manga-description").First().Each(func(_ int, el *goquery.Selection) { result.Description = strings.TrimSpace(el.Text()) })
	doc.Find(".info-image img").First().Each(func(_ int, img *goquery.Selection) { result.ThumbnailURL = imgAttr(img, s.cfg.BaseURL) })
	doc.Find("li a.btn-success").First().Each(func(_ int, el *goquery.Selection) { result.Status = util.StatusFromString(el.Text()) })
	var genres []string
	doc.Find("li a.btn-danger").Each(func(_ int, el *goquery.Selection) {
		if t := strings.TrimSpace(el.Text()); t != "" {
			genres = append(genres, t)
		}
	})
	result.Genre = strings.Join(genres, ", ")
	return result, nil
}

func (s *Source) GetChapterList(manga source.SManga) ([]source.SChapter, error) {
	doc, err := s.get(context.Background(), util.AbsURL(s.cfg.BaseURL, manga.URL))
	if err != nil {
		return nil, err
	}
	var chapters []source.SChapter
	doc.Find("div.row-content-chapter li, #chapterList li").Each(func(_ int, el *goquery.Selection) {
		ch := source.SChapter{}
		el.Find("a").First().Each(func(_ int, a *goquery.Selection) {
			if href, ok := a.Attr("href"); ok {
				ch.URL = stripDomain(href, s.cfg.BaseURL)
			}
			ch.Name = strings.TrimSpace(a.Text())
		})
		el.Find(".chapter-time, .time").First().Each(func(_ int, e *goquery.Selection) {
			ch.DateUpload = util.ParseRelativeDate(e.Text())
		})
		if ch.URL != "" {
			chapters = append(chapters, ch)
		}
	})
	return chapters, nil
}

func (s *Source) GetPageList(chapter source.SChapter) ([]source.Page, error) {
	rawURL := util.AbsURL(s.cfg.BaseURL, chapter.URL)
	doc, err := s.get(context.Background(), rawURL)
	if err != nil {
		return nil, err
	}
	var pages []source.Page
	doc.Find(".reading-detail img, #chapter-content img").Each(func(i int, img *goquery.Selection) {
		if u := imgAttr(img, s.cfg.BaseURL); u != "" {
			pages = append(pages, source.Page{Index: i, URL: rawURL, ImageURL: u})
		}
	})
	return pages, nil
}

func (s *Source) GetImageURL(page source.Page) (string, error) { return page.ImageURL, nil }
func (s *Source) GetFilterList() []source.Filter               { return nil }

func stripDomain(href, baseURL string) string {
	parsed, err := url.Parse(href)
	if err != nil || !parsed.IsAbs() {
		return href
	}
	base, _ := url.Parse(baseURL)
	if base != nil && parsed.Host == base.Host {
		return parsed.RequestURI()
	}
	return href
}

func imgAttr(img *goquery.Selection, baseURL string) string {
	for _, attr := range []string{"data-bg", "data-lazy-src", "data-src", "src"} {
		if v, ok := img.Attr(attr); ok && v != "" && !strings.HasPrefix(v, "data:") {
			return util.AbsURL(baseURL, v)
		}
	}
	return ""
}