Piggy 0.4.2.4 → 0.4.3.0

data/lib/piggy-core/thumbnail_page_generator.rb

@@ -11,7 +11,7 @@ require 'piggy-core/options'
 #
 # Generation without frames:
 #
-#  outputPath
+#  output_path
 #   |
 #   +----subDir
 #            |
@@ -30,7 +30,7 @@ require 'piggy-core/options'
 #
 # Generation with frames:
 #
-#  outputPath
+#  output_path
 #   |
 #   +----subDir
 #   |        |
@@ -68,26 +68,28 @@ class ThumbnailPageGenerator < HtmlGenerator
     @indexName = 'index' + HtmlExt
   end
   
-  def setOutputDirectory(outputDir)
+  def set_output_directory(outputDir)
     @subDir = outputDir
-    @imageOutputPath = File.join(outputPath, outputDir)
+    @imageOutputPath = File.join(output_path, outputDir)
   end
   
   # Overwrite this, if you convert arbitrary image types into
   # output formats suitable for web pages, e. g. jpg or png
-  def conversionTypeFor(type)
+  def conversion_type_for(type)
     type
   end
   
-  def imageName(info)
-    escapeHtml("#{info.nameWithoutExtension}.#{conversionTypeFor(info.extension)}")
+  def image_name(info, pre = '')
+    offset = @options.stylesSample? ? "../basic/#{pre}" : pre
+    name = "#{info.name_without_extension}.#{conversion_type_for(info.extension)}"
+    offset + escape_html(name)
   end
   
-  def setFiles(fileInfos)
+  def set_files(fileInfos)
     @inputFilenames = fileInfos  
   end
   
-  def setTitle(title)
+  def set_title(title)
     @title = title
   end
   
@@ -99,147 +101,148 @@ class ThumbnailPageGenerator < HtmlGenerator
     return "..#{sep}"
   end
   
-  def outputPath
+  def output_path
     return @options.localDestinationPath
   end
   
-  def mainIndexPath
-    return @options.generateFramePage ? outputPath : imageOutputPath
+  def main_index_path
+    return @options.generateFramePage ? output_path : imageOutputPath
   end
   
-  def mainIndexWithPath
-    return mainIndexPath + sep + indexName
+  def main_index_with_path
+    return main_index_path + sep + indexName
   end
   
-  def getBacklinkString
+  def get_backlink_string
     @options.generateFramePage? ? back + subDir + HtmlExt : indexName
   end
   
-  def subStylesheetUrl
+  def sub_stylesheet_url
     if @options.generateFramePage?
-      back + mainStylesheetUrl
+      back + main_stylesheet_url
     else
-      mainStylesheetUrl
+      main_stylesheet_url
     end
   end
   
-  def mainStylesheetUrl
+  def main_stylesheet_url
     'style/style.css'
   end
   
   # Add important meta tags
-  def commonHead
+  def common_head
     norobots()
     # the next tag will tell Piggy that this file may be
     # overwritten by Piggy
     meta({
-      "name" => "generator",
-      "content" =>"Piggy"})
+        "name" => "generator",
+        "content" =>"Piggy"})
     utf8()
   end
   
   # Check if this file has been written by Piggy
-  def isPiggyFile?(file)
+  def is_piggy_file?(file)
     ret = false
-    File.open(file, 'r') { |fp|
-      while !ret && fp.gets
-        ret = true if(/<meta.*name="generator"/ && /<meta.*content="Piggy"/)
+    File.open(file, 'r') do |fp|
+      while !ret && (line = fp.gets)
+        ret = /<meta.*name="generator"/.match(line) &&
+          /<meta.*content="Piggy"/.match(line)
       end
-    }
+    end
     return ret
   end
   
