mangdown 0.20.8 → 0.21.0.beta1

data/lib/mangdown/chapter.rb

@@ -3,26 +3,26 @@
 module Mangdown
   # Mangdown chapter object, which holds pages
   class Chapter
+    extend Forwardable
+
     include Equality
-    include Enumerable
 
-    attr_reader :uri, :pages, :name, :manga, :chapter
-    attr_accessor :adapter
+    attr_reader :chapter
+
+    def_delegators :chapter, :url, :name, :number
+
+    alias uri url
 
-    def initialize(uri, name, manga, chapter = nil)
-      @name = name
-      @manga = manga
+    def initialize(chapter)
       @chapter = chapter
-      @uri = Addressable::URI.escape(uri)
-      @pages = []
     end
 
-    def each(&block)
-      @pages.each(&block)
+    def pages
+      @pages ||= chapter.pages.map { |page| Mangdown.page(page) }
     end
 
-    def to_chapter
-      self
+    def manga
+      @manga ||= Mangdown.manga(chapter.manga)
     end
 
     def path
@@ -31,8 +31,8 @@ module Mangdown
     alias to_path path
 
     def setup_path(dir = nil)
-      dir ||= File.join(DOWNLOAD_DIR, manga)
-      path = File.join(dir, name)
+      dir ||= manga.path
+      path = Tools.file_join(dir, name)
       path = Tools.valid_path_name(path)
       @path = Tools.relative_or_absolute_path(path)
     end
@@ -41,8 +41,11 @@ module Mangdown
       CBZ.one(dir)
     end
 
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # rubocop:disable Metrics/MethodLength
+    # rubocop:disable Metrics/PerceivedComplexity
     def download_to(dir = nil, opts = { force_download: false })
-      pages = map(&:to_page)
       failed = []
       succeeded = []
       skipped = []
@@ -53,10 +56,13 @@ module Mangdown
         setup_download_dir!(dir)
       end
 
-      Tools.hydra_streaming(pages, adapter.hydra_opts) do |stage, page, data = nil|
+      Tools.hydra_streaming(
+        pages,
+        chapter.hydra_opts
+      ) do |stage, page, data = nil|
         case stage
         when :failed
-          failed << page
+          failed << [page, data]
         when :succeeded
           succeeded << page
         when :before
@@ -72,13 +78,10 @@ module Mangdown
 
       { failed: failed, succeeded: succeeded, skipped: skipped }
     end
-
-    def load_pages
-      return @pages if @pages.any?
-
-      fetch_each_page { |page| @pages << page }
-      @pages.sort_by!(&:name)
-    end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/CyclomaticComplexity
+    # rubocop:enable Metrics/MethodLength
+    # rubocop:enable Metrics/PerceivedComplexity
 
     private
 
@@ -86,38 +89,5 @@ module Mangdown
       setup_path(dir)
       FileUtils.mkdir_p(to_path) unless Dir.exist?(to_path)
     end
-
-    def fetch_each_page
-      pages = build_page_hashes
-      page_data = Hash.new { |h, k| h[k] = +'' }
-      Tools.hydra_streaming(pages, adapter.hydra_opts) do |status, page, data = nil|
-        case status
-        when :before
-          true
-        when :body
-          page_data[page] << data
-        when :complete
-          page = get_page(page.uri, Nokogiri::HTML(page_data[page]))
-          yield(page)
-        end
-      end
-    end
-
-    def build_page_hashes
-      adapter.page_list.map do |page|
-        page[:chapter] = name
-        page[:manga] = manga
-        MDHash.new(page)
-      end
-    end
-
-    def get_page(uri, doc)
-      adapter = Mangdown.adapter!(uri, nil, doc)
-      page = adapter.page
-      page[:chapter] = name
-      page[:manga] = manga
-
-      MDHash.new(page)
-    end
   end
 end

data/lib/mangdown/client.rb

@@ -2,21 +2,24 @@
 
 require_relative '../mangdown'
 
-# Simple client for Mangdown
-module M
-  DATA_FILE_PATH = Dir.home + '/.manga_list.yml'
-  HELP_FILE_PATH = File.expand_path(
-    '../../README.md', File.dirname(__FILE__)
-  )
+require_relative 'db'
 
-  DEFAULT_MANGA_PAGES = ['https://www.mangareader.net/alphabetical'].freeze
+module Mangdown
+  # Simple client for Mangdown
+  module Client
+    class <<self
+      include Logging
+    end
+
+    module_function
 
