lyrics-ebook 0.1

data/lib/eeepub/spec/eeepub_spec.rb

@@ -0,0 +1,4 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Epubr" do
+end

data/lib/eeepub/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rubygems'
+require 'eeepub'
+require 'spec'
+require 'spec/autorun'
+require 'nokogiri'
+require 'rr'
+
+Spec::Runner.configure do |config|
+  config.mock_with :rr
+end

data/lib/lyrics_ebook.rb

@@ -0,0 +1,71 @@
+
+require 'lyrics_ebook/lyric'
+require 'lyrics_ebook/cache_manager'
+require 'lyrics_ebook/lyric_download'
+require 'lyrics_ebook/mp3_parser'
+require 'lyrics_ebook/lyrics2html'
+
+# The main class 
+#
+# Song lyrics are stored in <home>/Lyrics, if exists, 
+#  else in <home>/.lyrics_ebook/Lyrics
+#
+class LyricsEbook
+
+  def initialize
+    find_base_lyrics_dir
+    @cm=CacheManager.new(@base_lyrics_dir)
+    @cm.alternative_dir=@alt_lyrics_dir
+    @dm=LyricDownload.new
+    @mp3_parser=Mp3Parser.new
+  end
+
+  def parse_dir dir
+    if dir.nil?
+      puts "Dir not set" 
+      return 
+    end
+    @mp3_parser.parse dir
+    $stdout.flush
+    download
+  end
+
+  def download
+    puts "start downloading..."
+    total, new, missing=0,0,0
+    lyrics=@mp3_parser.lyrics
+    lyrics.each do |lyric|
+      total+=1
+      if lyric.text.nil? && !@cm.get(lyric)
+        if @dm.download(lyric)
+          @cm.store(lyric)
+          new+=1
+        else
+          missing+=1 
+        end
+      end
+    end
+    puts "#{total} songs in total; #{new} just downloaded; #{missing} missing "
+  end
+
+  def build epub_name=nil
+    epub_name="lyrics-ebook.epub" if epub_name.nil? 
+    l2h=Lyrics2Html.new
+    l2h.add_lyrics @cm.get_lyrics
+    l2h.to_epub epub_name
+  end
+
+  private
+
+  def find_base_lyrics_dir
+    lyric_home=File.join(ENV['HOME'],'Lyrics')
+    lyric_ebook_home=File.join(ENV['HOME'],'.lyrics_ebook','Lyrics')
+    lyric_home_exists=File.exists?(lyric_home) && File.directory?(lyric_home)
+    @base_lyrics_dir=lyric_home_exists ? lyric_home : lyric_ebook_home
+    @alt_lyrics_dir=lyric_home_exists ? lyric_ebook_home : nil
+    puts "Using Lyrics dir :"+@base_lyrics_dir
+  end
+
+end
+
+

data/lib/lyrics_ebook/cache2html.rb

@@ -0,0 +1,33 @@
+require 'erb'
+include ERB::Util
+
+
+class Cache2Html
+  
+   def parse_dir(dirname, hash=nil)
+     parser=MiniLyricsParser.new
+   
+     @hash=Hash.new{ |hash,key| hash[key]=[] } unless @hash
+     @cache=Hash.new{ |hash,key| hash[key]={} } unless @cache
+     
+     Dir.foreach(dirname) do |filename|
+       file=File.join(dirname,filename)
+       lp=parser.parse(file)
+       if lp
+         @hash[lp.artist.upcase.strip] << lp
+         @cache[lp.artist][lp.title]= file
+       end
+     end
+   end
+
+   def to_html
+     data=@hash.to_a.sort!
+     data.each{|r| r[1].sort! }
+     template=""
+     IO.foreach('template.erb.html') {|line| template << line }
+     html=ERB.new(template)
+     html.run(binding)
+   end
+  
+end
+

data/lib/lyrics_ebook/cache_manager.rb