-  def buildHtmlPagesForImages(progress)
-    progress.setTask("Generate html", @inputFilenames.size)
-    maxInd = @inputFilenames.size - 1
-    backlink = getBacklinkString
-     (0..maxInd).each { | i |
+  def build_html_pages_for_images(progress)
+    progress.set_task("Generate html", @inputFilenames.size)
+    max_ind = @inputFilenames.size - 1
+    backlink = get_backlink_string
+    (0..max_ind).each { | i |
       currentInfo = @inputFilenames[i]
-      predInfo = @inputFilenames[i == 0 ? maxInd : i - 1]
-      succInfo = @inputFilenames[i == maxInd ? 0 : i + 1]
-      current = currentInfo.nameWithoutExtension
+      predInfo = @inputFilenames[i == 0 ? max_ind : i - 1]
+      succInfo = @inputFilenames[i == max_ind ? 0 : i + 1]
+      current = currentInfo.name_without_extension
       comment = currentInfo.comment
-      pred = predInfo.nameWithoutExtension
-      succ = succInfo.nameWithoutExtension
-      progress.setProgress(current, 1)
-      newTransitional
+      pred = predInfo.name_without_extension
+      succ = succInfo.name_without_extension
+      progress.set_progress(current, 1)
+      new_transitional
       html {
         head {
-          title() { escapeHTML(current) }
-          commonHead
-          stylesheet subStylesheetUrl
+          title() { escape_html(current) }
+          common_head
+          stylesheet sub_stylesheet_url
         }
         body({"class"=>"image_page"}) {
-	  div({'class' => 'content'}){
-	    div({'class' => 'navigation'}){
-	      div {
-		div {
-		  p {
-		    a({"HREF" => escapeHTML(pred) + HtmlExt}){
-		      addHtml(escapeHTML(i == 0 ? 'last' : 'previous'))
-		    }
-		    a({"HREF" => escapeHTML(backlink) }) {
-		      addHtml(escapeHTML('overview'))
-		    }
-		    a({"HREF" => escapeHTML(succ) + HtmlExt}) {
-		      addHtml(escapeHTML(i == maxInd ? 'first' : 'next'))
-		    }
-		  }
-		}
-	      }
-	    }
-	    div({'class' => 'image'}){
-	      div {
-		div {
-		  p {
-		    img(imageName(currentInfo), escapeHTML(current))
-		  }
-		}
-	      }
-	    }
-	    div({'class' => 'comment'}){
-	      div {
-		div {
-		  p { addHtml(escapeHTML(comment)) }
-		}
-	      }
-	    }
-	  }
-	}
+          div({'class' => 'content'}){
+            div({'class' => 'navigation'}){
+              div {
+                div {
+                  p {
+                    a({"HREF" => escape_html(pred) + HtmlExt}){
+                      add_html(escape_html(i == 0 ? 'last' : 'previous'))
+                    }
+                    a({"HREF" => escape_html(backlink) }) {
+                      add_html(escape_html('overview'))
+                    }
+                    a({"HREF" => escape_html(succ) + HtmlExt}) {
+                      add_html(escape_html(i == max_ind ? 'first' : 'next'))
+                    }
+                  }
+                }
+              }
+            }
+            div({'class' => 'image'}){
+              div {
+                div {
+                  p {
+                    img(image_name(currentInfo), escape_html(current))
+                  }
+                }
+              }
+            }
+            div({'class' => 'comment'}){
+              div {
+                div {
+                  p { add_html(escape_html(comment)) }
+                }
+              }
+            }
+          }
+        }
       }
       File.open(File.join(imageOutputPath, current + HtmlExt), 'w') { | fp |
-        fp.print(getPage)
+        fp.print(get_page)
       }
     }
   end
   
