kamishibai 0.6.2

data/lib/kamishibai/database.rb

@@ -0,0 +1,330 @@
+# encoding: utf-8
+
+# License: refer to LICENSE file
+
+#
+# Functions for database and bookmarks
+#
+
+require 'json'
+require 'fileutils'
+require 'pathname'
+
+module Kamishibai
+	class Database
+		attr_reader :files, :bookcodes
+
+		def initialize( db_filepath, bookmarks_filepath )
+			@db_savepath = db_filepath
+			@db_dirty = true
+
+			if File.exists?( @db_savepath )
+				load_database
+			else
+				# create fresh database
+				@db = {}
+				# indexes
+				@bookcodes = []
+				@files = {}
+				@inodes = {}
+			end
+
+
+			# bookmark section
+			@bookmarks_savepath = bookmarks_filepath
+			@bookmarks_dirty = false
+
+			if File.exists?( @bookmarks_savepath )
+				load_bookmarks
+			end
+		end
+
+		def add_book(filepath)
+			bookcode = gen_bookcode
+			o = Kamishibai::Book.new(bookcode, filepath)
+
+			if o.pages
+				@db[ bookcode ] = o
+				@bookcodes << bookcode
+				if File.exists?( filepath )
+					@files[ File.basename( filepath ).delete('ÿ') ] = bookcode # utf8-mac puts ÿ in filename, need to remove first for cross os support
+					@inodes[ o.inode ] = bookcode
+				end
+
+				@db_dirty = true
+
+				puts "added book. #{bookcode} #{filepath}" if $debug
+				bookcode
+			end
+		end
+
+		def has_bookcode?(bookcode)
+			@bookcodes.include?( bookcode )
+		end
+
+		def get_book(bookcode)
+			@db[ bookcode ]
+		end
+
+		def get_bookcode_byfilename(filename)
+			filename = File.basename( filename )
+			@files[ filename ]
+		end
+
+		def get_book_byfilename(filename)
+			filename = File.basename( filename )
+			bookcode = @files[ filename ]
+			get_book( bookcode )
+		end
+
+		def set_bookmark(bookcode, page)
+			puts "set_bookmark #{bookcode} #{page}" if $debug
+			@bookmarks_dirty = true
+			o = get_book(bookcode)
+			o.page  = page
+			o.rtime = Time.now.to_i
+		end
+
+		def get_bookmark(bookcode)
+			get_book( bookcode ).page
+		end
+
+		def books
+			@db
+		end
+
+		# refresh @bookcodes, making sure all the books have valid path
+		def refresh_bookcodes
+			bookcodes = []
+			for bookcode, book in @db
+				if File.exists?( book.fullpath )
+					book.fullpath_valid = true
+					bookcodes << bookcode
+				else
+					book.fullpath_valid = false
+				end
+			end
+
+			@bookcodes = bookcodes
+		end
+		
+
+		# big codes
+
+		# add book from directories, if existing booka are found, modify instead
+		def add_books(srcs, recursive = true)
+			srcs = cleanup_srcs( srcs )
+			
+			for src in srcs
+				# stopped using find module, because it wrack encoding havoc in windows (gives ??? character in unicode filename)
+				# now using Dir.glob instead
+				if recursive
+					search = '/**/*.cbz'
+				else
+					search = '/*.cbz'
+				end
+
+				Dir.glob(File.expand_path(src).escape_glob + search).delete_if { |f|
+					restricted_dir?(f)
+				}.each { |f|
+					bc = get_bookcode_byfilename( f )
+					o  = get_book( bc )
+					fs = File.stat(f)
+					o2 = get_book( @inodes[ fs.ino ] )
+
+					if o
+						# book exists in db
+						puts "book match(m1):     #{File.basename(f)} == #{File.basename(o.fullpath)}" if $debug == 2
+						
+						# update data with new path
+						o.fullpath = f
+
+						# update index, as bookcodes is the list that keeps actual books that exists
+						@bookcodes << o.bookcode
+					elsif o2 and fs.size == o2.size
+						# found existing book using inode and size, can detected changed filename in same filesystem
+						puts "book match(m2):     #{File.basename(f)} == #{File.basename(o2.fullpath)}" if $debug == 2
+
+						o2.fullpath = f
+						o2.title    = Kamishibai::CBZFilename.title( f )
+						o2.author   = Kamishibai::CBZFilename.author( f )
+
+						# update indexes
+						@bookcodes << o2.bookcode
+						@files[ File.basename(f) ] = o2.bookcode
+					else
+						# book don't exist in db
+						self.add_book(f)
+					end
+				}
+			end
+
+			puts "Found #{@bookcodes.length} books" if $debug
+		end
+
+		# save database
+		def save
+			if @db_dirty
+				# create dir if dir doesn't exist
+				if ! FileTest.exists?( File.dirname( @db_savepath ) )
+					FileUtils.mkdir_p( File.dirname( @db_savepath ) )
+				end
+				
+				db = {}
+				@db.each { |bookcode, book|
+					next unless book.pages # skip invalid book that contain no page/images
+
+					db[ bookcode ] = {
+						:title    => book.title,
+						:author   => book.author,
+						:fullpath => book.fullpath,
+						:size     => book.size,
+						:inode    => book.inode,
+						:mtime    => book.mtime,
+						:itime    => book.itime,
+						:rtime    => book.rtime,
+						:page     => book.page,
+						:pages    => book.pages
+					}
+				}
+				File.binwrite( @db_savepath, JSON.pretty_generate( db ) )
+				
+				@db_dirty = false
+
+				puts "db saved (#{db.length} books) #{Time.now}" if $debug
+			end
+		end
+
+		# save bookmarks
+		def save_bookmarks
+			if @bookmarks_dirty
+				# save bookmarks
+				if ! FileTest.exists?( File.dirname( @bookmarks_savepath ) )
+					FileUtils.mkdir_p( File.dirname( @bookmarks_savepath ) )
+				end
+
+				bookmarks = {}
+				@db.each { |bookcode, book|
+					page = book.page  # last read page
+					time = book.rtime # last read time
+
+					if page and page > 1
+						dat = {
+							:p => page,
+							:r => time
+						}
+						bookmarks[bookcode] = dat
+					end
+				}
+				
+				File.binwrite( @bookmarks_savepath, JSON.pretty_generate( bookmarks ) )
+				
+				@bookmarks_dirty = false
+
+				puts "bookmarks saved (#{bookmarks.length} bookmarks) #{Time.now}" if $debug
+			end
+		end
+
+
+
+		private
+
+		# clean up and sanity check on directory lists
+		def cleanup_srcs( dir_lists )
+			srcs = dir_lists.collect { |src|
+				pn = Pathname.new( src )
+				fp = pn.expand_path.cleanpath.to_s
+			
+				if FileTest.directory?( fp ) and not restricted_dir?( fp )
+					fp
+				end
+			}
+			srcs.compact!
+			p srcs if $debug
+			
+			srcs
+		end
+
+		# generate a unique bookcode, lookup bookcode existance by using db
+		def gen_bookcode
+			while true
+				word = GenChar(3)
+				break unless @bookcodes.include?(word) # find next available word
+			end
+			return word
+		end
+
+		# load database
+		def load_database
+			@db = {}
+			
+			# indexes for db, help to speed up database search
+			@files = {} # hash of files linked to bookcodes, format: files[basename] = bookcode
+			@bookcodes = [] # list of bookcodes, format: [ bookcode_a, bookcode_b, bookcode_c, ... ]
+			@inodes = {} # list of file inodes, format: inodes[inode] = bookcode
+
+			str = File.binread( @db_savepath )
+
+			JSON.parse( str ).each { |bookcode, h|
+				o = Kamishibai::Book.new
+				o.bookcode = bookcode
+				o.title    = h['title']
+				o.author   = h['author']
+				o.fullpath = h['fullpath']
+				o.size     = h['size']
+				o.mtime    = h['mtime']
+				o.inode    = h['inode']
+				o.itime    = h['itime'] # imported time
+				o.rtime    = h['rtime'] # last read time
+				o.page     = h['page']  # last read page
+				o.pages    = h['pages']
+
+				unless o.pages
+					puts "Book contain no images!!! skipping... #{bookcode} #{o.fullpath}"
+					next
+				end
+
+				@db[ o.bookcode ] = o
+				# update indexes
+				@files[ File.basename( o.fullpath ).delete('ÿ') ] = o.bookcode # utf8-mac puts ÿ in filename, need to remove first for cross os support
+				@inodes[ o.inode ] = o.bookcode
+
+				# if book exists
+				if File.exists?( o.fullpath )
+					fs = File.stat( o.fullpath )
+					o.fullpath_valid = true
+
+					# repopulate data if doesn't exist
+					o.title    = Kamishibai::CBZFilename.title( o.fullpath )  unless o.title
+					o.author   = Kamishibai::CBZFilename.author( o.fullpath ) unless o.author
+					o.size     = fs.size                                      unless o.size
+					o.mtime    = fs.mtime                                     unless o.mtime
+					o.inode    = fs.ino                                       unless o.inode
+
+					# update indexes
+					@bookcodes << o.bookcode
+					@inodes[ o.inode ] = o.bookcode
+				end
+			}
+			
+			# db format:   @db[ bookcode ] = Book obj
+			# + indexes    @files = { basename_a => bookcode_a, basename_b => bookcode_b, ... }
+			#              @bookcodes = [ bookcode_a, bookcode_b, ... ]
+			#              @inodes = { inode_a => bookcode_a, inode_b => bookcode_b, ... }
+		end
+
+		# load bookmarks
+		def load_bookmarks
+			bookmarks = {}
+
+			str = File.binread( @bookmarks_savepath )
+
+			JSON.parse( str ).each { |bookcode, h|
+				if get_book( bookcode )
+					get_book( bookcode ).page  = h['p']
+					get_book( bookcode ).rtime = h['r']
+				end
+			}
+		end
+	end
+end

