manga-downloadr 1.0.4 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6a3825e68d8726f3736ece8f9516fa33010391dc
-  data.tar.gz: 623c2e036a456dbd5ca82a27b2c881fc711ceae6
+  metadata.gz: b083f3caf90e18e3afa86b91fbbd6d54c1b14236
+  data.tar.gz: 14ba9e5c6f03356dd90446b966acf73caf201b28
 SHA512:
-  metadata.gz: 512ede770e7dd1dea258c037f675ea199eadcf2b1f9d392ff027f57cd0ab6f365ebc72799a0e753af43125e77d2d8ea405d6a55a62f31ca51a50e58d872b610c
-  data.tar.gz: 31d1bbc52d3a41544e29552a5fe393366fba7b73991377015f4181fd22eb5a1f6538c54cda7f4d2ef178c7cbdb8666ac6c0332016894f646c5ed4de5e46cbf2f
+  metadata.gz: d15ce2ed73541b567ded076918b114b359443256749e5a12d488f0de9271d69ad0ba3be176557b33d41ec4aeb93952216a7398620b7d77a306ad75fb5a760959
+  data.tar.gz: 03a5734f26846feb483d645aaaf504adab7167cd73004a36e7b347e4c08d16927a33cfbf07289bc2b61a2ddf89a244b47dcdf0230c28a257feee2a6f10f41bdb

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2014 Fabio Akita
+Copyright (c) 2014-2016 Fabio Akita
 
 MIT License
 

data/README.md

@@ -1,29 +1,49 @@
 # Manga Downloadr
 