-  def buildSlideshowList
+  def build_slideshow_list
     File.open(File.join(imageOutputPath, 'images.js'), 'w') { | fp |
       fp.print("var images = new Array(\n")
       maxInd = @inputFilenames.size - 1
-       (0..maxInd).each { | i |
-        current = slideshowImage(@inputFilenames[i])
+      (0..maxInd).each { | i |
+        current = slideshow_image(@inputFilenames[i])
         fp.print("#{current}")
         fp.print(i == maxInd ? "\n" : ",\n")
       }
       fp.print(")\n")
     }
     unless @inputFilenames.empty?
-      updateSlideshowTemplate(slideshowImage(@inputFilenames[1]))
+      update_slideshow_template(slideshow_image(@inputFilenames[1]))
     end
   end
 
-  def slideshowImage(fileInfo)
-    src = imageName(fileInfo)
-    txt = escapeHtml(fileInfo.comment)
+  def slideshow_image(fileInfo)
+    src = image_name(fileInfo)
+    txt = escape_html(fileInfo.comment)
     "new slide(\"#{src}\", \"\", \"#{txt}\")"
   end
 
-  def updateSlideshowTemplate(imageFile)
+  def update_slideshow_template(imageFile)
     reset
     file = File.join(imageOutputPath, 'slideshow.htm')
     lines = File.readlines(file)
-    backlink = "href=\"#{getBacklinkString}\""
+    backlink = "href=\"#{get_backlink_string}\""
     File.open(file, 'w') { |fp|
       lines.each { |line|
         line = line.gsub('PLACEHOLDER_FOR_IMAGE_NAME', imageFile)
@@ -249,7 +252,7 @@ class ThumbnailPageGenerator < HtmlGenerator
     }
   end
   
-  def bytesAsString(bytes)
+  def bytes_as_string(bytes)
     kb = bytes/1024
     return "#{kb} KB" if kb < 1024
     mb = kb/1024
@@ -258,58 +261,58 @@ class ThumbnailPageGenerator < HtmlGenerator
     return  "#{gb} GB"
   end
   
-  def buildThumbnailPage(sizeOfZipfile = -1)
-    numCol = 5
-    matrix = Array.new(@inputFilenames.size() / numCol)
+  def build_thumbnail_page(size_of_zipfile = -1)
+    num_col = 5
+    matrix = Array.new(@inputFilenames.size() / num_col)
     row = -1
     col = 0
     @inputFilenames.each { |info|
-      if col % numCol == 0
+      if col % num_col == 0
         col = 0
         row += 1
-        matrix[row] = Array.new(numCol) 
+        matrix[row] = Array.new(num_col)
       end
       matrix[row][col] = info
       col += 1
     }
-    newTransitional
+    new_transitional
     html() {
       head() {
         title() { @title }
-        commonHead()
-        stylesheet subStylesheetUrl
+        common_head()
+        stylesheet sub_stylesheet_url
       }
       body({'class'=>'thumbs'}){
-        h3({}){ addHtml(escapeHTML(@title)) }
-	if(sizeOfZipfile > 0)
-	  a({"href" => DownloadName }) { addHtml(DownloadName) }
-	  addHtml("(#{bytesAsString(sizeOfZipfile)})")
-	end
-	if(@options.addSlideshow?)
-	  a({"href" => File.join('slideshow.htm'), "target" => "_top"}) {
-	    addHtml(SlideshowName)
-	  }
-	end
-	imageTable({'class'=>'table'}) {
-	  matrix.each { |row|
-	    imageRow {
-	      row.each { |info|
-		if info
-		  imageColumn {
-		    addPreview(info)
-		  }
-		end
-	      }
-	    }
-	  }
-	}
+        h3({}){ add_html(escape_html(@title)) }
+        if(size_of_zipfile > 0)
+          a({"href" => DownloadName }) { add_html(DownloadName) }
+          add_html("(#{bytes_as_string(size_of_zipfile)})")
+        end
+        if(@options.addSlideshow?)
+          a({"href" => File.join('slideshow.htm'), "target" => "_top"}) {
+            add_html(SlideshowName)
+          }
+        end
+        image_table({'class'=>'table'}) {
+          matrix.each do |m_row|
+            image_row {
+              m_row.each do |info|
+                if info
+                  image_column {
+                    add_preview(info)
+                  }
+                end
+              end
+            }
+          end
+        }
       }
     }
     File.open(File.join(imageOutputPath, indexName), 'w') { | fp |
-      fp.print(getPage) }
+      fp.print(get_page) }
   end
 
-  def imageTable(params, &block)
+  def image_table(params, &block)
     if @options.useTable?
       table(params, &block)
     else
@@ -317,140 +320,140 @@ class ThumbnailPageGenerator < HtmlGenerator
     end
   end
 
-  def imageRow(&block)
-     if @options.useTable?
-       tr({}, &block)
-     else
-       block.call
-     end
+  def image_row(&block)
+    if @options.useTable?
+      tr({}, &block)
+    else
+      block.call
+    end
   end
 
-  def imageColumn(&block)
-     if @options.useTable?
-       td({}, &block)
-     else
-       dd({}, &block)
-     end
+  def image_column(&block)
+    if @options.useTable?
+      td({}, &block)
+    else
+      dd({}, &block)
+    end
   end
 
-  def addPreview(info)
+  def add_preview(info)
     div({'class' => 'preview'}){
       div({'class' => 'thumb'}){
-	p {
-	  name = escapeHtml(info.nameWithoutExtension)
-	  a({
-	      "href" => name + HtmlExt,
-	      'target' => '_top'}
-	    ) {
-	    img('t_'+ imageName(info), name)
-	  }
-	}
+        p {
+          name = escape_html(info.name_without_extension)
+          a({
+              "href" => name + HtmlExt,
+              'target' => '_top'}
+          ) {
+            img(image_name(info, 't_'), name)
+          }
+        }
       }
     }
   end
   
-  def frameText()
-    newFrame
+  def frame_text()
+    new_frame
     html(){
       head(){
         title { 'Bildindex' }
-        commonHead
-        stylesheet mainStylesheetUrl
+        common_head
+        stylesheet main_stylesheet_url
       }
       frameset({'rows'=>'14%,65%,21%'}){
         frame({
-          'src'=>"kopf.htm",
-          'name'=>"Kopf",
-          'scrolling'=>"no",
-          'frameborder'=>"0"
-        })
-        frameset({'cols'=>"15%,85%"}){
-          frame({
-            'src'=>"navigation.htm",
-            'name'=>"Navigation",
-            'scrolling'=>"yes",
+            'src'=>"kopf.htm",
+            'name'=>"Kopf",
+            'scrolling'=>"no",
             'frameborder'=>"0"
           })
+        frameset({'cols'=>"15%,85%"}){
           frame({
-            'src'=>"#{subDir + sep + indexName}",
-            'name'=>"Daten",
-            'frameborder'=>"0"
-          })
+              'src'=>"navigation.htm",
+              'name'=>"Navigation",
+              'scrolling'=>"yes",
+              'frameborder'=>"0"
+            })
+          frame({
+              'src'=>"#{subDir + sep + indexName}",
+              'name'=>"Daten",
+              'frameborder'=>"0"
+            })
         }
         frame({
-          'src'=>"fuss.htm",
-          'name'=>"Fuss",
-          'scrolling'=>"no",
-          'frameborder'=>"0"
-        })
+            'src'=>"fuss.htm",
+            'name'=>"Fuss",
+            'scrolling'=>"no",
+            'frameborder'=>"0"
+          })
         noframes(){
           cr
-          addHtml('Ohne Frames siehe: ')
+          add_html('Ohne Frames siehe: ')
           a({'href'=>"navigation.htm"}){
-            addHtml('Navigationsleiste')
+            add_html('Navigationsleiste')
           }
         }
       }
     }