-  class << self
     # return a list of hash with :uri and :name of mangas found in list
     def find(search)
-      search = Regexp.new(/^#{search}$/) if search.respond_to?(:to_str)
-
-      current_manga_list.select { |manga| manga[:name] =~ search }
+      filter = Sequel.lit('LOWER(name) LIKE ?', "%#{search.downcase}%")
+      order = Sequel[:name]
+      Mangdown::DB::Manga.where(filter).order(order).map do |manga|
+        Mangdown.manga(manga.url)
+      end
     end
 
     # cbz all subdirectories in a directory
@@ -26,51 +29,25 @@ module M
       raise Mangdown::Error, "Failed to package #{dir}: #{error.message}"
     end
 
-    # display help file
-    def help
-      puts File.read(HELP_FILE_PATH)
-    end
-
-    # delete data file
-    def clean_up
-      File.delete(DATA_FILE_PATH) if File.exist?(DATA_FILE_PATH)
-    end
-
-    def manga_pages
-      @manga_pages ||= DEFAULT_MANGA_PAGES.dup
-    end
-
-    private
-
-    # convenience method to access the data file path
-    def path
-      DATA_FILE_PATH
-    end
-
-    # check if the data file is current
-    def file_current?(file)
-      File.exist?(file) && File.mtime(file) > (Time.now - 604_800)
-    end
+    # rubocop:disable Metrics/MethodLength
+    # load manga into sqlite db
+    def index_manga
+      count_before = Mangdown::DB::Manga.count
 
-    # attempt to get the list from the data file
-    def data_from_file
-      YAML.load(File.read(path)) if file_current?(path)
-    end
+      Mangdown.adapters.each do |name, adapters|
+        adapters.manga_list.each do |manga|
+          Mangdown::DB::Manga.find_or_create(
+            adapter: name,
+            url: manga.url,
+            name: manga.name
+          )
+        end
+      end
 
-    # get saved current manga list, if data is less than a week old
-    # otherwise fetch new data and write it to the data file
-    def current_manga_list
-      data = data_from_file
-      return Mangdown::MangaList.from_data(data) if data
+      count_after = Mangdown::DB::Manga.count
 
-      list = manga_pages.inject([]) do |manga, uri|
-        list = Mangdown::MDHash.new(uri: uri).to_manga_list
-        list.merge(manga)
-      end
-      File.open(path, 'w+') { |f| f.write(list.to_yaml) }
-      list
-    rescue StandardError => error
-      raise Mangdown::Error, "#{path} may be corrupt: #{error.message}"
+      logger.info("#{count_after} manga, #{count_after - count_before} new")
     end
+    # rubocop:enable Metrics/MethodLength
   end
 end

data/lib/mangdown/db.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'sequel'
+require 'sqlite3'
+
+module Mangdown
+  # DB Connection
+  module DB
+    DB_MIGRATE = File.expand_path('../../db/migrate', __dir__)
+    DB_FILE = File.expand_path('../../db/mangdown.db', __dir__)
+
+    unless File.exist?(DB_FILE)
+      begin
+        SQLite3::Database.new(DB_FILE)
+      rescue StandardError
+        File.delete(DB_FILE)
+        raise
+      end
+    end
+
+    CONNECTION = Sequel.connect("sqlite://#{DB_FILE}")
+    Sequel.extension(:migration)
+    Sequel::Migrator.run(CONNECTION, DB_MIGRATE)
+  end
+end
+
+require_relative 'db/manga'

data/lib/mangdown/db/manga.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Mangdown
+  module DB
+    # DB model for manga
+    class Manga < Sequel::Model(Mangdown::DB::CONNECTION[:manga])
+    end
+  end
+end

data/lib/mangdown/manga.rb

@@ -3,17 +3,25 @@
 module Mangdown
   # Mangdown manga object, which holds chapters
   class Manga
+    extend Forwardable
+
     include Equality
-    include Enumerable
     include Logging
 
-    attr_reader :uri, :chapters, :name
-    attr_accessor :adapter
+    attr_accessor :manga
+
+    def_delegators :manga, :url, :name
 
-    def initialize(uri, name)
-      @name = name
-      @uri = Addressable::URI.escape(uri)
-      @chapters = []
+    alias uri url
+
+    def initialize(manga)
+      @manga = manga
+    end
+
+    def chapters
+      @chapters ||= manga
+                    .chapters
+                    .map { |chapter| Mangdown.chapter(chapter) }
     end
 
     def cbz
@@ -24,7 +32,8 @@ module Mangdown
       download_to(nil, *args)
     end
 
-    # download using enumerable
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength
     def download_to(dir, start = 0, stop = -1, opts = { force_download: false })
       start, stop = validate_indeces!(start, stop)
       setup_download_dir!(dir)
@@ -32,16 +41,15 @@ module Mangdown
       succeeded = []
       skipped = []
 
-      chapters[start..stop].each do |md_hash|
-        chapter = md_hash.to_chapter
+      chapters[start..stop].each do |chapter|
         chapter_result = chapter.download_to(to_path, opts)
 
         if chapter_result[:failed].any?
-          failed << chapter
+          failed << [chapter, chapter_result]
         elsif chapter_result[:succeeded].any?
-          succeeded << chapter
+          succeeded << [chapter, chapter_result]
         elsif chapter_result[:skipped].any?
-          skipped << chapter
+          skipped << [chapter, chapter_result]
         end
 
         next unless chapter_result[:failed].any?
@@ -52,12 +60,11 @@ module Mangdown
           chapter: chapter.name
         }.to_s)
       end
