mangdown 0.8.3 → 0.8.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2661378fbd595b26a9bf3287f4ac62998aa6839c
-  data.tar.gz: 020610efc7afb039d77415d18ac5f5a232541ca5
+  metadata.gz: 6443de1c0cb154bfc68bd4b1f5cea81f58946693
+  data.tar.gz: 8726490e4b2178e714ab66db8ee27afafe4107db
 SHA512:
-  metadata.gz: 6ce635544cdd44bdfa0c6b8bb39cd296ecac6e356130440ceceeb5c86a0b617496ac5b66cc0a027e64f20934515dbc6b7da37e7dc314b7e56ef950c5f0be4c27
-  data.tar.gz: d96dbacc58a1388b8b3a57bf89538af380b2920100dc5453d61fc8402b3653f005f2fab566f506a2a24a78b531737e36983cbb97d4b0826e1bf74c488742c001
+  metadata.gz: 767c5e5aeb49ff9b2e28d16035ff718d054bded41e78cf690c53659593663469eb98fd22ac03cef0f6b08bbe58c50637450427150f998e319c76c08affc3497a
+  data.tar.gz: 064ca3d79312925c8b919dc9383aedfc8c8884ec8aa40abb923053b1ba1fa9f076a892f2a817a47c44d1146bee3e5a7a84c7d89ed249c94746857c173614993f

data/lib/mangdown.rb

@@ -5,7 +5,11 @@ require 'yaml'
 require 'timeout'
 require 'zip'
 
+require_relative 'mangdown/mangdown'
+
 require_relative 'mangdown/tools'
+require_relative 'mangdown/properties'
+require_relative 'mangdown/uri'
 require_relative 'mangdown/page'
 require_relative 'mangdown/chapter'
 require_relative 'mangdown/manga'

data/lib/mangdown/cbz.rb

@@ -7,32 +7,55 @@ module Mangdown
       zip_file_name = dir + '.cbz'
       dir += '/' unless dir[-1] == '/'
 
-      ::Zip::File.open(zip_file_name, ::Zip::File::CREATE) do |zp|
+      ::Zip::File.open(zip_file_name, ::Zip::File::CREATE) do |zip|
         Dir[File.join(dir, '**', '**')].each do |file|
-          zp.add(file.sub(dir, ''), file)
+          zip.add(file.sub(dir, ''), file)
         end
       end
     end
 
     def cbz_sub_dirs(dir)
-      check_dir(dir) do |d|
-        cbz_dir(d)
+      check_dir(dir) do |sub_dir|
+        cbz_dir(sub_dir)
       end
     end 
 
     def all(main_dir)
-      if Dir.exist?(main_dir)
-        # Make sure all sub dirs are checked
-        validate_file_or_dir_names(main_dir)
-        # Make sure all sub dirs have files checked
-        check_dir(main_dir) { |d| validate_file_or_dir_names(d)}
-        # Create cbz files for all sub dirs
-        cbz_sub_dirs(main_dir)
-        # new line
-        puts
-      else
-	puts "Cannot find directory"
+			# Make sure all sub dirs are checked
+			validate_file_or_dir_names(main_dir)
+			# Make sure all sub dirs have files checked
+			check_dir(main_dir) { |dir| validate_file_or_dir_names(dir)}
+			# Create cbz files for all sub dirs
+			cbz_sub_dirs(main_dir)
+			# new line
+			puts
+    end
+
+    def check_dir(dir)
+      Dir.glob(dir + '/*').each do |file_name| 
+        #do block on each file name, but skip .cbz files
+        next if file_name.include?('.cbz')
+        yield(file_name)
+      end
+    end 
+
+    def validate_file_or_dir_names(dir)
+      check_dir(dir) do |file_name|
+        checked_name = check_file_or_dir_name(file_name)
+        File.rename(file_name, checked_name)
       end
     end
+
+    def check_file_or_dir_name(name)
+      # slice the last number in the file or directory name,
+      # which will be either the page number or the chapter number
+      num = name.slice(/(\d+)(\.jpg)*\Z/, 1)
+      return unless num
+
+      zeros_to_add = (3-num.length) > 0 ? (3-num.length) : 0
+      num = "0" * zeros_to_add + num
+      name.sub(/(\d+)(\.jpg)*\Z/, num + '\2')
+    end 
+
   end
 end

data/lib/mangdown/chapter.rb

@@ -1,96 +1,133 @@
 module Mangdown
-  class Chapter
+	class Chapter
 
-    attr_reader :pages
+		attr_reader :name, :uri, :pages
 
-    # initialize with MDHash and only have @info[:key]
-    def initialize(info)
-      @info = info
-      @pages = []
+		def initialize(name, uri)
+      @manga = name.slice(/(^.+)\s/, 1) 
+      @chapter = name.slice(/\d+\z/) 
+			@name  = name
+			@uri   = Mangdown::Uri.new(uri)
+			@pages = []
+      @properties = Properties.new(@uri)
 
-      get_pages
-    end
+			get_pages
+		end
 