-    return getPage
+    return get_page
   end
   
-  def buildFramePage()
-    content = frameText
-    writeFile(File.join(outputPath, subDir + HtmlExt), content)
-    writeFile(File.join(outputPath, indexName), content)
+  def build_frame_page()
+    content = frame_text
+    write_file(File.join(output_path, subDir + HtmlExt), content)
+    write_file(File.join(output_path, indexName), content)
   end
   
-  def writeFile(file, content)
-    return if File.exists?(file) && !isPiggyFile?(file)
+  def write_file(file, content)
+    return if File.exists?(file) && !is_piggy_file?(file)
     File.open(file, 'w') { |fp| fp.print(content) }
   end
   
-  def buildZipfile(nameOfZipFile, progress)
+  def build_zip_file(nameOfZipFile, progress)
     require 'zip/zip'
-    progress.setTask("Creating zipfile", @inputFilenames.size)
+    progress.set_task("Creating zipfile", @inputFilenames.size)
     Zip::ZipFile.open(nameOfZipFile, Zip::ZipFile::CREATE) {
       |zipfile|
       zipfile.mkdir(subDir)
       @inputFilenames.each do
         |info|
-        progress.setProgress("Zip #{info.name}", 1)
+        progress.set_progress("Zip #{info.name}", 1)
         entry = File.join(subDir, info.name)
-        src = info.nameWithPath
+        src = info.name_with_path
         zipfile.add(entry, src) 
       end
     }
   end
   