-      { failed: failed, succeeded: succeeded, skipped: skipped }
-    end
 
-    def to_manga
-      self
+      { failed: failed, succeeded: succeeded, skipped: skipped }
     end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
 
     def path
       @path ||= setup_path
@@ -66,21 +73,10 @@ module Mangdown
 
     def setup_path(dir = nil)
       dir ||= DOWNLOAD_DIR
-      path = File.join(dir, name)
+      path = Tools.file_join(dir, name)
       @path = Tools.relative_or_absolute_path(path)
     end
 
-    def each(&block)
-      @chapters.each(&block)
-    end
-
-    def load_chapters
-      @chapters += adapter.chapter_list.map do |chapter|
-        chapter[:manga] = name
-        MDHash.new(chapter)
-      end
-    end
-
     private
 
     def chapter_indeces(start, stop)

data/lib/mangdown/page.rb

@@ -3,21 +3,23 @@
 module Mangdown
   # Mangdown page
   class Page
+    extend Forwardable
+
     include Equality
     include Logging
 
-    attr_reader :uri, :name, :manga, :chapter
+    attr_reader :page
+
+    def_delegators :page, :url, :name
+
+    alias uri url
 
-    def initialize(uri, name, manga, chapter)
-      @name = Tools.valid_path_name(name)
-      @chapter = chapter
-      @manga = manga
-      @uri = Addressable::URI.escape(uri)
+    def initialize(page)
+      @page = page
     end
 
-    # explicit conversion to page
-    def to_page
-      self
+    def chapter
+      @chapter ||= Mangdown.chapter(page.chapter)
     end
 
     def path
@@ -29,15 +31,16 @@ module Mangdown
     # without file extension if file is not found. File extensions
     # are appended only after the file has been downloaded.
     def setup_path(dir = nil)
-      dir ||= File.join(manga, chapter)
+      dir ||= chapter.path
       dir = Tools.valid_path_name(dir)
+      name = self.name.tr('/', '')
       file = Dir.entries(dir).find { |f| f[name] } if Dir.exist?(dir)
-      path = File.join(dir, file || name)
+      path = Tools.file_join(dir, file || name)
       @path = Tools.relative_or_absolute_path(path)
     end
 
-    # downloads to specified directory
-    def download_to(dir = Dir.pwd, force_download: false)
+    # rubocop:disable Metrics/MethodLength
+    def download_to(dir = Dir.pwd, opts = { force_download: false })
       delete_files!(dir) if opts[:force_download]
 
       return if file_exist?(dir)
@@ -56,6 +59,7 @@ module Mangdown
         backtrace: error.backtrace
       }.to_s)
     end
+    # rubocop:enable Metrics/MethodLength
 
     def append_file_data(_dir, data)
       File.open(to_path, 'ab') { |file| file.write(data) }

data/lib/mangdown/support/cbz.rb

@@ -29,10 +29,9 @@ module Mangdown
 
         ::Zip::File.open(zip_filename, ::Zip::File::CREATE) do |zip|
           file_matcher = File.join(dir, '**', '**')
-          dir << '/'
 
           Dir.glob(file_matcher).each do |file|
-            filename = file.sub(dir, '')
+            filename = file.sub("#{dir}/", '')
             zip.add(filename, file)
           end
         end