-I just bought a new Kindle Paperwhite and so happens it's the perfect form factor
-to read good old, black and white, mangas.
+[![Build Status](https://travis-ci.org/akitaonrails/manga-downloadr.svg)](https://travis-ci.org/akitaonrails/manga-downloadr)
+[![Code Climate](https://codeclimate.com/repos/54ac0c066956802e06000ffb/badges/441f1f6af106cc32b2b5/gpa.svg)](https://codeclimate.com/repos/54ac0c066956802e06000ffb/feed)
+[![Test Coverage](https://codeclimate.com/repos/54ac0c066956802e06000ffb/badges/441f1f6af106cc32b2b5/coverage.svg)](https://codeclimate.com/repos/54ac0c066956802e06000ffb/feed)
 
-So I decided to automate the process of fetching manga images from MangaReader.net,
-optimize and compile them into PDF files that fit the Kindle resolution.
+I just bought a new Kindle Paperwhite and so happens it's the perfect form factor to read good old, black and white, mangas.
+
+So I decided to automate the process of fetching manga images from MangaReader.net, optimize and compile them into PDF files that fit the Kindle resolution.
 
 ## Installation
 
-Just install with:
+Setup your environment with:
+
+    sudo apt-get install imagemagick
+    sudo gem install bundler
+
+And install manga-downloadr with:
 
-```
-gem install manga-downloadr
-```
+    gem install manga-downloadr
 
 ## Usage
 
 And then execute:
 
-    $ manga-downloadr -n berserk -u http://www.mangareader.net/96/berserk.html -d /MyDocuments/MyMangas
+    $ manga-downloadr -u http://www.mangareader.net/onepunch-man -d /tmp/onepunch-man
+
+In this example, all the pages of the "One Punch Man" will be downloaded to the directory "/tmp/onepunch-man" and they will have the following filename format:
+
+    /tmp/onepunch-man/Onepunch-Man-Chap-00038-Pg-00011.jpg
+
+## Development
+
+Tests are in Rspec:
+
+    bundle exec rspec
+
+Version 2.0 is a complete rewrite, following what was learned writing my [Elixir version](https://github.com/akitaonrails/ex_manga_downloadr).
+
+This is basically a port of the [Crystal version](https://github.com/akitaonrails/cr_manga_downloadr).
+
+Elixir has superb parallelism and concurrency through Erlang's OTP architecture so it's easy to process hundreds of parallel requests, limited only to what MangaReader can respond.
 
-If there's any interruption (bad network) you can run the same command line again and it will resume from
-where it was interrupted before.
+Crystal is also super fast (because its compiled to native code) and has very good concurrency (through the use of Go-like CSP channels).
 
-If you want to restart from scratch, delete the "/tmp/[your manga].yml" that saves the current workflow state.
+This Ruby version uses native Threads. Because this is I/O intensive, we assume we can run several HTTP requests concurrently. But because Threads have significantly more overhead than Elixir or Crystal architectures, we will be limited by Ruby's MRI interpreter.
 
 ## Contributing
 
@@ -35,5 +55,6 @@ If you want to restart from scratch, delete the "/tmp/[your manga].yml" that sav
 
 ## TODO
 
+* Version 2.0 removes the crash-recovery (saving state) from Version 1.0 - could be reimplemented
 * Move MangaReader specifics to a different class
 * Add support for MangaFox and other manga sites

data/bin/manga-downloadr

@@ -1,27 +1,42 @@
 #!/usr/bin/env ruby
-$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
-require 'optparse'
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), "..", "lib")
+require "optparse"
+require "manga-downloadr"
+
+opt_manga_directory  = "/tmp"
+opt_manga_root_uri   = ""
+opt_batch_size       = 50
+opt_resize_format    = "600x800"
+opt_pages_per_volume = 250
 
-options = {}
 option_parser = OptionParser.new do |opts|
-  opts.banner = "Usage: manga-downloadr [options]"
+  # Set a banner, displayed at the top
+  # of the help screen.
+  opts.banner = "Scraps all the images from all pages of a MangaReader.net manga"
+
+  opts.on( "-d DIRECTORY", "--d DIRECTORY", "the directory path where to save the manga" ) do |directory|
+    opt_manga_directory = directory
+  end
+
+  opts.on( "-u URL", "--url URL", "the MangaReader full URI to the chapters index of the manga" ) do |url|
+    opt_manga_root_uri = url
+  end
 
-  opts.on("-u URL", "--url URL",
-    "Full MangaReader.net manga homepage URL - required") do |v|
-    options[:url] = v
+  opts.on( "-b BATCH_SIZE", "-batch 50", "the amount of concurrent HTTP fetches to the MangaReader site, don't overdo it") do |batch|
+    opt_batch_size = batch.to_i
   end
 
-  opts.on("-n NAME", "--name NAME",
-    "slug to be used for the sub-folder to store all manga files - required") do |n|
-    options[:name] = n
+  opts.on( "-r FORMAT", "--resize 600x800", "the current Kindle format is 600x800 but you can change it") do |format|
+    opt_resize_format = format
   end
 
-  opts.on("-d DIRECTORY", "--directory DIRECTORY",
-    "main folder where all mangas will be stored - required") do |d|
-    options[:directory] = d
+  opts.on( "-v PAGES", "--volume 250", "how many pages should each PDF volume have") do |volume|
+    opt_pages_per_volume = volume.to_i
   end
 
-  opts.on("-h", "--help", "Show this message") do
+  # This displays the help screen, all programs are
+  # assumed to have this option.
+  opts.on( "-h", "--help", "Display this screen" ) do
     puts opts
     exit
   end
@@ -35,25 +50,8 @@ rescue OptionParser::ParseError
   exit
 end
 
-require 'manga-downloadr'
-generator = MangaDownloadr::Workflow.create(options[:url], options[:name], options[:directory])
-unless generator.state?(:chapter_urls)
-  puts "Massive parallel scanning of all chapters "
-  generator.fetch_chapter_urls!
-end
-unless generator.state?(:page_urls)
-  puts "\nMassive parallel scanning of all pages "
-  generator.fetch_page_urls!
-end
-unless generator.state?(:image_urls)
-  puts "\nMassive parallel scanning of all images "
-  generator.fetch_image_urls!
-  puts "\nTotal page links found: #{generator.chapter_pages_count}"
-end
-unless generator.state?(:images)
-  puts "\nMassive parallel download of all page images "
-  generator.fetch_images!
+if opt_manga_root_uri.size > 0
+  root_uri = URI.parse(opt_manga_root_uri)
+  config = MangaDownloadr::Config.new(root_uri.host, root_uri.path, opt_manga_directory, opt_batch_size, opt_resize_format, opt_pages_per_volume)
+  MangaDownloadr::Workflow.run(config)
 end
-puts "\nCompiling all images into PDF volumes "
-generator.compile_ebooks!
-puts "\nProcess finished."

data/lib/manga-downloadr.rb

@@ -1,219 +1,19 @@
-require 'rubygems'
-require 'bundler/setup'
-
-require 'nokogiri'
-require 'typhoeus'
-require 'fileutils'
-require 'rmagick'
-require 'prawn'
-require 'fastimage'
-require 'open-uri'
-require 'yaml'
-
-# Seems like retryability is unstable at this point, commenting out
-# if ENV['RUBY_ENV'].nil?
-#   require 'retryable_typhoeus'
-#   Typhoeus::Request.send(:include, RetryableTyphoeus::RequestExtension)
-#   Typhoeus::Hydra.send(:include, RetryableTyphoeus::HydraExtension)
-# else
-#   Typhoeus::Hydra.send(:alias_method, :queue_with_retry, :queue)
-# end
-
-module MangaDownloadr
-  ImageData = Struct.new(:folder, :filename, :url)
-
-  class Workflow
-    attr_accessor :manga_root_url, :manga_root, :manga_root_folder, :manga_name, :hydra_concurrency
-    attr_accessor :chapter_list, :chapter_pages, :chapter_images, :download_links, :chapter_pages_count
-    attr_accessor :manga_title, :pages_per_volume, :page_size
-    attr_accessor :processing_state
-    attr_accessor :fetch_page_urls_errors, :fetch_image_urls_errors, :fetch_images_errors
-
-    def initialize(root_url = nil, manga_name = nil, manga_root = nil, options = {})
-      root_url or raise ArgumentError.new("URL is required")
-      manga_root or raise ArgumentError.new("Manga root folder is required")
-      manga_name or raise ArgumentError.new("Manga slug is required")
-
-      self.manga_root_url    = root_url
-      self.manga_root        = manga_root
-      self.manga_root_folder = File.join(manga_root, manga_name)
-      self.manga_name        = manga_name
-
-      self.hydra_concurrency = options[:hydra_concurrency] || 100
-
-      self.chapter_pages    = {}
-      self.chapter_images   = {}
-
-      self.pages_per_volume = options[:pages_per_volume] || 250
-      self.page_size        = options[:page_size] || [600, 800]
-
-      self.processing_state        = []
-      self.fetch_page_urls_errors  = []
-      self.fetch_image_urls_errors = []
-      self.fetch_images_errors     = []
-    end
-
-    def fetch_chapter_urls!
-      doc = Nokogiri::HTML(open(manga_root_url))
-
-      self.chapter_list = doc.css("#listing a").map { |l| l['href']}
-      self.manga_title  = doc.css("#mangaproperties h1").first.text
-
-      current_state :chapter_urls
-    end
-
-    def fetch_page_urls!
-      hydra = Typhoeus::Hydra.new(max_concurrency: hydra_concurrency)
-      chapter_list.each do |chapter_link|
-        begin
-          request = Typhoeus::Request.new "http://www.mangareader.net#{chapter_link}"
-          request.on_complete do |response|
-            begin
-              chapter_doc = Nokogiri::HTML(response.body)
-              # pages = chapter_doc.css('#selectpage #pageMenu option')
-              pages = chapter_doc.xpath("//div[@id='selectpage']//select[@id='pageMenu']//option")
-              chapter_pages.merge!(chapter_link => pages.map { |p| p['value'] })
-              puts chapter_link
-              # print '.'
-            rescue => e
-              self.fetch_page_urls_errors << { url: chapter_link, error: e, body: response.body }
-              print 'x'
-            end
-          end
-          hydra.queue request
-        rescue => e
-          puts e
-        end
-      end
-      hydra.run
-      unless fetch_page_urls_errors.empty?
-        puts "\n Errors fetching page urls:"
-        puts fetch_page_urls_errors
-      end
-
-      self.chapter_pages_count = chapter_pages.values.inject(0) { |total, list| total += list.size }
-      current_state :page_urls
-    end
-
-    def fetch_image_urls!
-      hydra = Typhoeus::Hydra.new(max_concurrency: hydra_concurrency)
-      chapter_list.each do |chapter_key|
-        chapter_pages[chapter_key].each do |page_link|
-          begin
-            request = Typhoeus::Request.new "http://www.mangareader.net#{page_link}"
-            request.on_complete do |response|
-              begin
-                chapter_doc = Nokogiri::HTML(response.body)
-                image       = chapter_doc.css('#img').first
-                tokens      = image['alt'].match("^(.*?)\s\-\s(.*?)$")
-                extension   = File.extname(URI.parse(image['src']).path)
-
-                chapter_images.merge!(chapter_key => []) if chapter_images[chapter_key].nil?
-                chapter_images[chapter_key] << ImageData.new( tokens[1], "#{tokens[2]}#{extension}", image['src'] )
-                print '.'
-              rescue => e
-                self.fetch_image_urls_errors << { url: page_link, error: e }
-                print 'x'
-              end
-            end
-            hydra.queue request
-          rescue => e
-            puts e
-          end
-        end
-      end
-      hydra.run
-      unless fetch_image_urls_errors.empty?
-        puts "\nErrors fetching image urls:"
-        puts fetch_image_urls_errors
-      end
-
-      current_state :image_urls
-    end
-
-    def fetch_images!
-      hydra = Typhoeus::Hydra.new(max_concurrency: hydra_concurrency)
-      chapter_list.each_with_index do |chapter_key, chapter_index|
-        chapter_images[chapter_key].each do |file|
-            downloaded_filename = File.join(manga_root_folder, file.folder, file.filename)
-            next if File.exists?(downloaded_filename) # effectively resumes the download list without re-downloading everything
-            request = Typhoeus::Request.new file.url
-            request.on_complete do |response|
-              begin
-                # download
-                FileUtils.mkdir_p(File.join(manga_root_folder, file.folder))
-                File.open(downloaded_filename, "wb+") { |f| f.write response.body }
-
-                # resize
-                image = Magick::Image.read( downloaded_filename ).first
-                resized = image.resize_to_fit(600, 800)
-                resized.write( downloaded_filename ) { self.quality = 50 }
-
-                print '.'
-                GC.start # to avoid a leak too big (ImageMagick is notorious for that, specially on resizes)
-              rescue => e
-                self.fetch_images_errors << { url: file.url, error: e }
-                print '.'
-              end
-            end
-          hydra.queue request
-        end
-      end
-      hydra.run
-      unless fetch_images_errors.empty?
-        puts "\nErrors downloading images:"
-        puts fetch_images_errors
-      end
-
-      current_state :images
-    end
-
-    def compile_ebooks!
-      folders = Dir[manga_root_folder + "/*/"].sort_by { |element| ary = element.split(" ").last.to_i }
-      self.download_links = folders.inject([]) do |list, folder|
-        list += Dir[folder + "*.*"].sort_by { |element| ary = element.split(" ").last.to_i }
-      end
-
-      # concatenating PDF files (250 pages per volume)
-      chapter_number = 0
-      while !download_links.empty?
-        chapter_number += 1
-        pdf_file = File.join(manga_root_folder, "#{manga_title} #{chapter_number}.pdf")
-        list = download_links.slice!(0..pages_per_volume)
-        Prawn::Document.generate(pdf_file, page_size: page_size) do |pdf|
-          list.each do |image_file|
-            begin
-              pdf.image image_file, position: :center, vposition: :center
-            rescue => e
-              puts "Error in #{image_file} - #{e}"
-            end
-          end
-        end
-        print '.'
-      end
-
-      current_state :ebooks
-    end
-
-    def state?(state)
-      self.processing_state.include?(state)
-    end
-
-    private def current_state(state)
-      self.processing_state << state
-      MangaDownloadr::Workflow.serialize(self)
-    end
-
-    class << self
-      def serialize(obj)
-        File.open("/tmp/#{obj.manga_name}.yaml", 'w') {|f| f.write(YAML::dump(obj)) }
-      end
-
-      def create(root_url, manga_name, manga_root, options = {})
-        dump_file_name = "/tmp/#{manga_name}.yaml"
-        return YAML::load(File.read(dump_file_name)) if File.exists?(dump_file_name)
-        MangaDownloadr::Workflow.new(root_url, manga_name, manga_root, options)
-      end
-    end
-  end
-end
+require "rubygems"
+require "bundler/setup"
+
+require "chainable_methods"
+require "nokogiri"
+require "fileutils"
+require "net/http"
+require "open-uri"
+
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), "lib")
+
+require "manga-downloadr/records.rb"
+require "manga-downloadr/downloadr_client.rb"
+require "manga-downloadr/concurrency.rb"
+require "manga-downloadr/chapters.rb"
+require "manga-downloadr/pages.rb"
+require "manga-downloadr/page_image.rb"
+require "manga-downloadr/image_downloader.rb"
+require "manga-downloadr/workflow.rb"

data/lib/manga-downloadr/chapters.rb

@@ -0,0 +1,15 @@
+module MangaDownloadr
+  class Chapters < DownloadrClient
+    def initialize(domain, root_uri)
+      @root_uri = root_uri
+      super(domain)
+    end
+
+    def fetch
+      get @root_uri do |html|
+        nodes = html.css("#listing a")
+        nodes.map { |node| node["href"] }
+      end
+    end
+  end
+end

data/lib/manga-downloadr/concurrency.rb

@@ -0,0 +1,28 @@
+module MangaDownloadr
+  class Concurrency
+    def initialize(engine_klass = nil, config = Config.new, turn_on_engine = true)
+      @engine_klass = engine_klass
+      @config = config
+      @turn_on_engine = turn_on_engine
+    end
+
+    def fetch(collection, &block)
+      results = []
+      collection&.each_slice(@config.download_batch_size) do |batch|
+        mutex   = Mutex.new
+        threads = batch.map do |item|
+          Thread.new {
+            engine  = @turn_on_engine ? @engine_klass.new(@config.domain) : nil
+            Thread.current["results"] = block.call(item, engine)&.flatten
+            mutex.synchronize do
+              results += Thread.current["results"]
+            end
+          }
+        end
+        threads.each(&:join)
+        puts "Processed so far: #{results&.size}"
+      end
+      results
+    end
+  end
+end

data/lib/manga-downloadr/downloadr_client.rb

@@ -0,0 +1,24 @@
+module MangaDownloadr
+  class DownloadrClient
+    def initialize(domain)
+      @domain = domain
+      @http_client = Net::HTTP.new(@domain)
+    end
+
+    def get(uri, &block)
+      response = @http_client.get(uri)
+      case response.code
+      when "301"
+        get response.headers["Location"], &block
+      when "200"
+        parsed = Nokogiri::HTML(response.body)
+        block.call(parsed)
+      end
+    rescue Net::HTTPGatewayTimeOut, Net::HTTPRequestTimeOut
+      # TODO: naive infinite retry, it will loop infinitely if the link really doesn't exist
+      # so should have a way to control the amount of retries per link
+      sleep 1
+      get(uri, &block)
+    end
+  end
+end

data/lib/manga-downloadr/image_downloader.rb

@@ -0,0 +1,19 @@
+module MangaDownloadr
+  class ImageDownloader < DownloadrClient
+    def fetch(image_src, filename)
+      File.delete(filename) if File.exists?(filename)
+      response = @http_client.get(image_src)
+      case response.code
+      when "301"
+        fetch(response.headers["Location"], filename)
+      when "200"
+        File.open(filename, "w") do |f|
+          f.print response.body
+        end
+      end
+    rescue Net::HTTPGatewayTimeOut, Net::HTTPRequestTimeOut
+      sleep 1
+      fetch(image_src, filename)
+    end
+  end
+end

data/lib/manga-downloadr/page_image.rb

@@ -0,0 +1,25 @@
+module MangaDownloadr
+  class PageImage < DownloadrClient
+    def fetch(page_link)
+      get page_link do |html|
+        images = html.css('#img')
+
+        image_alt = images[0]["alt"]
+        image_src = images[0]["src"]
+
+        if image_alt && image_src
+          extension      = image_src.split(".").last
+          list           = image_alt.split(" ").reverse
+          title_name     = list[4..-1].join(" ")
+          chapter_number = list[3].rjust(5, '0')
+          page_number    = list[0].rjust(5, '0')
+
+          uri = URI.parse(image_src)
+          Image.new(uri.host, uri.path, "#{title_name}-Chap-#{chapter_number}-Pg-#{page_number}.#{extension}")
+        else
+          raise Exception.new("Couldn't find proper metadata alt in the image tag")
+        end
+      end
+    end
+  end
+end

data/lib/manga-downloadr/pages.rb

@@ -0,0 +1,10 @@
+module MangaDownloadr
+  class Pages < DownloadrClient
+    def fetch(chapter_link)
+      get chapter_link do |html|
+        nodes = html.xpath("//div[@id='selectpage']//select[@id='pageMenu']//option")
+        nodes.map { |node| [chapter_link, node.children.to_s].join("/") }
+      end
+    end
+  end
+end

data/lib/manga-downloadr/records.rb

@@ -0,0 +1,4 @@
+module MangaDownloadr
+  Image  = Struct.new *%i[host path filename]
+  Config = Struct.new *%i[domain root_uri download_directory download_batch_size image_dimensions pages_per_volume]
+end

data/lib/manga-downloadr/version.rb

@@ -1,3 +1,3 @@
 module MangaDownloadr
-  VERSION = "1.0.4"
+  VERSION = "2.0.0"
 end

data/lib/manga-downloadr/workflow.rb

@@ -0,0 +1,83 @@
+module MangaDownloadr
+  class Workflow
+    def self.run(config = Config.new)
+      FileUtils.mkdir_p config.download_directory
+
+      CM(Workflow, config)
+        .fetch_chapters
+        .fetch_pages(config)
+        .fetch_images(config)
+        .download_images(config)
+        .optimize_images(config)
+        .prepare_volumes(config)
+        .unwrap
+
+      puts "Done!"
+    end
+
+    def self.fetch_chapters(config)
+      puts "Fetching chapters ..."
+      chapters = Chapters.new(config.domain, config.root_uri).fetch
+      puts "Number of Chapters: #{chapters&.size}"
+      chapters
+    end
+
+    def self.fetch_pages(chapters, config)
+      puts "Fetching pages from all chapters ..."
+      reactor = Concurrency.new(Pages, config)
+      reactor.fetch(chapters) do |link, engine|
+        engine&.fetch(link)
+      end
+    end
+
+    def self.fetch_images(pages, config)
+      puts "Feching the Image URLs from each Page ..."
+      reactor = Concurrency.new(PageImage, config)
+      reactor.fetch(pages) do |link, engine|
+        [ engine&.fetch(link) ]
+      end
+    end
+
+    def self.download_images(images, config)
+      puts "Downloading each image ..."
+      reactor = Concurrency.new(ImageDownloader, config, false)
+      reactor.fetch(images) do |image, _|
+        image_file = File.join(config.download_directory, image.filename)
+        unless File.exists?(image_file)
+          ImageDownloader.new(image.host).fetch(image.path, image_file)
+        end
+        [ image_file ]
+      end
+    end
+
+    def self.optimize_images(downloads, config)
+      puts "Running mogrify to convert all images down to Kindle supported size (600x800)"
+      `mogrify -resize #{config.image_dimensions} #{config.download_directory}/*.jpg`
+      downloads
+    end
+
+    def self.prepare_volumes(downloads, config)
+      manga_name = config.download_directory.split("/")&.last
+      index = 1
+      volumes = []
+      downloads.each_slice(config.pages_per_volume) do |batch|
+        volume_directory = "#{config.download_directory}/#{manga_name}_#{index}"
+        volume_file      = "#{volume_directory}.pdf"
+        volumes << volume_file
+        FileUtils.mkdir_p volume_directory
+
+        puts "Moving images to #{volume_directory} ..."
+        batch.each do |file|
+          destination_file = file.split("/").last
+          `mv #{file} #{volume_directory}/#{destination_file}`
+        end
+
+        puts "Generating #{volume_file} ..."
+        `convert #{volume_directory}/*.jpg #{volume_file}`
+
+        index += 1
+      end
+      volumes
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: manga-downloadr
 version: !ruby/object:Gem::Version
-  version: 1.0.4
+  version: 2.0.0
 platform: ruby
 authors:
 - AkitaOnRails
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-04 00:00:00.000000000 Z
+date: 2016-06-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nokogiri
@@ -25,63 +25,35 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.6'
 - !ruby/object:Gem::Dependency
-  name: typhoeus
+  name: chainable_methods
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: 0.1.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: 0.1.2
 - !ruby/object:Gem::Dependency
-  name: rmagick
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.13'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.13'
-- !ruby/object:Gem::Dependency
-  name: prawn
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.3'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.3'
-- !ruby/object:Gem::Dependency
-  name: fastimage
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.6'
-  type: :runtime
+        version: '0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -95,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: webmock
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -109,7 +81,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: webmock
+  name: pry
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -134,8 +106,15 @@ files:
 - Rakefile
 - bin/manga-downloadr
 - lib/manga-downloadr.rb
+- lib/manga-downloadr/chapters.rb
+- lib/manga-downloadr/concurrency.rb
+- lib/manga-downloadr/downloadr_client.rb
+- lib/manga-downloadr/image_downloader.rb
+- lib/manga-downloadr/page_image.rb
+- lib/manga-downloadr/pages.rb
+- lib/manga-downloadr/records.rb
 - lib/manga-downloadr/version.rb
-- lib/retryable_typhoeus.rb
+- lib/manga-downloadr/workflow.rb
 homepage: http://github.com/akitaonrails/manga-downloadr
 licenses:
 - MIT
@@ -156,7 +135,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.3
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: downloads and compile to a Kindle optimized manga in PDF

data/lib/retryable_typhoeus.rb

@@ -1,40 +0,0 @@
-# original source: https://gist.github.com/kunalmodi/2939288
-module RetryableTyphoeus
-  DEFAULT_RETRIES = 1
-
-  module RequestExtension
-    def original_on_complete=(proc)
-      @original_on_complete = proc
-    end
-
-    def original_on_complete
-      @original_on_complete
-    end
-
-    def retries=(retries)
-      @retries = retries
-    end
-
-    def retries
-      @retries ||= 0
-    end
-  end
-
-  module HydraExtension
-    def queue_with_retry(request, opts = {})
-      request.retries = (opts[:retries] || RetryableTyphoeus::DEFAULT_RETRIES).to_i
-      request.original_on_complete ||= request.on_complete
-      request.on_complete do |response|
-        if response.success? || response.request.retries <= 0
-          request.original_on_complete.map do |callback|
-            response.handled_response = callback.call(response)
-          end
-        else
-          response.request.retries -= 1
-          queue response.request
-        end
-      end
-      queue request
-    end
-  end
-end