-  def copyTemplateFiles()
+  def copy_template_files()
     if @options.generateFramePage
-      copyTemplates(['navigation.htm', 'kopf.htm', 'fuss.htm'],
-		    outputPath)
-      copyStyle(outputPath)
+      copy_templates(['navigation.htm', 'kopf.htm', 'fuss.htm'],
+		    output_path)
+      copy_style(output_path)
     else
-      copyStyle(imageOutputPath)
+      copy_style(imageOutputPath)
     end
     if @options.addSlideshow?
-      copyTemplates(['slideshow.htm', 'slideshow.js'], imageOutputPath)  
-      link = "<link href=\"#{subStylesheetUrl}\" rel=\"stylesheet\" type=\"text/css\">"
-      insertInFile(File.join(imageOutputPath, 'slideshow.htm'),
-		   /<!--STYLE-->/, link)
+      copy_templates(['slideshow.htm', 'slideshow.js'], imageOutputPath)
+      link = "<link href=\"#{sub_stylesheet_url}\" rel=\"stylesheet\" type=\"text/css\">"
+      insert_in_file(File.join(imageOutputPath, 'slideshow.htm'),
+        /<!--STYLE-->/, link)
     end
   end
 
-  def styleSourceDir
+  def style_source_dir
     File.join(PIGGY_PATH, 'templates/styles', @options.style)
   end
 