-    # reader method for uri
-    def uri
-      @info[:uri]
-    end
+		# explicit conversion to chapter
+		def to_chapter
+			self
+		end
 
-    # reader method for name
-    def name
-      @info[:name]
-    end
-
-    # download should be in its own module
-    # and the start_dir is sandwich code and should be moved and
-    # passed a block 
     def download
-      start_dir = Dir.pwd 
+      warn "#download is depreciated use #download_to"
 
-      Dir.mkdir(@info[:name]) unless Dir.exists?(@info[:name])
-      Dir.chdir(@info[:name])
+      dir = File.expand_path(@name)
+      Dir.mkdir(dir) unless Dir.exists?(dir)
       
-      @pages.each {|page| page.download}
-
-      Dir.chdir(start_dir)
-    end
-
-    private
-      def get_pages
-        uri = @info[:uri]
-        doc = ::Mangdown::Tools.get_doc(uri)
-        
-        get_num_pages(doc).times do
-          page = get_page(doc) 
-          uri = get_next_uri(doc)
-
-          @pages << Page.new(page)
-          doc = ::Mangdown::Tools.get_doc(uri)
+      threads = []
+      @pages.each do |page| 
+        threads << Thread.new(page) do |this_page| 
+          this_page.download_to(dir)
         end
       end
-  end
 
-  class MRChapter < Chapter
-    private
-      def get_page(doc)
-        image = doc.css('img')[0]
+      threads.each {|thread| thread.join}
+      return @pages.length
+		end
 
-        hash = MDHash.new
-        hash[:uri], hash[:name] = image['src'], (image['alt'] + ".jpg")
-        hash
+		# download all pages in a chapter
+		def download_to(dir)
+      dir = File.expand_path(dir + '/' + @name)
+      Dir.mkdir(dir) unless Dir.exists?(dir)
+      
+      threads = []
+      @pages.each do |page| 
+        threads << Thread.new(page) do |this_page| 
+          this_page.download_to(dir)
+        end
       end
 
-      def get_next_uri(doc)
-        #root url + the href of the link to the next page
-        ::Mangdown::Tools.get_root(@info[:uri]) + 
-          doc.css('div#imgholder a')[0]['href']
+      threads.each {|thread| thread.join}
+      return @pages.length
+		end
+
+		private
+			
+			# get page objects for all pages in a chapter
+			def get_pages
+        threads = []
+        get_num_pages(get_page_doc(1)).times do |page|
+          threads << Thread.new(page) do |this_page|
+            hash = get_page(get_page_doc(this_page + 1)) 
+            @pages << hash.to_page 
+          end
+				end
+
+        threads.each {|thread| thread.join}
+        return @pages.length
+			end
+	end
+
+	# mangareader chapter object
+	class MRChapter < Chapter
+		private
+	
+      # get the doc for a given page number
+      def get_page_doc(num)
+        doc = Tools.get_doc(
+          Mangdown::Uri.new( 
+            @properties.root                                + 
+            "/#{@manga.gsub(' ', '-')}/#{@chapter}/#{num}"
+          ).downcase
+        )
       end
-
-      def get_num_pages(doc)
-        # the select is a dropdown menu of chapter pages
+		
+			# get the page uri and name
+			def get_page(doc)
+				image = doc.css('img')[0]
+
+				MDHash.new(
+					uri: image['src'], 
+					name: (image['alt'] + ".jpg")
+				)
+			end
+
+			# get the number of pages
+			def get_num_pages(doc)
+				# the select is a dropdown menu of chapter pages
         doc.css('select')[1].children.length
+			end
+	end
+
+	# mangafox chapter object
+	class MFChapter < Chapter
+		private
+
+      # get the doc for a given page number
+      def get_page_doc(num)
+        doc = Tools.get_doc(
+          Mangdown::Uri.new(
+            @properties.root                               + 
+            "/manga/#{@manga.gsub(' ', '_')}/c#{@chapter}/" + 
+            "#{num}.html"
+          ).downcase
+        )
       end
-  end
-
-  class MFChapter < Chapter
-    private
-      def get_page(doc)
-        image = doc.css('img')[0]
 
