mangdown 0.13.4 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1b46ede1b55f92c1ff03e43c64890bcb77f98838
-  data.tar.gz: ce4927534522cc6bf0ab39deece40bb58d7524d8
+  metadata.gz: ceaa6642dfcb70513d084ec3b636d2c0855a9928
+  data.tar.gz: e6f2920b7f48afb586aeb038543a2f32ac6e1267
 SHA512:
-  metadata.gz: 669578148a673bdd314a4f49cb541947e473d9286e907f51effc28e298d877ac56f68c44830c4c6b123732deacb289395d96bf13245d5f2db28d8e61305748f1
-  data.tar.gz: c4e48d29330badd3ebd2166262b6fa62783b0ce614ccac4907ec7b7e2c4259618aa16c8535d0498770451ee507bc5f8f33f599757235573063eb0c5145e7a0c9
+  metadata.gz: e6ef238870bac0cd688769574919aea5ab8dffcd59b52f17ce1cbe315310179394c572972ffa34045a036a4f1d7eb200700a12ff9fb2e00756bb8b3afceddc8a
+  data.tar.gz: f9c15ca24c70f1abd1eabbe33af7a90ed68f300fe5397877a8a76ab3ee1966d9cd2e2b4337871a637c0a0dcd3bbbbc6c86b6df7bd1feefe2dc3933849ae3f606

data/README.md

@@ -2,9 +2,16 @@
 
 There is a simple built-in client, "M", that you can use for finding manga:
 
-```
+```ruby
+require 'mangdown/client'
+
+# Search for an exact match
 results = M.find("Dragon Ball")
 
+# Or if you need more flexibilty when searching for a manga, 
+# use are Regex
+results = M.find(/dragon ball(\ssd)?$/i)
+
 # Get a Mangdown::Manga object
 manga = results.first.to_manga
 

data/lib/mangdown/adapter/mangareader.rb

@@ -1,54 +1,118 @@
 module Mangdown
   class Mangareader < Adapter::Base
-    Mangdown::ADAPTERS << self
+
+    site :mangareader
+
+    attr_reader :root
 
     def initialize(uri, doc, name)
       super
-      @root                  ||= 'http://www.mangareader.net'
-      @manga_list_css        = 'ul.series_alpha li a'
-      @manga_name_css        = 'h2.aname'
-      @chapter_list_css      = 'div#chapterlist td a'
-      @manga_list_uri        = "#{@root}/alphabetical"
-      @manga_link_prefix     = @root 
-      @reverse_chapters      = false
-      @manga_uri_regex       = 
-        /#{@root}(\/\d+)?(\/[^\/]+)(\.html)?/i
-      @chapter_uri_regex     = 
-        /#{@root}(\/[^\/]+){1,2}\/(\d+|chapter-\d+\.html)/i
-      @page_uri_regex        = /.+\.(png|jpg|jpeg)$/i
+
+      @root = 'http://www.mangareader.net'
     end
 
-    def manga_name
-      CGI.unescapeHTML(super)
+    def is_manga_list?(uri = @uri)
+      uri == "#{root}/alphabetical"
     end
 