data/lib/kamishibai/functions.rb

@@ -0,0 +1,332 @@
+# encoding: utf-8
+
+# License: refer to LICENSE file
+
+# for available_drives
+require 'win32ole' if RbConfig::CONFIG['host_os'] =~ /ming/
+
+
+require 'zip/filesystem'
+if RUBY_PLATFORM == 'java'
+	require 'image_voodoo'
+else
+	require 'gd2-ffij'
+end
+
+# is dir restricted directory?
+def restricted_dir?( dir, excludes=[] )
+	# restricted directory list
+	restricted_dirs = [
+		'.Trash', '.Trashes', '.fseventsd', '.Spotlight-V100', '.DocumentRevisions-V100',
+		'.$EXTEND',
+		'_SYNCAPP',
+		'Corrupted',
+		'System Volume Information', 'RECYCLER',
+		'backup',
+		'.sparsebundle',
+		'.tmpdir', '.tmp7z',
+		'.AppleDouble'
+	]
+
+	for word in restricted_dirs - excludes
+	    return true if dir.include?( word )
+    end
+    return false
+end
+
+class String
+	# escape [] and {} character for Dir.glob to use
+	def escape_glob
+		s = self.dup
+		s.gsub(/([\[\]\{\}\*\?\\])/, '\\\\\1')
+	end
+
+	# escape glob and overwite it
+	def escape_glob!
+		self.replace( self.escape_glob )
+	end
+
+	# escape characters and make it html safe
+	def escape_html
+		s = self.dup
+
+		for i in 32..255
+			next if i == 35 # #
+			next if i == 38 # &
+			next if i == 59 # ;
+			next if i >=  48 && i <=  57 # 0-9
+			next if i >=  65 && i <=  90 # A-Z
+			next if i >=  97 && i <= 122 # a-z
+			next if i >= 127 && i <= 159 # not defined in html standards
+
+			c = [i].pack('U')
+			r = "\&\##{i.to_s}\;"
+			s.gsub!(c, r) # replace char to html number
+		end
+
+		s
+	end
+
+	# escape characters and make it html safe and overwrite
+	def escape_html!
+		self.replace( self.escape_html )
+	end
+end
+
+# generate random char
+def GenChar(length)
+	length = length.to_i
+	return nil if length < 1
+
+	s = ''
+	w = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ' # 62 uniq chars
+
+	while s.length < length
+		s = s + w[rand(62)]
+	end
+
+	return s
+end
+
+# return image type
+def image_type(magic)
+	magic = magic[0..9]
+	case magic
+		when /^\xff\xd8/n
+			:jpeg
+		when /^\x89PNG/n
+			:png
+		when /^GIF8/n
+			:gif
+		when /^\x00/n
+			:wbmp
+		when /^gd2/n
+			:gd2
+		else
+			:unknown
+	end
+end
+# /class
+
+# show list of drives in ms windows environment
+def available_drives
+	if RbConfig::CONFIG['host_os'] =~ /ming/
+		drives = []
+
+		file_system = WIN32OLE.new("Scripting.FileSystemObject")
+		fs_drives = file_system.Drives
+		fs_drives.each do |drive|
+			next unless drive.IsReady
+			drives << drive.Path
+		end
+
+		drives
+	else
+		['/']
+	end
+end
+
+# returns total number of pages for cbz file
+def cbz_pages?( zfile )
+	i = 0
+	begin
+		Zip::File.open( zfile ) { |x|
+			x.each { |zobj|
+				if zobj.ftype == :file and File.basename(zobj.name)[0] != '.' and File.basename( zobj.name ) =~ /\.(jpg|jpeg|png|gif)$/i
+					i += 1
+				end
+			}
+		}
+	rescue
+		return nil
+	end
+	return i
+end
+
+
+# cbz file accessor, give file name and page and you shall receive
+def open_cbz( zfile, page = 1, options = {} )
+	objs = []
+	# begin
+		Zip::File.open( zfile ) { |x|
+			x.each { |zobj|
+				if zobj.ftype == :file and File.basename(zobj.name)[0] != '.' and File.basename( zobj.name ) =~ /\.(jpg|jpeg|png|gif)$/i
+					objs << zobj
+				end
+			}
+			objs.sort!
+
+			if objs.length == 0
+				puts "error: no image detected. #{zfile}"
+				return nil
+			elsif page > objs.length or page < 1
+				puts "error: no such page #{page} : #{zfile}"
+				return nil
+			else
+				img = objs[page-1].name
+				uimg = img.clone.force_encoding('UTF-8') # unicode version of filename, or it won't print on puts
+				puts "reading image… #{page} : #{uimg} : #{zfile}" if $debug
+
+				simg = x.file.read(img)
+
+				begin
+					# load the image to check if the image is corrupted or not
+					GD2::Image.load( simg ) if defined?(GD2)
+				rescue => errmsg
+					puts "error: fail to load image #{page} : #{zfile}"
+					p errmsg
+					return nil
+				end
+
+				return simg
+			end
+		}
+	# rescue => e
+	# 	puts "Corrupted zip file."
+	# 	puts e.exception
+	# 	puts e.backtrace
+	# end
+end
+
+if defined?(ImageVoodoo)
+	# resize image using Java library
+	def img_resize( dat, w, h, options = {} )
+		puts "resizing jimage… #{w} : #{h} : #{options[:quality]} : #{options[:format]}" if $debug
+
+		quality = options[:quality]
+		format = options[:format]
+
+		ssimg = ''
+		ImageVoodoo.with_bytes(dat) { |img|
+			scale = 1280 / img.width
+
+			img.scale( scale ) do |simg|
+				ssimg = simg.bytes( image_type( dat ).to_s )
+			end
+		}
+
+		return ssimg
+	end
+else
+	# resize image using GD library
+	#   image will maintain aspect ratio and fit within width and height specified
+	#   if width or height is 0, it will use the image original resolution
+	def img_resize( dat, w, h, options = {} )
+		quality = options[:quality]
+		format = options[:format]
+
+		begin
+			img = GD2::Image.load(dat)
+
+			# get image resolution
+			res = img.size
+			iw = res[0]
+			ih = res[1]
+
+			# calc new width and height
+			if w == 0
+				w = (h * img.aspect).to_i
+
+			elsif h == 0
+				h = (w / img.aspect).to_i
+
+			else
+				if iw >= ih
+					w = (h * img.aspect).to_i
+				else
+					h = (w / img.aspect).to_i
+				end
+			end
+
+			puts "resizing image… width: #{w}, height: #{h}, quality: #{quality}" if $debug
+
+			# make sure it doesn't upscale image
+			if iw > w and ih > h
+				img.resize!( w, h )
+			end
+
+			if format
+				case format
+					when :png
+						img.png
+					when :jpeg
+						if quality
+							img.jpeg( quality.to_i )
+						else
+							img.jpeg
+						end
+					when :gif
+						img.gif
+					else
+						raise 'img_resize(elsif format), unknown output format'
+				end
+			else
+				case image_type(dat)
+					when :png
+						img.png
+					when :jpeg
+						if quality
+							img.jpeg( quality.to_i )
+						else
+							img.jpeg
+						end
+					when :gif
+						img.gif
+					else
+						raise 'img_resize(else), unknown output format'
+				end
+			end
+
+		rescue => errmsg
+			puts "error: resize failed. #{w} #{h} #{quality}"
+			p errmsg
+			return nil
+		end
+	end
+end
+
+# create image thumbnail and save to cache
+def mk_thumb(f_cbz, auto_gen = false)
+	unless auto_gen
+		# holds the last time the open_cbz is called
+		# to pause the Thumbnail Generator thread
+		$open_cbz_ltime = Time.now
+	end
+
+	quality = 60 #80
+	width = 220 #320
+	height = 0
+	page = 1
+
+	f = $settings.cache_path + '/' + File.basename( f_cbz.delete('ÿ') ).gsub('.cbz','.jpeg') # utf8-mac puts ÿ in filename, need to remove first for cross os support
+
+	if File.exists?( f )
+		if File.size( f ) == 0
+			File.delete( f )
+		else
+			if auto_gen
+				# no need to return data if this is called from auto thumbnail worker
+				return
+			else
+				# return file if it exists
+				puts "thumbnail found. #{f}" if $debug
+				return File.binread( f )
+			end
+		end
+	end
+
+	puts "thumbnail generated. #{f_cbz}" if $debug
+	image = open_cbz( f_cbz, page )
+	image = img_resize(image, width, height, { :quality => quality, :format => :jpeg })
+
+	begin
+		# store image to cache dir
+		FileUtils.mkdir_p( File.dirname( f ) ) if ! Dir.exists?( File.dirname( f ) )
+		File.binwrite( f, image )
+	rescue => errmsg
+		puts "\nthumbnail storage failed: #{f} >> #{errmsg} … retrying\n"
+		retry
+	end
+
+	return image
+end