@@ -0,0 +1,77 @@
+require 'fileutils'
+require 'kconv'
+
+class CacheManager
+
+  def initialize(base_dir='data')
+    @base_dir=base_dir
+  end
+
+  def alternative_dir=(alt_dir)
+    @alt_dir=alt_dir
+  end
+
+  def get(lyric)
+    file=lyric2file(lyric)
+    if !File.exists?(file) && !@alt_dir.nil?
+      file=lyric2file(lyric,false,@alt_dir)
+    end 
+    return false unless File.exists?(file)
+    read_lyric_file(file,lyric)
+  end
+
+  def store(lyric)
+    file=lyric2file(lyric,true)
+    File.open(file,'w') do |f|
+      f << "#{lyric.artist} - #{lyric.title}\n\n".toutf8
+      f << lyric.text.toutf8
+    end
+  end
+
+  def get_lyrics
+    res=[]
+    Dir.foreach(@base_dir) do |artist_dir|
+      artist_dir_path=File.join(@base_dir,artist_dir)
+      if File.directory?(artist_dir_path)
+        Dir.foreach(artist_dir_path) do |lyric_file|
+          ext=File.extname(lyric_file)
+          if ext==".lyric"
+            basename=File.basename(lyric_file,ext)
+            lyric_file_path=File.join(artist_dir_path,lyric_file)
+            lyric=Lyric.new({:artist=>artist_dir, :title=>basename})
+            read_lyric_file(lyric_file_path,lyric)
+            res << lyric
+          end
+        end
+      end
+    end
+    res
+  end
+
+  private
+
+  def lyric2file(lyric,create_missing_dirs=false, dir=@base_dir)
+    title=fix_string(lyric.title)
+    artist=fix_string(lyric.artist)
+    artist_dir=File.join(dir,artist)
+    FileUtils.mkdir_p(artist_dir) if (!File.exists?(artist_dir) && create_missing_dirs)
+    song_file=File.join(dir,artist,title+".lyric")
+    song_file
+  end
+
+  def fix_string string
+    @re_inv_chars=/[\x00\/\\:\*\?\"<>\|]/ unless @re_inv_chars
+    string.strip.downcase.gsub(@re_inv_chars,'_')
+  end
+
+  def read_lyric_file(file, lyric=Lyric.new)
+    s=[]
+    IO.foreach(file) do |line|
+      s << line
+    end
+    lyric.artist,lyric.title=s.shift.split(" - ").collect!{|el| el.strip}
+    s.shift if s[0]=="\n"
+    lyric.text=s
+  end
+
+end

data/lib/lyrics_ebook/lyric.rb

@@ -0,0 +1,32 @@
+class Lyric
+
+  attr_accessor :artist, :album, :title, :tracknum, :mp3_filename
+
+  def initialize(map=nil)
+    map.each do |k,v|
+      send("#{k}=",v)
+    end if map
+  end
+      
+  def <=>(other)
+    @title<=>other.title
+  end
+
+  def to_s
+    "#{@artist} - #{@title}"
+  end
+
+  def text=(a)
+    @text=a.to_a
+  end
+
+  def text
+    @text.join if @text
+  end
+
+  def html_text
+    @text.collect{|line| h(line)}.join("<br />")
+  end
+  
+end
+

data/lib/lyrics_ebook/lyric_download.rb

@@ -0,0 +1,50 @@
+require "wiki_lyrics/utils/strings"
+require "wiki_lyrics/cli/plugins" 
+require "wiki_lyrics/cli/wikilyrics" 
+
+
+class Application
+	def process( artist, title, album, year )
+		if @featuring_fix
+			artist = Strings.cleanup_artist( artist, title )
+			title  = Strings.cleanup_title( title )
+		end
+
+		puts( "searching.. #{title} - #{artist}" ) 
+
+		request = Lyrics::Request.new( artist, title, album, year )
+		response, response_plugin, shown_review_dialog = fetch_lyrics( request )
+
+		if response.lyrics
+			artist = response.artist ? response.artist : response.request.artist
+			title = response.title ? response.title : response.request.title
+			puts "found at #{response_plugin.site_name}"
+			$stdout.flush
+  		return response.lyrics
+		else
+			puts "not found...."
+			$stdout.flush
+			return nil
+		end
+
+	end
+
+end
+
+sites = ["Lyriki", "LyricWiki"]
+Plugins.load_plugins( sites )
+
+class LyricDownload
+
+	def download(lyric)
+	  @app = Application.new true, true, false
+    begin
+      text=@app.process(lyric.artist,lyric.title, nil, nil )
+      lyric.text=text if text
+      !text.nil?
+    ensure
+	    @app.finalize()
+    end
+  end
+end
+

data/lib/lyrics_ebook/lyrics2html.rb

@@ -0,0 +1,106 @@
+#require 'rubygems'
+#require 'eeepub'
+require 'eeepub/lib/eeepub'
+require 'erb'
+require 'kconv'
+require 'date'
+
+include ERB::Util
+
+class Lyrics2Html
+
+  def add_lyrics(lyrics)
+    @hash=Hash.new{ |hash,key| hash[key]=[] } unless @hash
+    lyrics.each do |lyric|
+      unless lyric.text.nil?
+        @hash[lyric.artist.upcase.strip] << lyric
+      end
+    end
+  end
+
+  def to_epub name
+    ext=File.extname(name)
+    basename=File.basename(name,ext)
+    @html_files=[]
+    Dir.mktmpdir do |base_dir|
+      build_pages base_dir
+      nav1=build_nav
+      files=[]
+      @html_files.each do |file|
+        files << {file=>'pages'}
+      end
+      epub = EeePub.make do
+        title       basename
+        creator     'lyrics-ebook'
+        publisher   'maner'
+        date        Date.today.to_s
+        identifier  'http://example.com/book/foo', :scheme => 'URL'
+        uid         'http://example.com/book/foo'
+        files files
+        nav nav1
+        guide  [
+          {:type => 'toc', :title => 'Table of Contents', :href => 'pages/artists.xhtml'},
+          {:type => 'cover', :title => 'Cover', :href => 'pages/cover.xhtml'}
+        ]
+      end
+      name=name+".epub" if ext==""
+      epub.save(name)
+      puts "Created "+name
+    end
+  end
+
+  private 
+
+  def build_pages base_dir
+    @data=@hash.to_a.sort!
+    @data.each{|r| r[1].sort! }
+    pages_dir=File.join(base_dir,"pages")
+    Dir.mkdir(pages_dir)
+    build_html('cover',pages_dir)
+    build_html('artists',pages_dir)
+    @data.each_with_index do |art_lyrics,index|
+      @art_name=art_lyrics[0]
+      @lyrics=art_lyrics[1]
+      build_html('art_'+index.to_s,pages_dir,'art_')
+    end
+  end
+
+  def build_nav
+    nav=[]
+    @data.each_with_index do |art_lyrics,index|
+      art_aname="pages/art_#{index}.xhtml"
+      art_label=art_lyrics[0]
+      nav1=[]
+      art_lyrics[1].each_with_index do |lyric, index_song|
+        song_aname="pages/art_#{index}.xhtml#song_#{index_song}"
+        nav1 << {:label => lyric.title, :content =>song_aname}
+      end
+      nav << {:label => art_label, :content => art_aname, :nav => nav1}
+    end
+    [
+     {:label => "Cover", :content =>'pages/cover.xhtml'},
+     {:label => "Artists", :content =>'pages/artists.xhtml', :nav => nav}
+    ]
+  end
+
+  def build_html name, basedir, template_name=nil
+    template_name=name if template_name.nil?
+    template=read_template(template_name)
+    html=ERB.new(template)
+    res=html.result(binding)
+    html_file=File.join(basedir, name+'.xhtml')
+    File.open(html_file,'w') do |f|
+      f << res.toutf8
+    end
+    @html_files << html_file
+  end
+
+  def read_template name
+    template_file=File.dirname(__FILE__)+"/../../templates/"+name+".erb.xhtml"
+    template=""
+    IO.foreach(template_file) {|line| template << line }
+    template
+  end
+  
+end
+

data/lib/lyrics_ebook/mini_lyrics_parser.rb

@@ -0,0 +1,26 @@
+require 'lyric'
+
+class MiniLyricsParser
+
+   def parse filename
+     return if File.directory?(filename)
+     lyric=Lyric.new
+     basename=File.basename(filename, File.extname(filename))
+     lyric.artist,lyric.title=basename.split(" - ")
+     text_a=[]
+     IO.foreach(filename) do |line|
+       cl=clear(line).strip
+       text_a << h(cl) if cl.size>0
+     end
+     lyric.text=text_a.join("<br />\n")
+     lyric
+   end
+
+   private
+
+   def self.clear(line)
+     line.gsub(/\[.*\]/,"")
+   end
+   
+end
+

data/lib/lyrics_ebook/mp3_parser.rb

@@ -0,0 +1,37 @@
+require 'rubygems'
+require 'mp3info'
+
+class Mp3Parser
+  attr_accessor :lyrics
+
+  def initialize
+    @lyrics= []
+  end
+
+  def parse filename
+    if File.directory?(filename)
+      Dir.foreach(filename) do |file2|
+        unless ['.','..'].include?(file2)
+          f= File.join(filename,file2)
+          parse f
+        end
+      end
+      return
+    end
+    
+    ext=File.extname(filename)
+    if (ext=='.mp3')
+      Mp3Info.open(filename) do |mp3|
+        if mp3.tag.title
+          lyric=Lyric.new(:artist=>mp3.tag.artist, :album=>mp3.tag.album, :title=>mp3.tag.title,
+            :tracknum=>mp3.tag.tracknum, :mp3_filename=>filename)
+          @lyrics << lyric
+          puts "Added : #{lyric.to_s}"  
+        end
+      end
+    end
+    
+  end
+
+end
+