-    def build_page_uri(uri, manga, chapter, page_num)
-      slug = slug(manga)
-      "#{root}/#{slug}/#{chapter}/#{page_num}"
+    def is_manga?(uri = @uri)
+      uri.slice(/#{root}(\/\d+)?(\/[^\/]+)(\.html)?/i) == uri
     end
 
-    def num_pages
-      doc.css('select')[1].css('option').length
+    def is_chapter?(uri = @uri)
+      uri.slice(/#{root}(\/[^\/]+){1,2}\/(\d+|chapter-\d+\.html)/i) == uri
     end
 
-    def page_image_src
-      page_image[:src]
+    def is_page?(uri = @uri)
+      uri.slice(/.+\.(png|jpg|jpeg)$/i) == uri
+    end
+
+    # Only valid mangas should be returned (using is_manga?(uri))
+    def manga_list
+      doc.css('ul.series_alpha li a').map { |a| 
+        uri = "#{root}#{a[:href]}"
+        manga = { uri: uri, name: a.text.strip, site: site }
+
+        manga if is_manga?(uri)
+      }.compact
     end
 
-    def page_image_name
-      page_image[:alt].sub(/([^\d]*)(\d+)(\.\w+)?$/) { 
-        "#{Regexp.last_match[1]}" +
-        "#{Regexp.last_match[2].to_s.rjust(3, '0')}"
+    def manga
+      { uri: uri, name: manga_name, site: site }
+    end
+
+    # Only valid chapters should be returned (using is_chapter?(uri))
+    def chapter_list
+      doc.css('div#chapterlist td a').map { |a|
+        uri = root + a[:href].sub(root, '')
+        chapter = { uri: uri, name: a.text.strip, site: site }
+
+        chapter if is_chapter?(uri)
+      }.compact
+    end
+
+    def chapter
+      { uri: uri, 
+        manga: manga_name, 
+        name: chapter_name,
+        chapter: chapter_number,
+        site: site }
+    end
+
+    def page_list
+      last_page = doc.css('select')[1].css('option').length
+      (1..last_page).map { |page|  
+        slug = manga_name.gsub(' ', '-').gsub(/[:,]/, '')
+        uri = "#{root}/#{slug}/#{chapter_number}/#{page}"
+        uri = Mangdown::Uri.new(uri).downcase 
+
+        { uri: uri, name: page, site: site } }
+    end
+
+    def page
+      page_image = doc.css('img')[0]
+      uri = page_image[:src]
+      name = page_image[:alt].sub(/([^\d]*)(\d+)(\.\w+)?$/) { 
+        Regexp.last_match[1].to_s + Regexp.last_match[2].to_s.rjust(3, '0')
       }
+
+      { uri: uri, name: name, site: site }
     end
 
     private
-    def page_image
-      doc.css('img')[0]
+
+    def manga_name
+      if is_manga?
+        name = doc.css('h2.aname').text
+      elsif is_chapter?
+        name = chapter_manga_name
+      end
+
+      CGI.unescapeHTML(name) if name
+    end
+
+    def chapter_name
+      if @name
+        @name.sub(/\s(\d+)$/) { |num| ' ' + num.to_i.to_s.rjust(5, '0') }
+      else
+        doc.css("").text # Not implimented
+      end
+    end
+
+    def chapter_manga_name
+      if @name
+        @name.slice(/(^.+)\s/, 1) 
+      else
+        doc.css("").text # Not implimented
+      end
     end
 
-    def slug(string)
-      string.gsub(' ', '-').gsub(/[:,]/, '')
+    def chapter_number
+      if @name
+        @name.slice(/\d+\z/).to_i 
+      else
+        doc.css("").text # Not implimented
+      end
     end
   end
 end

data/lib/mangdown/adapter/no_adapter_error.rb

@@ -2,7 +2,7 @@ module Mangdown
   module Adapter
     class NoAdapterError < StandardError
       def initialize(site)
-        super("Bad Site: No Properties Specified for Site: #{site.inspect}")
+        super("Bad Site: No Adapter Specified for Site: #{site.inspect}")
       end
     end
   end

data/lib/mangdown/adapter.rb

@@ -1,143 +1,81 @@
 module Mangdown
   module Adapter
     class Base
-      
-      attr_reader :root
-      def initialize(uri, doc, name)
-        @uri, @doc, @name = uri, doc, name
-        #@root                    = '' 
-        #@manga_list_css          = ''
-        #@chapter_list_css        = ''
-        #@manga_name_css          = ''
-        #@chapter_name_css        = ''
-        #@chapter_manga_name_css  = ''
-        #@chapter_number_css        = ''
-        #@manga_list_uri          = '' 
-        #@manga_link_prefix       = '' 
-        #@reverse_chapters        = true || false
-        #@manga_uri_regex         = /.*/i 
-        #@chapter_uri_regex       = /.*/i
-        #@page_uri_regex          = /.*/i
-      end
 
-      def self.type
-        name.split('::').last.downcase.to_sym
+      # Returns something truthy if this adapter should be used for the 
+      # given url or adapter name
+      def self.for?(url_or_adapter_name)
+        url_or_adapter_name[site.to_s]
       end
 
-      def type
-        self.class.type
+      def self.site(site = nil)
+        site ? @_site = site : @_site
       end
-
-      # Override this if you want to use an adapter name for a site that is 
-      # not matched in the site's url
-      # e.g. CoolAdapterName < Adapter::Base
-      # def site
-      #   "mangareader"
-      # end
-      def self.site
-        type.to_s
+      
+      attr_reader :uri, :doc, :name
+      def initialize(uri, doc, name)
+        @uri = uri
+        @doc = doc
+        @name = name
       end
 
       def site
         self.class.site
       end
 
+      # Overwrite if you want to check the uri if it belongs to a manga list
+      def is_manga_list?(uri = @uri)
+        raise NotImplementedError
+      end
+
       # Must return true/false if uri represents a manga for adapter
       def is_manga?(uri = @uri)
-        uri.slice(@manga_uri_regex) == uri
+        raise NotImplementedError
       end
 
       # Must return true/false if uri represents a chapter for adapter
       def is_chapter?(uri = @uri)
-        uri.slice(@chapter_uri_regex) == uri
+        raise NotImplementedError
       end
 
       # Must return true/false if uri represents a page for adapter
       def is_page?(uri = @uri)
-        uri.slice(@page_uri_regex) == uri
-      end
-
-      # Must return a string
-      def manga_name
-        if is_manga?
-          doc.css(@manga_name_css).text
-        elsif is_chapter?
-          chapter_manga_name
-        end
-      end
-
-      def chapter_name
-        if @name
-          @name.sub(/\s(\d+)$/) { |num| ' ' + num.to_i.to_s.rjust(5, '0') }
-        else
-          doc.css(@chapter_name_css).text
-        end
-      end
-
-      def chapter_manga_name
-        if @name
-          @name.slice(/(^.+)\s/, 1) 
-        else
-          doc.css(@chapter_manga_name_css).text
-        end
-      end
-
-      def chapter_number
-        raise NoMethodError, "Not a chapter" unless is_chapter?
-        if @name
-          @name.slice(/\d+\z/).to_i 
-        else
-          doc.css(@chapter_number_css).text
-        end
+        raise NotImplementedError
       end
 
-      # Must return a uri for a page given the arguments
-      def build_page_uri(uri, manga, chapter, page_num)
+      # Return Array of Hash with keys: :uri, :name, :site
+      def manga_list
+        raise NotImplementedError
       end
 
-      # Must return the number of pages for a chapter 
-      def num_pages
+      # Return Hash with keys: :uri, :name, :site
+      def manga
+        raise NotImplementedError
       end
 
-      # Must return the src for the page image
-      def page_image_src
+      # Return Array of Hash with keys: :uri, :name, :site
+      def chapter_list
+        raise NotImplementedError
       end
 
-      # Must return the name of the page image
-      def page_image_name
+      # Return Hash with keys: :uri, :name, :chapter, :manga, :site
+      def chapter
+        raise NotImplementedError
       end
 
-      # If no block given, must return an array arrays 
-      # [manga_uri, manga_name, adapter_type]
-      # If block given, then the block may alter this array
-      # Only valid mangas should be returned (using is_manga?(uri))
-      def collect_manga_list
-        doc.css(@manga_list_css).map { |a| 
-          manga = ["#{@manga_link_prefix}#{a[:href]}", a.text.strip, type]
-          if is_manga?(manga.first)
-            block_given? ? yield(manga) : manga
-          end
-        }.compact
+      # Return Array of Hash with keys: :uri, :name, :site
+      def page_list
+        raise NotImplementedError
       end
 
-      # If no block given, must return an array arrays 
-      # [chapter_uri, chapter_name, adapter_type]
-      # If block given, then the block may alter this array
-      # Only valid chapters should be returned (using is_chapter?(uri))
-      def manga_chapters
-        chapters = doc.css(@chapter_list_css).map { |a|
-          link = root + a[:href].sub(root, '')
-          chapter = [link, a.text.strip, type]
-          if is_chapter?(chapter.first)
-            block_given? ? yield(chapter) : chapter 
-          end
-        }.compact
-        @reverse_chapters ? chapters.reverse : chapters
+      # Return Hash with keys: :uri, :name, :site
+      def page
+        raise NotImplementedError
       end
 
       private
       def doc
-        @doc ||= Tools.get_doc(@uri)
+        @doc ||= Tools.get_doc(uri)
       end
     end
   end

data/lib/mangdown/chapter.rb

@@ -4,35 +4,21 @@ module Mangdown
     include Equality
     include Enumerable
 
-    attr_reader :uri, :pages
+    attr_reader :uri, :pages, :name, :manga, :chapter
+    attr_accessor :adapter
 
-    def initialize(uri, name = nil, manga = nil, chapter = nil)
-      # use a valid name
+    def initialize(uri, name, manga, chapter = nil)
       @name = name 
       @manga = manga
       @chapter = chapter
       @uri = Mangdown::Uri.new(uri)
-      @properties = Properties.new(@uri, nil, nil, name)
-
-      load_pages
-    end
-
-    def name
-      @name ||= @properties.chapter_name
-    end
-
-    def manga
-       @manga ||= @properties.manga_name
-    end
-
-    def chapter
-      @chapter ||= @properties.chapter_number
+      @pages = []
     end
 
     def inspect
       "#<#{self.class} @name=#{name} @uri=#{uri} " +
-      "@pages=[#{pages.first(10).join(',')}"       +
-      "#{",..." if pages.length > 10}]>"
+      "@pages=[#{pages.first(3).join(',')}"       +
+      "#{",..." if pages.length > 3}]>"
     end
     alias_method :to_s, :inspect
 
@@ -94,19 +80,19 @@ module Mangdown
       { failed: failed, succeeded: succeeded, skipped: skipped }
     end
 
-    private
-    def setup_download_dir!(dir)
-      set_path(dir)
-      FileUtils.mkdir_p(to_path) unless Dir.exists?(to_path)
-    end
-
     def load_pages
-      @pages ||= []
+      return @pages if @pages.any?
 
       fetch_each_page do |page| @pages << page end
       @pages.sort_by!(&:name)
     end
 
+    private
+    def setup_download_dir!(dir)
+      set_path(dir)
+      FileUtils.mkdir_p(to_path) unless Dir.exists?(to_path)
+    end
+
     # get page objects for all pages in a chapter
     def fetch_each_page
       pages = build_page_hashes
@@ -118,21 +104,19 @@ module Mangdown
 
     # get the docs for number of pages 
     def build_page_hashes
-      (1..@properties.num_pages).map { |num|  
-        uri_str = @properties.build_page_uri(uri, manga, chapter, num)
-        uri = Mangdown::Uri.new(uri_str).downcase 
-        MDHash.new(uri: uri, name: num, chapter: name, manga: manga)
-      }
+      adapter.page_list.map { |page|
+        page.merge!(chapter: name, manga: manga)
+        MDHash.new(page) }
     end
 
     # get the page name and uri
     def get_page(uri, doc)
-      properties = Properties.new(uri, nil, doc)
-      uri = properties.page_image_src 
-      page = properties.page_image_name
-      site = properties.type
+      # Local binding for adapter
+      adapter = Mangdown.adapter!(uri, nil, doc)
+      page = adapter.page
+      page.merge!(chapter: name, manga: manga)
 
-      MDHash.new(uri: uri, name: page, chapter: name, manga: manga, site: site)
+      MDHash.new(page)
     end
   end
 end

data/lib/mangdown/{commands.rb → client.rb}

@@ -1,35 +1,25 @@
+require_relative '../mangdown'
+
 module M
   extend self
 
-  include ::Mangdown
-
   DATA_FILE_PATH = Dir.home + '/.manga_list.yml'
   HELP_FILE_PATH = File.expand_path(
     '../../README.md', File.dirname(__FILE__)
   )
-=begin
-  MANGA_PAGES = (1..9).map { |p| 
-      "http://www.wiemanga.com/search/?name_sel=contain" +
-      "&author_sel=contain&completed_series=either&page=#{p}.html"
-    } +
-    [
-      'http://www.mangareader.net/alphabetical',
-      'http://mangafox.me/manga/'
-    ]
-=end
+
   MANGA_PAGES = ['http://www.mangareader.net/alphabetical']
 
   # return a list of hash with :uri and :name of mangas found in list
   def find(search)
-    validate_search(search)
-    current_manga_list.mangas.select { |manga| 
-      manga[:name].downcase.include?(search.downcase) 
-    }
+    search = Regexp.new(/^#{search}$/) if search.respond_to?(:to_str)
+
+    current_manga_list.select { |manga| manga[:name] =~ search }
   end
 
   # cbz all subdirectories in a directory
   def cbz(dir)
-    Dir.exist?(dir) ? CBZ.all(dir) : raise(Errno::ENOENT, dir) 
+    Dir.exist?(dir) ? Mangdown::CBZ.all(dir) : raise(Errno::ENOENT, dir) 
   end
 
   # display help file
@@ -62,20 +52,15 @@ module M
   # otherwise fetch new data and write it to the data file
   def current_manga_list
     data = data_from_file
-    return MangaList.from_data(data) if data
+    return Mangdown::MangaList.from_data(data) if data
 
-    MangaList.new(*MANGA_PAGES).tap { |list| 
-      File.open(path, 'w+') { |f| f.write(list.to_yaml) } 
-    }
+    list = MANGA_PAGES.inject([]) { |manga, uri|
+      list = Mangdown::MDHash.new(uri: uri).to_manga_list
+      list.merge(manga) }
+    File.open(path, 'w+') { |f| f.write(list.to_yaml) } 
+    list
   rescue Object => error
     puts "#{path} may be corrupt: #{error.message}"
     raise
   end
-
-  # check if the search key contains letters or numbers
-  def validate_search(search)
-    unless search =~ /\w/
-      raise ArgumentError, "Searches must contain letters and numbers"
-    end
-  end
 end

data/lib/mangdown/manga.rb

@@ -7,25 +7,19 @@ module Mangdown
     include Equality
     include Enumerable
 
-    attr_reader :uri, :chapters
+    attr_reader :uri, :chapters, :name
+    attr_accessor :adapter
 
-    def initialize(uri, name = nil)
+    def initialize(uri, name)
       @name = name
       @uri = Mangdown::Uri.new(uri)
       @chapters = []
-      @properties = Properties.new(uri)
-
-      get_chapters
-    end
-
-    def name
-      @name || @properties.manga_name
     end
 
     def inspect
       "#<#{self.class} @name=#{name} @uri=#{uri} " +
-      "@chapters=[#{chapters.first(10).join(',')}" +
-      "#{",..." if chapters.length > 10}]>"
+      "@chapters=[#{chapters.first(3).join(',')}" +
+      "#{",..." if chapters.length > 3}]>"
     end
     alias_method :to_s, :inspect
 
@@ -42,17 +36,29 @@ module Mangdown
     def download_to(dir, start = 0, stop = -1, opts = { force_download: false })
       start, stop = validate_indeces!(start, stop)
       setup_download_dir!(dir)
+      failed = []
+      succeeded = []
+      skipped = []
 
       bar = progress_bar(start, stop)
       chapters[start..stop].each do |md_hash|
         chapter = md_hash.to_chapter
-
-        if chapter.download_to(to_path, opts)
-          bar.increment!
+        chapter_result = chapter.download_to(to_path, opts)
+        
+        if chapter_result[:failed].any?
+          failed << chapter
+        elsif chapter_result[:succeeded].any?
+          succeeded << chapter
+        elsif chapter_result[:skipped].any?
+          skipped << chapter
+        end
+        if chapter_result[:failed].any?
+          STDERR.puts("error: #{chapter.name} was not fully downloaded") 
         else
-          STDERR.puts("error: #{chapter.name} was not downloaded") 
+          bar.increment!
         end
       end
+      { failed: failed, succeeded: succeeded, skipped: skipped }
     end
 
     # explicit conversion to manga
@@ -75,14 +81,14 @@ module Mangdown
       @chapters.each(&block)
     end 
 
-    private
     # push MDHashes of manga chapters to @chapters 
-    def get_chapters
-      @chapters += @properties.manga_chapters do |uri, chapter, site|
-         MDHash.new(uri: uri, name: chapter, manga: name, site: site)
-      end
+    def load_chapters
+      @chapters += adapter.chapter_list.map { |chapter|
+         chapter.merge!(manga: name)
+         MDHash.new(chapter) }
     end
 
+    private
     def chapter_indeces(start, stop)
       length = chapters.length
       [start, stop].map { |i| i < 0 ? length + i : i }

data/lib/mangdown/manga_list.rb

@@ -1,32 +1,41 @@
 module Mangdown
-
-  # a list of manga
   class MangaList
+    include Enumerable
 
-    def self.from_data(mangas)
-      new(nil, mangas: mangas) 
+    def self.from_data(manga)
+      new(manga) 
     end
 
-    attr_reader :mangas
+    attr_reader :manga
 
-    def initialize(*uris, mangas: [])
-      @mangas = mangas.map! { |hash| MDHash.new(hash) }
-      if uris.any?
-        uris.each { |uri| get_mangas(uri) } 
-      end
+    def initialize(manga = [])
+      @manga = manga.map! { |hash| MDHash.new(hash) }
     end
 
+    def each(&block)
+      manga.each(&block)
+    end 
+
     def to_yaml
-      @mangas.map(&:to_hash).to_yaml
+      @manga.map(&:to_hash).to_yaml
     end
 
-    private
-    # get a list of mangas from the uri
-    def get_mangas(uri)
+    def load_manga(uri)
+      adapter = Mangdown.adapter!(uri)
+
+      manga = adapter.manga_list.map { |manga| MDHash.new(manga) }
       
-      @mangas += Properties.new(uri).collect_manga_list { |uri, name, site| 
-        MDHash.new(uri: uri, name: name, site: site) 
-      }
+      merge(manga)
+    end
+
+    def to_a
+      manga
+    end
+
+    def merge(other)
+      @manga += other.to_a
+
+      return self
     end
   end
 end