-  def copyStyle(targetPath)
-    targetDir = File.join(targetPath, 'style')
-    File.makedirs(targetDir)
-    Dir[File.join(styleSourceDir, '*.*')].each { |fName|
-      File.copy(fName, targetDir) unless File.exists?(File.join(targetDir, fName))
+  def copy_style(targetPath)
+    target_dir = File.join(targetPath, 'style')
+    File.makedirs(target_dir)
+    Dir[File.join(style_source_dir, '*.*')].each { |fName|
+      File.copy(fName, target_dir) unless File.exists?(File.join(target_dir, fName))
     }
   end
   
-  def copyTemplates(files, targetPath)
+  def copy_templates(files, targetPath)
     files.each do
       |fName|
       unless File.exists?(File.join(targetPath, fName))
@@ -461,7 +464,7 @@ class ThumbnailPageGenerator < HtmlGenerator
   end
   
   # Insert insertion into file after any match of pattern
-  def insertInFile(file, pattern, insertion)
+  def insert_in_file(file, pattern, insertion)
     lines = File.readlines(file)
     File.open(file, 'w') { |fp|
       lines.each { |line|
@@ -471,18 +474,18 @@ class ThumbnailPageGenerator < HtmlGenerator
     }
   end
 
-  def updateNavigationFrame()
+  def update_navigation_frame()
     reset
-    navFile = File.join(outputPath, 'navigation.htm')
+    nav_file = File.join(output_path, 'navigation.htm')
     a({
-      'href' => escapeHtml(subDir) + '/index.htm',
-      'target' => 'Daten'}) {
-      addHtml(escapeHTML(@title))
+        'href' => escape_html(subDir) + '/index.htm',
+        'target' => 'Daten'}) {
+      add_html(escape_html(@title))
     }
     br
-    addHtml("\n")
-    link = getPage
-    insertInFile(navFile, /<!--NAV-->/, link) 
+    add_html("\n")
+    link = get_page
+    insert_in_file(nav_file, /<!--NAV-->/, link)
   end
   
   def error msg
@@ -493,37 +496,38 @@ class ThumbnailPageGenerator < HtmlGenerator
   ##
   # Will create the directory for all the '3 files per image'
   # unless directory exits
-  def createSubdir
-    subDirWithPath = File.join(outputPath, subDir)
-    Dir.mkdir(subDirWithPath) unless  File.directory?(subDirWithPath)
+  def create_subdir
+    sub_dir_with_path = File.join(output_path, subDir)
+    Dir.mkdir(sub_dir_with_path) unless  File.directory?(sub_dir_with_path)
   end
   
   ##
   # Central bublic doit function
-  def generate(progress, overwrite=false, addZipfile=false)
-    if File.directory?(File.join(outputPath, subDir)) && !overwrite
-      return error("#{subDir} allready exists")
+  def generate(progress, overwrite=false, add_zipfile=false)
+    unless File.directory?(output_path)
+      return error("#{output_path} ist no directory}")
     end
-    unless File.directory?(outputPath)
-      return error("#{outputPath} ist no directory}")
+    if File.directory?(File.join(output_path, subDir))
+      return error("#{subDir} allready exists") unless overwrite
+    else
+      progress.set_task("Creating directory")
+      create_subdir
     end
-    progress.setTask("Creating directory")
-    createSubdir
-    sizeOfZipfile = -1
-    if addZipfile
-      nameOfZipFile = File.join(outputPath, subDir, DownloadName)
-      buildZipfile(nameOfZipFile, progress)
-      sizeOfZipfile = File.size(nameOfZipFile) if File.exists?(nameOfZipFile)
+    size_of_zipfile = -1
+    if add_zipfile
+      name_of_zip_file = File.join(output_path, subDir, DownloadName)
+      build_zip_file(name_of_zip_file, progress)
+      size_of_zipfile = File.size(name_of_zip_file) if File.exists?(name_of_zip_file)
     end
-    buildHtmlPagesForImages(progress)
-    buildThumbnailPage(sizeOfZipfile)
-    copyTemplateFiles
-    buildSlideshowList if @options.addSlideshow?
+    build_html_pages_for_images(progress)
+    build_thumbnail_page(size_of_zipfile)
+    copy_template_files
+    build_slideshow_list if @options.addSlideshow?
     if @options.generateFramePage?
-      buildFramePage
-      updateNavigationFrame
+      build_frame_page
+      update_navigation_frame
     end
-    imageProcessing(progress)
+    image_processing(progress) unless @options.skipImageProcessing
     return true
   end
 
@@ -532,12 +536,12 @@ class ThumbnailPageGenerator < HtmlGenerator
   ##
   # Overwrite this hook method to add image processing
   # to html genmeration
-  def imageProcessing(&block)
+  def image_processing(&block)
   end
   
   ##
   # Service which migt be useful if no client is set 
-  def runCommand(commandline, workingDir)
-    inPath(workingDir) { `#{commandline}` }
+  def run_command(commandline, workingDir)
+    in_path(workingDir) { `#{commandline}` }
   end
 end