-        hash        = MDHash.new
-        hash[:uri]  = image[:src]
-        hash[:name] = image[:src].sub(/.+\//, '')
-        hash
-      end
-
-
-      def get_next_uri(doc)
-        root = @info[:uri].slice(/.+\//)
-        root + doc.css('div#viewer a')[0][:href]
-      end
-
-      def get_num_pages(doc)
-        doc.css('select')[1].children.length - 1
-      end
-  end
+			# get the page name and uri
+			def get_page(doc)
+				image = doc.css('img')[0]
+
+				MDHash.new(
+					uri: image[:src], 
+					name: image[:src].sub(/.+\//, '')
+				)
+			end
+
+			# get the number of pages
+			def get_num_pages(doc)
+				doc.css('select')[1].children.length - 1
+			end
+	end
 end

data/lib/mangdown/commands.rb

@@ -2,74 +2,70 @@ module M
   extend self
 
   include ::Mangdown
-  extend ::Mangdown::Tools
 
+  DATA_FILE_PATH = Dir.home + '/.manga_list.yml'
+
+	# check if the search key contains letters or numbers
   def valid_search?(search)
     search =~ /\w/
   end
-  
-  def file_path
-    Dir.home + '/.manga_list.yml'
-  end
 
-  #returns a list of hash with :uri and :name of mangas found in @@list
+	# check if the data file is current
+	def file_current?(file)
+		File.exists?(file) ? File.mtime(file) > (Time.now - 604800) : false
+	end
+
+  # return a list of hash with :uri and :name of mangas found in list
   def find(search)
     unless valid_search?(search)
       puts "Searches must contain letters and numbers.."
       return []
     end
     
-    # Previously, popular manga was used for find, but there is a 
-    # much better way to do it
-    # PopularManga.new('http://www.mangareader.net/popular', 3000)
-    
-    if File.exist?(file_path) 
-      file_current = File.mtime(file_path) > (Time.now - 60*60*24*7)
-    end
-
-    if file_current
-      @@list = YAML.load(File.open(file_path, 'r').read)
+		if file_current?(DATA_FILE_PATH)
+      list = YAML.load(File.open(DATA_FILE_PATH, 'r').read)
     else
-      @@list = MangaList.new(
+      list = MangaList.new(
         'http://www.mangareader.net/alphabetical',
         'http://mangafox.me/manga/'                       
       ) 
 
-      File.open(file_path, 'w+') do |f|
-        f.write( @@list.to_yaml )
+      File.open(DATA_FILE_PATH, 'w+') do |file|
+        file.write( list.to_yaml )
       end
     end
 
-    search_result = @@list.mangas.select do |manga| 
+    search_result = list.mangas.select do |manga| 
       manga[:name].downcase.include?(search.downcase)
     end
     
-    puts "Could not find manga" if search_result.empty?     
-    
-    search_result
+		search_result.empty? ? (puts "Could not find manga") : search_result
   end
   
-  def download(manga, first_chapter = 0, last_chapter = -1)
+	# download a manga (accepts MDHash) between the chapters given
+	# by default the entire manga will be downloaded
+  def download(manga, first = 0, last = -1)
     if manga.class == MDHash
-      manga = Manga.new(manga)
+			manga = manga.to_manga
     end
 
-    chapters = ::Mangdown::Tools.slow_get_chapters(
-                manga, first_chapter, last_chapter)
-    ::Mangdown::Tools.slow_dl_chapters(chapters)
+    Tools::Downloader.new(manga, first, last)
   end
 
+	# cbz all subdirectories in a directory
   def cbz(dir)
-    CBZ.all(dir)
+		Dir.exist?(dir) ? CBZ.all(dir) : (puts "Cannot find directory")
   end
 
+	# display help file
   def help
     help_file = File.expand_path('../../doc/help.txt', 
                                  File.dirname(__FILE__))
     puts File.open(help_file, 'r').read
   end
 
+	# delete data file
   def clean_up
-    File.delete(file_path) if File.exist?(file_path)
+    File.delete(DATA_FILE_PATH) if File.exist?(DATA_FILE_PATH)
   end
 end

data/lib/mangdown/manga.rb

@@ -1,12 +1,13 @@
 module Mangdown
+
+	# mangdown manga object, which holds chapters
   class Manga
-    include ::Mangdown::Tools
 
-    attr_reader :chapters, :chapters_list 
+    attr_reader :name, :uri, :chapters, :chapters_list 
 
-    #initialize only use @info[:key]
-    def initialize(info)
-      @info = info
+    def initialize(name, uri)
+			@name = name
+			@uri  = uri
 
       #Keeping these chapter objects in memory could be expensive
       @chapters = []
@@ -15,69 +16,41 @@ module Mangdown
       get_chapters_list
     end
 
-    # reader method for uri
-    def uri
-      @info[:uri]
-    end
-
-    # reader method for name
-    def name
-      @info[:name]
-    end
+		# explicit conversion to manga
+		def to_manga 
+			self
+		end
 
+		# get push MDHashes of manga chapters to @chapters 
     def get_chapters_list
-      doc = ::Mangdown::Tools.get_doc(@info[:uri])
-      root = ::Mangdown::Tools.get_root(@info[:uri])
+			properties = Properties.new(@uri)
+      doc        = Tools.get_doc(@uri)
+			root       = properties.root
 
       #get the link with chapter name and uri
-      doc.css(css_klass(root)).each do |chapter|
-        hash = MDHash.new
-        hash[:uri]  = (root + chapter[:href].sub(root, '')) 
-        hash[:name] = chapter.text
-        @chapters_list << hash 
+      doc.css(properties.manga_css_klass).each do |chapter|
+				@chapters_list << MDHash.new(
+					uri: (root + chapter[:href].sub(root, '')), 
+					name: chapter.text,
+				) 
       end
 
-      if root =~ /mangafox/
-        @chapters_list.reverse!
-      end
-    end
- 
-    def css_klass(site)
-      case site
-      when /mangareader/
-        'div#chapterlist td a'
-      when /mangafox/
-        'a.tips'
-      else
-        nil
-      end
+			@chapters_list.reverse! if properties.reverse 
     end
 
-    # chapter is an MDHash
+    # returns a MDHash if the chapter is found in @chapters 
     def chapter_found(chapter)
       @chapters.find do |chp| 
         (chp.name == chapter[:name]) or (chp.uri == chapter[:uri])
       end
     end
 
+		# pushes a Chapter object into @chapters unless it is already there
     def get_chapter(index) 
-      
-      root = ::Mangdown::Tools.get_root(@info[:uri])
       chapter  = @chapters_list[index] 
 
       unless chapter_found(chapter) 
-        # this should be put in a module the case is used in 
-        # almost every class
-        chapter_klass = case root 
-        when /mangareader/
-          ::Mangdown::MRChapter
-        when /mangafox/
-          ::Mangdown::MFChapter
-        else
-          return :no_chapter 
-        end
-     
-        @chapters << chapter_klass.new(chapter)
+				@chapters << chapter.to_chapter 
       else
         puts "This chapter has already been added" 
       end

data/lib/mangdown/manga_list.rb

@@ -1,46 +1,27 @@
 module Mangdown
+
+	# a list of manga
   class MangaList
 
     attr_reader :mangas
 
     def initialize(*uri)
-      @uri = uri
       @mangas = []
 
-      @uri.each {|uri| get_mangas(uri)}
+      uri.each {|uri| get_mangas(uri)}
     end
 
+		# get a list of mangas from the uri
     def get_mangas(uri)
-      doc = ::Mangdown::Tools.get_doc(uri)
-      root = ::Mangdown::Tools.get_root(uri)
-
+			properties = Properties.new(uri)
+      doc        = Tools.get_doc(uri)
       
       # This should be put in a tool
-      doc.css(css_klass(root)).each do |a|
-        hash = MDHash.new
-        #hot fix
-        url = case root 
-        when /mangareader/
-          root + a[:href]
-        when /mangafox/
-          a[:href]
-        else
-          nil
-        end
-
-        hash[:uri], hash[:name] = url, a.text
-        @mangas << hash
-      end
-    end
-
-    def css_klass(site)
-      case site
-      when /mangareader/
-        'ul.series_alpha li a'
-      when /mangafox/
-        'div.manga_list li a'
-      else
-        nil
+			doc.css(properties.manga_list_css_klass).each do |a|
+				@mangas << MDHash.new( 
+					uri: "#{properties.manga_link_prefix}#{a[:href]}", 
+					name: a.text
+			  )
       end
     end
   end

data/lib/mangdown/mangdown.rb

@@ -0,0 +1,23 @@
+module Mangdown 
+
+	extend self
+
+  def to_s
+		"<#{self.class}::#{self.object_id}" <<
+		@name ? " : #{@name}" : '' <<
+		name  ? " : #{name}"  : '' <<
+		@uri  ? "	: #{@uri}"  : '' <<
+		uri   ? " : #{uri}"   : '' <<
+		">"
+	end
+
+  def eql?(other)
+    (self.name == other.name) and (self.uri == other.uri)
+  end
+
+	def ==(other)
+		puts "You may want to use :eql?"
+		super
+	end
+end
+

data/lib/mangdown/mangdown_hash.rb

@@ -1,8 +1,26 @@
 module Mangdown
   class MDHash < ::Hash
-    def get_manga
-      Manga.new(self)
+
+		def initialize(options = {})
+			self[:uri]     = options[:uri]
+			self[:name]    = options[:name]
+		end
+
+		# explicit conversion to manga 
+    def to_manga
+      Manga.new(self[:name], self[:uri])
     end
+
+		# explicit conversion to chapter 
+		def to_chapter
+			klass = Properties.new(self[:uri]).chapter_klass
+		  klass.new(self[:name], self[:uri])
+		end
+
+		# explicit conversion to page 
+ 	  def to_page 
+		  Page.new(self[:name], self[:uri])
+		end	
   end
 end
 

data/lib/mangdown/page.rb

@@ -1,30 +1,35 @@
-module Mangdown
-  class Page
+class Mangdown::Page
 
-    attr_reader :info
+	include Mangdown 
 
-    # like chapter and manga, should initialize with MDHash, and use
-    # @info[:key]
-    def initialize(info)
-      @info = info
-    end
+	attr_reader :name, :uri
 
-    def filename
-      @info[:name]
-    end
+	def initialize(name, uri)
+		@name = name
+		@uri  = Mangdown::Uri.new(uri) 
+	end
 
-    def uri 
-      @info[:uri]
-    end
+	# explicit conversion to page 
+	def to_page
+		self
+	end	
+
+  # download the page
+	def download
+    warn "#download is depreciated use #download_to"
+		return nil if File.exist?(@name)
+    File.open(@name, 'wb') do |file|
+			file.write(open(uri).read)
+		end
+	end
 
-    # this method should probably be moved somewhere else because
-    # pages, chapters and mangas can all be "downloaded"
-    def download
-      unless File.exist?(@info[:name])
-        File.open(@info[:name], 'wb') do |file|
-          file.write(open(URI.encode(@info[:uri], '[]')).read)
-        end
-      end
+  # downloads to specified directory
+  def download_to(dir)
+    path = dir + '/' + @name
+    # don't download again
+    return nil if File.exist?(path)
+    File.open(path, 'wb') do |file| 
+      file.write(open(uri).read)
     end
   end
 end

data/lib/mangdown/popular.rb

@@ -23,7 +23,7 @@ module Mangdown
 
       unless @mangas.find {|mnga| (mnga.name == manga[:name]) or 
                                    (mnga.uri == manga[:uri])}
-        @mangas << Manga.new(manga)
+        @mangas << manga.to_manga
       else
         puts "This manga has already been added.."
       end

data/lib/mangdown/properties.rb

@@ -0,0 +1,43 @@
+module Mangdown
+	class Properties
+
+		attr_reader :info
+
+		def initialize(site)
+			@info = Hash.new
+
+      case site 
+      when /mangareader/
+				mangareader
+      when /mangafox/
+				mangafox
+      else
+        nil
+      end
+		end
+
+		def mangareader
+			@info[:manga_list_css_klass] = 'ul.series_alpha li a'
+			@info[:manga_css_klass]      = 'div#chapterlist td a'
+			@info[:chapter_klass]        = MRChapter
+			@info[:root]                 = 'http://www.mangareader.net'
+			@info[:manga_link_prefix]    = @info[:root] 
+			@info[:reverse]              = false
+		end
+
+		def mangafox
+			@info[:manga_list_css_klass] = 'div.manga_list li a'
+			@info[:manga_css_klass]      = 'a.tips'
+			@info[:chapter_klass]        = MFChapter
+			@info[:root]                 = 'http://mangafox.me'
+			@info[:manga_link_prefix]    = ''
+			@info[:reverse]              = true
+		end
+
+		private
+			def method_missing(method, *args, &block)
+				return @info[method] unless @info[method].nil?
+				super
+			end
+	end
+end

data/lib/mangdown/tools.rb

@@ -1,140 +1,89 @@
+require 'timeout'
+
 module Mangdown
   module Tools
     extend self
   
-    def special?(klass)
-      klasses = [Manga, Chapter, Page, MRChapter, MFChapter]
-
-      if klasses.find(self.class)
-        true
-      else
-        false
-      end
-    end
+		def return_to_start_dir 
+			start = Dir.pwd
+			yield
+			Dir.chdir(start)
+    rescue Exception => error
+      Dir.chdir(start)
+      raise error
+		end
 
     def get_doc(uri)
-      @doc = ::Nokogiri::HTML(open(uri))
+			@doc = ::Nokogiri::HTML(open(uri))
     end
 
     def get_root(uri)
       @root = ::URI::join(uri, "/").to_s[0..-2] 
     end
-
-    def to_s
-      if special?(self.class)
-        "<#{self.class}::#{self.object_id} : #{@name} : #{@uri}>"
-      else
-        super
-      end
-    end
-
-    def eql?(other)
-      if special?(self.class)
-        (self.name == other.name) and (self.uri == other.uri)
-      else
-        super
-      end
-    end
-
-    def ==(other)
-      if special?(self.class)
-        puts 'You may want to use eql?'
-      end
-
-      super
-    end
-
+    
     def no_time_out(tries = 3, &block)
       tries -= 1
       begin 
-        timeout(120) do
-          yield 
-        end
-      rescue
-        if tries >= 0
-          puts "Tries left: #{tries}"
-          no_time_out(tries, &block)
-        else
-          return :timed_out
-        end
+        timeout(120) { yield } 
+      rescue Timeout::Error
+        tries >= 0 ? no_time_out(tries, &block) : :timed_out
       end
     end
 
-    def slow_get_chapters(manga, bgn, nd)
-      @@file_name = File.expand_path("#{manga.name}_temp.yml")
+    class Downloader
+      include Tools
 
-      # get Manga object from file if it exists
-      if File.exist?(@@file_name)
-        manga_from_file = YAML.load(File.open(@@file_name, 'r').read) 
-      end
+      def initialize(manga, first, last)
+        @tempfile = File.expand_path("#{manga.name}_temp.yml")
 
-      if manga_from_file and (manga_from_file.chapters.length > 0)
-        frst = (manga.chapters_list[bgn][:name] == 
-               manga_from_file.chapters.first.name) 
-        lst = (manga.chapters_list[nd][:name] == 
-               manga_from_file.chapters.last.name)
-        # check if this is the right temp file
-        manga = manga_from_file if (frst and lst)
-      else
-        manga.chapters_list[bgn..nd].each_index do |i|
-          no_time_out {manga.get_chapter(i + bgn)}
-        end
+        chapters = slow_get_chapters(manga, first, last)
+        slow_dl_chapters(chapters)
       end
 
-      File.open(@@file_name, 'w') {|f| f.write(manga.to_yaml)}
-
-      manga
-    end
-
-    def slow_dl_chapters(manga)
-      start_dir = Dir.pwd
-      Dir.mkdir(manga.name) unless Dir.exist?(manga.name)
-      Dir.chdir(manga.name)
-
-      manga_start_dir = Dir.pwd
-      manga.chapters.each do |chap|
-        no_time_out do 
-          Dir.chdir(manga_start_dir)
-          chap.download
+      def slow_get_chapters(manga, bgn, nd)
+        # get Manga object from file if it exists
+        if File.exist?(@tempfile)
+          manga_from_file = YAML
+            .load(File.open(@tempfile, 'r').read) 
         end
-      end
 
-      File.delete(@@file_name)
-      Dir.chdir(start_dir)
-    end
-
-    def check_file_or_dir_name(name)
-
-      # slice the last number in the file or directory name,
-      # which will be either the page number or the chapter number
-      num = name.slice(/(\d+)(\.jpg)*\Z/, 1)
-    
-      if num
-        while num.length < 3
-          num = '0' + num
+        # if the manga is from tempfile and the manga has chapters
+        # then check if it has the right chapters 
+        if manga_from_file and (manga_from_file.chapters.length > 0)
+          frst = (manga.chapters_list[bgn][:name] == 
+                 manga_from_file.chapters.first.name) 
+          lst = (manga.chapters_list[nd][:name] == 
+                 manga_from_file.chapters.last.name)
+          manga = manga_from_file if (frst and lst)
+        else
+          threads = []
+          manga.chapters_list[bgn..nd].each_index do |index|
+            threads << Thread.new(index) do |i|
+              no_time_out {manga.get_chapter(i + bgn)}
+            end
+          end
+          threads.each {|thread| thread.join}
         end
-    
-        name = name.sub(/(\d+)(\.jpg)*\Z/, num + '\2')
-      end
 
-      name
-    end 
+        File.open(@tempfile, 'w') {|f| f.write(manga.to_yaml)}
 
-    def check_dir(dir)
-      Dir.glob(dir + '/*').each do |file_name| 
-        #do block on each file name, but skip .cbz files
-        next if file_name.include?('.cbz')
-        yield(file_name)
+        manga
       end
-    end 
 
-    def validate_file_or_dir_names(dir)
-      check_dir(dir) do |file_name|
-        checked_name = check_file_or_dir_name(file_name)
+      def slow_dl_chapters(manga)
+        dir = File.expand_path(manga.name)
+        Dir.mkdir(dir) unless Dir.exist?(dir)
 
-        unless file_name == checked_name
-          File.rename(file_name, checked_name)
+        threads = []
+        manga.chapters.each do |chap|
+          threads << Thread.new(chap) do |this_chap|
+            no_time_out {this_chap.download_to(dir)}
+          end
         end
+
+        threads.each {|thread| thread.join}
+
+        File.delete(@tempfile)
       end
     end
   end

data/lib/mangdown/uri.rb

@@ -0,0 +1,8 @@
+module Mangdown::Uri 
+
+	extend self
+
+	def new(uri)
+		URI.encode(uri, '[]')
+	end	
+end

data/models/chapter.rb

@@ -0,0 +1,5 @@
+class Chapter < ActiveRecord::Base
+
+  belongs_to :manga
+  has_many :pages
+end

data/models/manga.rb

@@ -0,0 +1,6 @@
+class Manga < ActiveRecord::Base
+
+  belongs_to :site
+  has_many :chapters
+end
+

data/models/page.rb

@@ -0,0 +1,4 @@
+class Page < ActiveRecord::Base
+
+  belongs_to :chapter
+end

data/models/site.rb

@@ -0,0 +1,4 @@
+class Site < ActiveRecord::Base
+
+  has_many :mangas
+end

data/spec/mangdown/chapter_spec.rb

@@ -1,11 +1,14 @@
 require 'spec_helper'
 
 module Mangdown
-  @@chapter_hash = MDHash.new
-  @@chapter_hash[:uri] = 'http://www.mangareader.net/bleach/537'
-  @@chapter_hash[:name] = 'Bleach 537'
-
-  chapter = MRChapter.new(@@chapter_hash)
+  @@chapter_hash = MDHash.new(
+    uri: 'http://www.mangareader.net/bleach/537',
+    name: 'Bleach 537',
+    manga: 'Bleach',
+    chapter: '537',
+	)
+
+	chapter = @@chapter_hash.to_chapter
   chapter.download
   
   STUB_PATH = File.expand_path('../../objects/chapter.yml', __FILE__)
@@ -30,48 +33,31 @@ module Mangdown
       end
 
       it "should have the right first page at the 0 index" do
-        expect(@chapter.pages.first.filename).to eq(
+        expect(@chapter.pages.first.name).to eq(
                'Bleach 537 - Page 1.jpg')  
       end
 
       it "should have the right last page at the -1 index" do
-        expect(@chapter.pages.last.filename).to eq(
+        expect(@chapter.pages.last.name).to eq(
                'Bleach 537 - Page 21.jpg')
       end
 
       context "as a MFChapter" do
         it "should have pages" do
-          hash = MDHash.new
-          hash[:uri]  = 
-          'http://mangafox.me/manga/kitsune_no_yomeiri/v01/c001/1.html'
-          hash[:name] = 'Kitsune no Yomeiri 1'
-
-          chapter = MFChapter.new(hash)
+          hash = MDHash.new(
+            uri:  'http://mangafox.me/manga/kitsune_no_yomeiri/v01/c001/1.html',
+            name: 'Kitsune no Yomeiri 1',
+            manga: 'Kitsune no Yomeiri',
+            chapter: 1,
+					)
+
+					chapter = hash.to_chapter
           
           expect(chapter.pages).not_to be_empty
         end
       end
     end
     
-   # Move these to Tools spec 
-=begin
-    context "when the functions for get_pages are run" do
-      it "should have the right chapter uri" do
-        expect(@chapter.uri).to eq(@@uri)
-      end
-
-      it "should get the right image link and filename from a uri" do
-        expect(@chapter.get_page).to eq(
-              ['http://i25.mangareader.net/bleach/537/bleach-4149721.jpg',
-               'Bleach 537 - Page 1'])
-      end
-    
-      it "should get the right root from uri" do
-        expect(@chapter.get_root(@@uri)).to eq('http://www.mangareader.net')
-      end
-    end
-=end
-
   context "when chapter is downloaded" do
     it "should have a sub directory in the current directory" do
       dir = Dir.pwd
@@ -82,13 +68,9 @@ module Mangdown
 
     it "should download all it's pages" do
       dir = Dir.pwd + '/' + @chapter.name
-      # expect(dir).to include("mangdown/#{@chapter.name}")
 
       pages_in_dir = Dir.glob(dir + '/*.jpg').length
       expect(pages_in_dir).to eq(@chapter.pages.length)
-      #@chapter.pages.each do |page|
-      #  expect(Dir.glob(dir + '/*' )).to include(dir + 
-      #                                           '/' + page.filename)
       end
     end
   end

data/spec/mangdown/commands_spec.rb

@@ -4,15 +4,17 @@ module M
 
   describe "commands" do
 		before(:all) do
-      hash = MDHash.new
-      hash[:uri]  = 'http://www.mangareader.net/6-no-trigger'
-      hash[:name] = '6 no Trigger'
-      @manga = Manga.new(hash)
+      hash = MDHash.new(
+				uri:  'http://www.mangareader.net/6-no-trigger',
+				name: '6 no Trigger'
+			)
+      @manga = hash.to_manga
       
-      hash = MDHash.new
-      hash[:uri]  = 'http://mangafox.me/manga/naruto/'
-      hash[:name] = 'Naruto'
-      @mf_manga = Manga.new(hash)
+      hash = MDHash.new(
+				uri:  'http://mangafox.me/manga/naruto/',
+				name: 'Naruto'
+			)
+      @mf_manga = hash.to_manga
 
 	   	M.download(@manga, 1, 3)
 			M.cbz("./#{@manga.name}")
@@ -46,6 +48,7 @@ module M
 
     it "should download a manga from MF" do 
       dir = Dir.pwd
+			#@mf_manga.remove_chapters
       M.download(@mf_manga, 500, 501)
       expect(Dir.glob(dir + "/#{@mf_manga.name}/*").length).to eq(2)
     end

data/spec/mangdown/manga_spec.rb

@@ -1,11 +1,12 @@
 require_relative '../spec_helper'
 
 module Mangdown
-  @@manga_hash        = MDHash.new
-  @@manga_hash[:uri]  = 'http://www.mangareader.net/94/bleach.html'
-  @@manga_hash[:name] = 'Bleach'
+  @@manga_hash = MDHash.new(
+    uri:  'http://www.mangareader.net/94/bleach.html',
+    name: 'Bleach'
+	)
 
-  manga = Manga.new(@@manga_hash)
+	manga = @@manga_hash.to_manga
   
   MANGA_STUB_PATH = File.expand_path('../../objects/manga.yml', 
                                      __FILE__)
@@ -19,7 +20,6 @@ module Mangdown
     before(:each) do
       print '@'
       @manga = YAML.load(File.open(Mangdown::MANGA_STUB_PATH, 'r').read)
-      #@manga.get_doc(@@manga_hash[:uri])
     end
 
     context "When a manga is initialized" do
@@ -33,10 +33,11 @@ module Mangdown
 
       context "as a MangaFox manga" do
         it "should have chapters" do
-          hash = MDHash.new
-          hash[:uri] = 'http://mangafox.me/manga/masca_the_beginning/' 
-          hash[:name] = 'Masca: The Beginning'
-          manga = Manga.new(hash)
+          hash = MDHash.new(
+						uri:  'http://mangafox.me/manga/masca_the_beginning/', 
+						name: 'Masca: The Beginning'
+					)
+          manga = hash.to_manga
           expect(manga.chapters_list).not_to be_empty
         end
       end
@@ -50,13 +51,15 @@ module Mangdown
       it "should have the right first chapter" do
         expect(@manga.chapters_list.first).to eq({
           uri:'http://www.mangareader.net/94-8-1/bleach/chapter-1.html',
-          name: 'Bleach 1'})
+          name: 'Bleach 1',
+        })
       end
 
       it "should have the right 465th chapter" do
         expect(@manga.chapters_list[464]).to eq({
           uri: 'http://www.mangareader.net/bleach/465',
-          name: 'Bleach 465'})
+          name: 'Bleach 465',
+        })
       end
     end
 

data/spec/mangdown/mangdown_hash_spec.rb

@@ -4,13 +4,14 @@ module Mangdown
 
   describe MDHash do
     before(:all) do
-      @hash = MDHash.new
-      @hash[:uri] = 'http://www.mangareader.net/103/one-piece.html'
-      @hash[:name] = 'One Piece'
+      @hash = MDHash.new(
+				uri:  'http://www.mangareader.net/103/one-piece.html',
+				name: 'One Piece'
+			)
     end
 
     it "should get a manga object from get_manga" do
-      expect(@hash.get_manga).to be_kind_of(Manga)
+      expect(@hash.to_manga).to be_kind_of(Manga)
     end
   end
 end

data/spec/mangdown/page_spec.rb

@@ -4,12 +4,12 @@ module Mangdown
   describe Page do
    	before(:all) do
 		  @dir = Dir.pwd
-      @page_hash = MDHash.new
-	    @page_hash[:uri] = 
-        'http://i25.mangareader.net/bleach/537/bleach-4149721.jpg'
-	    @page_hash[:name] = "Bleach 537 - Page 1" 
+      @page_hash = MDHash.new(
+	      uri: 'http://i25.mangareader.net/bleach/537/bleach-4149721.jpg',
+	      name: "Bleach 537 - Page 1" 
+			)
 
-	    @page = Page.new(@page_hash)
+			@page = @page_hash.to_page
 	    @page.download
       PAGE_STUB_PATH = File.expand_path('../../objects/page.yml', 
                                         __FILE__)
@@ -22,7 +22,7 @@ module Mangdown
 
     context "when page is downloaded" do
       it "should download itself to the current directory" do
-        expect(Dir.glob(@dir + '/*')).to include(@dir + '/' + @page.filename)
+        expect(Dir.glob(@dir + '/*')).to include(@dir + '/' + @page.name)
       end
     end
 

data/spec/mangdown/tools_spec.rb

@@ -0,0 +1,20 @@
+   # Move these to a Tools spec 
+=begin
+    context "when the functions for get_pages are run" do
+      it "should have the right chapter uri" do
+        expect(@chapter.uri).to eq(@@uri)
+      end
+
+      it "should get the right image link and name from a uri" do
+        expect(@chapter.get_page).to eq(
+              ['http://i25.mangareader.net/bleach/537/bleach-4149721.jpg',
+               'Bleach 537 - Page 1'])
+      end
+    
+      it "should get the right root from uri" do
+        expect(@chapter.get_root(@@uri)).to eq('http://www.mangareader.net')
+      end
+    end
+=end
+
+

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: mangdown
 version: !ruby/object:Gem::Version
-  version: 0.8.3
+  version: 0.8.4
 platform: ruby
 authors:
 - jphager2
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-14 00:00:00.000000000 Z
+date: 2014-06-12 00:00:00.000000000 Z
 dependencies: []
-description: A gem to download Manga
+description: A gem to download Manga, (pg integration in dev)
 email: jphager2@gmail.com
 executables: []
 extensions: []
@@ -24,10 +24,17 @@ files:
 - lib/mangdown/commands.rb
 - lib/mangdown/manga.rb
 - lib/mangdown/manga_list.rb
+- lib/mangdown/mangdown.rb
 - lib/mangdown/mangdown_hash.rb
 - lib/mangdown/page.rb
 - lib/mangdown/popular.rb
+- lib/mangdown/properties.rb
 - lib/mangdown/tools.rb
+- lib/mangdown/uri.rb
+- models/chapter.rb
+- models/manga.rb
+- models/page.rb
+- models/site.rb
 - spec/mangdown/chapter_spec.rb
 - spec/mangdown/commands_spec.rb
 - spec/mangdown/manga_list_spec.rb
@@ -35,9 +42,10 @@ files:
 - spec/mangdown/mangdown_hash_spec.rb
 - spec/mangdown/page_spec.rb
 - spec/mangdown/popular_spec.rb
+- spec/mangdown/tools_spec.rb
 - spec/objects/make_chapter.rb
 - spec/spec_helper.rb
-homepage: 
+homepage: https://github.com/jphager2/mangdown
 licenses:
 - MIT
 metadata: {}