mangdown 0.20.8 → 0.21.0.beta1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a09d979891cb14a1db38340293795b8d599d99cdb5cbba07f9d8ca05f5530fc0
-  data.tar.gz: 26099c3ea529e2a0528b20b54b7c9c7ebe2f15e40c547081864e46a031883f9b
+  metadata.gz: 9dd954ee70668eaf60bdb7666da399247cab3b12e5149bc58cabb1e1e69907d1
+  data.tar.gz: 4e6f7bac16b8537de8a54a80afd60c0b86fcb72c3e72e9c125106ca2fa7f7aa9
 SHA512:
-  metadata.gz: 468c99af8dc3353a445e7d0b3e27758cd65f75dbfdd4d6689e641b602b62b8d4a9483c5fb81e2ae21097de59f53f17dca527f3b6e7cf2d0466371c8252547eaa
-  data.tar.gz: 31362635a8d659da879c2a2c36a810f93b3ecbf2d760689ad0a19e6283a01bc20f94877d3f15b512d9b42b5f457d003b8409e02442a46408d44f09ec965ad982
+  metadata.gz: abbeef647bd90011460b32610a71ff2d0023450f50e64f9d2a0a1f31c5a5a0e78a7287ffafecd24cea3f421bd0738ca48828b5b70933983412af86945f6067a6
+  data.tar.gz: c9ee0906dbb2e26bb84be9f7a760cdbcf511420b7234bdbeffe601fbe70c93e229067aa3c16ee86649ef8da873f9682777b84f94f2be716609914eee36294c1b

data/README.md

@@ -1,33 +1,35 @@
-## Adapters [New]
-Check out lib/mangdown/adapter.rb and lib/mangdown/adapters/mangareader.rb for examples of how to build an adapter.
+## Adapters
+Check out lib/mangdown/adapters/mangareader.rb and lib/mangdown/adapters/mangabat.rb for examples of how to build an adapter.
 
 ### Register an adapter
 
 ```
 # Register an adapter (AdapterClass) with the name :name
-Mangdown.register_adapter(:name, AdpaterClass)
+Mangdown.register_adapter(:name, AdpaterClass.new)
 ```
 
 ### Bundled adapters
-There is only one adapter bundled with mangdown, but it is fairly simple to create one, so go ahead and give it a try. Feel free to file an issue if you have any problems.
+There are only two adapters bundled with mangdown, but it is fairly simple to create one, so go ahead and give it a try. Feel free to file an issue if you have any problems.
 
-There is a simple built-in client, "M", that you can use for finding manga:
+There is a simple built-in client, "Mangdown::Client", that you can use for finding manga:
 
 ```ruby
 require 'mangdown/client'
 
 # Search for an exact match
-results = M.find("Dragon Ball")
+results = Mangdown::Client.find("Dragon Ball")
 
 # Or if you need more flexibilty when searching for a manga,
-# use are Regex
-results = M.find(/dragon ball(\ssd)?$/i)
+# use the db models directly
+results = Mangdown::DB::Manga.where(name: 'Bleach').map do |record|
+  Mangdown.manga(record.url)
+end
 
 # Get a Mangdown::Manga object
-manga = results.first.to_manga
+manga = results.first
 
 # Get a chapter count
-manga.count
+manga.chapter.length
 
 # Download everything
 manga.download
@@ -35,6 +37,9 @@ manga.download
 # Download a specific range
 manga.download(0, 99)
 
+# Download to a specific dir
+manga.download_to('path/to/downloads', 0, 99)
+
 # Convert all downloaded chapters to CBZ
 manga.cbz
 

data/db/migrate/001_create_manga_table.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+Sequel.migration do
+  change do
+    create_table(:manga) do
+      primary_key :id
+      String :adapter, null: false
+      String :url, null: false
+      String :name, null: false
+    end
+  end
+end

data/lib/mangdown.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'forwardable'
 require 'addressable/uri'
 require 'mimemagic'
 require 'nokogiri'
@@ -10,47 +11,94 @@ require_relative 'mangdown/error'
 
 require_relative 'mangdown/support/logging'
 require_relative 'mangdown/support/equality'
-require_relative 'mangdown/support/properties'
 require_relative 'mangdown/support/tools'
 require_relative 'mangdown/support/cbz'
 require_relative 'mangdown/page'
 require_relative 'mangdown/chapter'
 require_relative 'mangdown/manga'
-require_relative 'mangdown/manga_list.rb'
-require_relative 'mangdown/md_hash'
 
-require_relative 'mangdown/adapter'
-require_relative 'mangdown/adapter/proxy'
 require_relative 'mangdown/adapter/no_adapter_error'
 require_relative 'mangdown/adapter/not_implemented_error'
-require_relative 'mangdown/adapter/mangareader.rb'
+require_relative 'mangdown/adapter/mangareader'
+require_relative 'mangdown/adapter/manga_bat'
 
 # Find, download and package manga from the web
 module Mangdown
-  DOWNLOAD_DIR ||= Dir.home + '/manga'
+  class <<self
+    include Logging
+  end
 
-  module_function
+  DOWNLOAD_DIR ||= Dir.home + '/manga'
 
-  def register_adapter(name, adapter)
+  def self.register_adapter(name, adapter)
     adapters[name] = adapter
   end
 
-  def adapter(name)
-    adapters[name]
+  def self.adapters
+    @adapters ||= {}
   end
 
-  def adapter!(uri, site = nil, doc = nil, name = nil)
-    adapter_name = (uri || site).to_s
-    klass = adapters.values.find { |adapter| adapter.for?(adapter_name) }
+  def self.manga(uri_or_instance)
+    with_adapter(uri_or_instance, :manga) do |instance|
+      Mangdown::Manga.new(instance)
+    end
+  end
 
-    raise Adapter::NoAdapterError, adapter_name unless klass
+  def self.chapter(uri_or_instance)
+    with_adapter(uri_or_instance, :chapter) do |instance|
+      Mangdown::Chapter.new(instance)
+    end
+  end
 
-    Adapter::Proxy.new(klass.new(uri, doc, name))
+  def self.page(uri_or_instance)
+    with_adapter(uri_or_instance, :page) do |instance|
+      Mangdown::Page.new(instance)
+    end
   end
 
-  def adapters
-    @adapters ||= {}
+  # rubocop:disable Metrics/AbcSize
+  # rubocop:disable Metrics/MethodLength
+  def self.with_adapter(instance, instance_constructor)
+    if instance.is_a?(String)
+      adapter = adapter(instance)
+      instance = adapter.public_send(instance_constructor, instance)
+    else
+      adapter = adapter(instance.url)
+      klass = adapter.class.const_get(instance_constructor.to_s.capitalize)
+      instance = klass.new(instance.attributes)
+    end
+    yield(instance)
+  rescue Adapter::NoAdapterError
+    raise
+  rescue StandardError => error
+    logger.error(debug_error(error, adapter, instance))
+    raise Mangdown::Error, "Adapter failed: #{error.message}"
   end
-end
+  private_class_method :with_adapter
+  # rubocop:enable Metrics/AbcSize
+  # rubocop:enable Metrics/MethodLength
 
-Mangdown.register_adapter(:mangareader, Mangdown::Mangareader)
+  def self.adapter(uri)
+    adapter = adapters.values.find { |a| a.for?(uri) }
+
+    raise Adapter::NoAdapterError, uri unless adapter
+
+    adapter
+  end
+  private_class_method :adapter
+
+  def self.debug_error(error, adapter, instance)
+    {
+      msg: 'Adapter method failed',
+      adapter: adapter.class,
+      instance: instance,
+      error: error,
+      error_msg: error.message,
+      backtrace: error.backtrace
+    }.to_s
+  end
+  private_class_method :debug_error
+
+  register_adapter :mangareader, Mangdown::Mangareader.new
+  register_adapter :manga_bat, Mangdown::MangaBat.new
+end

data/lib/mangdown/adapter/manga_bat.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require 'scrapework'
+
+module Mangdown
+  # Adapter for mangabat
+  class MangaBat
+    ROOT = 'https://mangabat.com/'
+    CDNS = [
+      %r{^https://s\d.mkklcdnv\d.com/mangakakalot}
+    ].freeze
+
+    def for?(uri)
+      uri.to_s.start_with?(ROOT) || cdn_uri?(uri)
+    end
+
+    def cdn_uri?(uri)
+      CDNS.any? { |cdn| uri.match?(cdn) }
+    end
+
+    def manga_list
+      MangaList.load('https://mangabat.com/manga_list')
+    end
+
+    def manga(url)
+      Manga.load(url)
+    end
+
+    def chapter(url)
+      Chapter.load(url)
+    end
+
+    def page(url)
+      Page.load(url)
+    end
+
+    # A manga list web page
+    class MangaList < Scrapework::Object
+      has_many :manga, class: 'Mangdown::MangaBat::Manga'
+
+      def each(*args, &block)
+        to_enum.each(*args, &block)
+      end
+
+      def to_enum
+        Enumerator.new do |yielder|
+          page = self
+
+          while page
+            page.manga.each { |manga| yielder << manga }
+
+            page = page.next_page
+          end
+        end
+      end
+
+      map 'manga' do |html|
+        html.css('.update_item h3 a').map do |a|
+          uri = URI.join(ROOT, a[:href]).to_s
+
+          { url: uri, name: a.text.strip }
+        end
+      end
+
+      paginate do |html|
+        pages = html.css('.group-page a').to_a[1..-2]
+        current = pages.find_index { |p| p['class'] == 'pageselect' }
+
+        prev_page_link = pages[current - 1] if current
+        next_page_link = pages[current + 1] if current
+
+        prev_page = { url: prev_page_link['href'] } if prev_page_link
+        next_page = { url: next_page_link['href'] } if next_page_link
+
+        [prev_page, next_page]
+      end
+    end
+
+    # A manga web page
+    class Manga < Scrapework::Object
+      attribute :name
+
+      has_many :chapters, class: 'Mangdown::MangaBat::Chapter'
+
+      map :name do |html|
+        html.css('h1.entry-title').text.strip
+      end
+
+      map :chapters do |html|
+        html.css('.chapter-list .row a').reverse.map.with_index do |chapter, i|
+          i += 1
+          padded_number = i.to_s.rjust(5, '0')
+          chapter_name = "#{name} #{padded_number}"
+
+          { url: chapter['href'], name: chapter_name, number: i }
+        end
+      end
+    end
+
+    # A manga chapter web page
+    class Chapter < Scrapework::Object
+      attribute :name
+      attribute :number, type: Integer
+
+      belongs_to :manga, class: 'Mangdown::MangaBat::Manga'
+      has_many :pages, class: 'Mangdown::MangaBat::Page'
+
+      map :name do |html|
+        name = html.at_css('h1.entry-title').text.strip
+        name.sub(/Chapter (\d+)/) { Regexp.last_match[1].rjust(5, '0') }
+      end
+
+      map :number do
+        _mapped_name.slice(/Chapter (\d+)/, 1)
+      end
+
+      map :manga do |html|
+        manga = html.at_css('.breadcrumbs_doc p span:nth-child(3) a')
+
+        { url: manga['href'], name: manga.text.strip }
+      end
+
+      map :pages do |html|
+        html.css('.vung_doc img').map.with_index do |page, i|
+          i += 1
+          url = page['src']
+          padded_number = i.to_s.rjust(3, '0')
+          padded_chapter = number.to_s.rjust(5, '0')
+          name = "#{manga.name} #{padded_chapter}-#{padded_number}"
+
+          { url: url, name: name, number: i }
+        end
+      end
+
+      def hydra_opts
+        { max_concurrency: 10 }
+      end
+    end
+
+    # A manga page image
+    class Page < Scrapework::Object
+      attribute :name
+      attribute :number, type: Integer
+
+      belongs_to :chapter, class: 'Mangdown::MangaBat::Chapter'
+    end
+  end
+end

data/lib/mangdown/adapter/mangareader.rb

@@ -1,134 +1,162 @@
 # frozen_string_literal: true
 
-require 'cgi'
+require 'scrapework'
 
 module Mangdown
-  # Mangdown adapter for mangareader
-  class Mangareader < Adapter::Base
-    site :mangareader
-
-    attr_reader :root
-
-    def initialize(uri, doc, name)
-      super
-
-      @root = 'https://www.mangareader.net'
+  # Adapter for mangareader
+  class Mangareader
+    ROOT = 'https://www.mangareader.net'
+
+    def for?(uri)
+      URI.parse(uri).host&.end_with?('mangareader.net')
+    rescue URI::Error
+      false
     end
 
-    def is_manga_list?(uri = @uri)
-      uri == "#{root}/alphabetical"
+    def manga_list
+      MangaList.load('https://www.mangareader.net/alphabetical')
     end
 
-    def is_manga?(uri = @uri)
-      uri.slice(%r{#{root}(/\d+)?(/[^/]+)(\.html)?}i) == uri
+    def manga(url)
+      Manga.load(url)
     end
 
-    def is_chapter?(uri = @uri)
-      uri.slice(%r{#{root}(/[^/]+){1,2}/(\d+|chapter-\d+\.html)}i) == uri
+    def chapter(url)
+      Chapter.load(url)
     end
 
-    def is_page?(uri = @uri)
-      uri.slice(/.+\.(png|jpg|jpeg)$/i) == uri
+    def page(url)
+      Page.load(url)
     end
 
-    # Only valid mangas should be returned (using is_manga?(uri))
-    def manga_list
-      doc.css('ul.series_alpha li a').map do |a|
-        uri = "#{root}#{a[:href]}"
-        manga = { uri: uri, name: a.text.strip.tr('/', ''), site: site }
+    # A mangareader manga list
+    class MangaList < Scrapework::Object
+      has_many :manga, class: 'Mangdown::Mangareader::Manga'
 
-        manga if is_manga?(uri)
-      end.compact
-    end
+      map :manga do |html|
+        html.css('ul.series_alpha li a').map do |a|
+          uri = "#{ROOT}#{a[:href]}"
 
-    def manga
-      { uri: uri, name: manga_name, site: site }
-    end
+          { url: uri, name: a.text.strip }
+        end
+      end
 
-    # Only valid chapters should be returned (using is_chapter?(uri))
-    def chapter_list
-      doc.css('div#chapterlist td a').map do |a|
-        uri = root + a[:href].sub(root, '')
-        chapter = { uri: uri, name: a.text.strip.tr('/', ''), site: site }
+      def each(&block)
+        manga.each(&block)
+      end
 
-        chapter if is_chapter?(uri)
-      end.compact
+      def to_enum
+        manga.to_enum
+      end
     end
 
-    def chapter
-      { uri: uri,
-        manga: manga_name,
-        name: chapter_name,
-        chapter: chapter_number,
-        site: site }
-    end
+    # A mangareader manga
+    class Manga < Scrapework::Object
+      attribute :name
+
+      has_many :chapters, class: 'Mangdown::Mangareader::Chapter'
 
-    def page_list
-      last_page = doc.css('select')[1].css('option').length
-      (1..last_page).map do |page|
-        slug = manga_name.tr(' ', '-').gsub(%r{[:,!'&/]}, '')
-        uri = "#{root}/#{slug}/#{chapter_number}/#{page}"
-        uri = Addressable::URI.escape(uri).downcase
-        { uri: uri, name: page, site: site }
+      map :name do |html|
+        html.at_css('h2.aname').text.strip
+      end
+
+      map :chapters do |html|
+        html.css('div#chapterlist td a').map.with_index do |a, i|
+          uri = ROOT + a[:href]
+
+          { url: uri, name: a.text.strip, number: i + 1 }
+        end
       end
     end
 
-    def page
-      page_image = doc.css('img')[0]
-      uri = page_image[:src]
-      name = page_image[:alt].sub(/([^\d]*)(\d+)(\.\w+)?$/) do
-        Regexp.last_match[1].to_s + Regexp.last_match[2].to_s.rjust(3, '0')
+    # A mangareader chapter
+    class Chapter < Scrapework::Object
+      attribute :name
+      attribute :number, type: Integer
+
+      belongs_to :manga, class: 'Mangdown::Mangareader::Manga'
+      has_many :page_views, class: 'Mangdown::Mangareader::PageView'
+
+      map :name do |html|
+        name = html.at_css('#mangainfo h1').text.strip
+        name.sub(/(\d+)$/) { Regexp.last_match[1].rjust(5, '0') }
       end
 
-      { uri: uri, name: name.to_s.tr('/', ''), site: site }
-    end
+      map :number do |html|
+        _mapped_name.slice(/(\d+)$/, 1)
+      end
 
-    private
+      map :manga do |html|
+        manga = html.at_css('#mangainfo h2.c2 a')
 
-    def manga_name
-      if is_manga?
-        name = doc.css('h2.aname').text
-      elsif is_chapter?
-        name = chapter_manga_name
+        {
+          url: "#{ROOT}#{manga['href']}",
+          name: manga.text.strip.sub(/ Manga$/, '')
+        }
       end
 
-      return unless name
+      map :page_views do |html|
+        html.css('#selectpage select#pageMenu option').map.with_index do |op, i|
+          i += 1
+          uri = "#{ROOT}#{op['value']}"
+          padded_number = i.to_s.rjust(3, '0')
+          padded_chapter = number.to_s.rjust(5, '0')
+          name = "#{manga.name} #{padded_chapter}-#{padded_number}"
 
-      name = name.gsub(%r{[/]}, '')
-      CGI.unescapeHTML(name)
-    end
+          { url: uri, name: name, number: i }
+        end
+      end
+
+      def hydra_opts
+        {}
+      end
 
-    def chapter_name
-      name = if @name
-               @name.sub(/\s(\d+)$/) { |num| ' ' + num.to_i.to_s.rjust(5, '0') }
-             else
-               doc.css('').text # Not implimented
-             end
+      def pages
+        return @pages if defined?(@pages)
 
-      return unless name
+        threads = []
+        page_views.each do |page_view|
+          threads << Thread.new(page_view, &:page)
+        end
+        threads.each(&:join)
 
-      name = name.gsub(%r{[/]}, '')
-      CGI.unescapeHTML(name)
+        @pages = page_views.map(&:page)
+      end
     end
 
-    def chapter_manga_name
-      name = if @name
-               @name.slice(/(^.+)\s/, 1)
-             else
-               doc.css('').text # Not implimented
-             end
+    # A mangareader page
+    class PageView < Scrapework::Object
+      attribute :name
+      attribute :number, type: Integer
 
-      return unless name
+      belongs_to :chapter, class: 'Mangdown::Mangareader::Chapter'
+      has_one :page, class: 'Mangdown::Mangareader::Page'
 
-      name = name.gsub(%r{[/]}, '')
-      CGI.unescapeHTML(name)
+      alias uri url
+
+      map :chapter do |html|
+        name = html.at_css('.mangainfo h1').text.strip
+        op = html.css('#selectpage select#pageMenu option').first
+
+        { url: "#{ROOT}#{op['href']}", name: name }
+      end
+
+      map :page do |html|
+        img = html.at_css('#imgholder img#img')
+
+        { url: img['src'], name: name, number: number }
+      end
     end
 
-    def chapter_number
-      if @name
-        @name.slice(/\d+\z/).to_i
-      else
-        doc.css('').text # Not implimented
+    # A mangareader page
+    class Page < Scrapework::Object
+      attribute :name
+      attribute :number, type: Integer
+
+      belongs_to :page_view, class: 'Mangdown::Mangareader::PageView'
+
+      def chapter
+        page_view.chapter
       end
     end
   end