Piggy 0.4.2.2

data/lib/piggy-core/thumbnail_page_generator.rb

@@ -0,0 +1,542 @@
+#!/usr/bin/ruby
+# $Id: thumbnail_page_generator.rb 195 2008-05-29 21:32:40Z Sascha $
+
+require 'ftools'
+require 'piggy-core/environment'
+require 'piggy-core/htmlgen'
+require 'piggy-core/options'
+
+# ThumbnailPageGenerator generates html-pages for an internet picture
+# album. It does no image processing at all, this has to happen outside.
+#
+# Generation without frames:
+#
+#  outputPath
+#   |
+#   +----subDir
+#            |
+#            +----style
+#            |      |
+#            |      ...(stylesheet and background images)
+#            |
+#            +----index.htm
+#            |
+#            ...(3 files per image)
+#
+# The 3 files per image are:
+# - thumbnail image
+# - image
+# - image embedded in html with some basic navigation
+#
+# Generation with frames:
+#
+#  outputPath
+#   |
+#   +----subDir
+#   |        |
+#   |        +----index.htm
+#   |        |
+#   |        ...(3 files per image)
+#   |
+#   +----style
+#   |      |
+#   |      ...(stylesheet and background images)
+#   |
+#   +----index.htm
+#   |
+#   +----"#{subDir}.htm"
+#   |
+#   +----navigation.htm (updated)
+#   |
+#   +----kopf.htm
+#   |
+#   +----fuss.htm
+#
+# You may replace kopf.htm and fuss.htm by your own files.
+class ThumbnailPageGenerator < HtmlGenerator
+  
+  attr_reader(:client, :imageOutputPath, :indexName, :subDir)
+  attr_writer(:client)
+  
+  HtmlExt = '.htm'
+  DownloadName = "download.zip"
+  SlideshowName = "slideshow"
+  
+  def initialize(options)
+    @client = self
+    @options = options
+    @indexName = 'index' + HtmlExt
+  end
+  
+  def setOutputDirectory(outputDir)
+    @subDir = outputDir
+    @imageOutputPath = File.join(outputPath, 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)
+    type
+  end
+  
+  def imageName(info)
+    escapeHtml("#{info.nameWithoutExtension}.#{conversionTypeFor(info.extension)}")
+  end
+  
+  ##
+  # Set path to directory containing the original image files
+  def setInputDirectory(inputDir)
+    @inputDir = inputDir
+  end
+  
+  def setFiles(fileInfos)
+    @inputFilenames = fileInfos  
+  end
+  
+  def setTitle(title)
+    @title = title
+  end
+  
+  def sep
+    return "#{File::SEPARATOR}"
+  end
+  
+  def back
+    return "..#{sep}"
+  end
+  
+  def outputPath
+    return @options.localDestinationPath
+  end
+  
+  def mainIndexPath
+    return @options.generateFramePage ? outputPath : imageOutputPath
+  end
+  
+  def mainIndexWithPath
+    return mainIndexPath + sep + indexName
+  end
+  
+  def getBacklinkString
+    @options.generateFramePage? ? back + subDir + HtmlExt : indexName
+  end
+  
+  def subStylesheetUrl
+    if @options.generateFramePage?
+      back + mainStylesheetUrl
+    else
+      mainStylesheetUrl
+    end
+  end
+  
+  def mainStylesheetUrl
+    'style/style.css'
+  end
+  
+  # Add important meta tags
+  def commonHead
+    norobots()
+    # the next tag will tell Piggy that this file may be
+    # overwritten by Piggy
+    meta({
+      "name" => "generator",
+      "content" =>"Piggy"})
+    utf8()
+  end
+  
+  # Check if this file has been written by Piggy
+  def isPiggyFile?(file)
+    ret = false
+    File.open(file, 'r') { |fp|
+      while !ret && fp.gets
+        ret = true if(/<meta.*name="generator"/ && /<meta.*content="Piggy"/)
+      end
+    }
+    return ret
+  end
+  
+  def buildHtmlPagesForImages(progress)
+    progress.setTask("Generate html", @inputFilenames.size)
+    maxInd = @inputFilenames.size - 1
+    backlink = getBacklinkString
+     (0..maxInd).each { | i |
+      currentInfo = @inputFilenames[i]
+      predInfo = @inputFilenames[i == 0 ? maxInd : i - 1]
+      succInfo = @inputFilenames[i == maxInd ? 0 : i + 1]
+      current = currentInfo.nameWithoutExtension
+      comment = currentInfo.comment
+      pred = predInfo.nameWithoutExtension
+      succ = succInfo.nameWithoutExtension
+      progress.setProgress(current, 1)
+      newTransitional
+      html {
+        head {
+          title() { escapeHTML(current) }
+          commonHead
+          stylesheet subStylesheetUrl
+        }
+        body({"class"=>"image_page"}) {
+          a({"HREF" => escapeHTML(pred) + HtmlExt}){
+            addHtml(escapeHTML(i == 0 ? 'letztes' : 'voriges'))
+          }
+          a({"HREF" => escapeHTML(backlink) }) {
+            addHtml(escapeHTML('�bersicht'))
+          }
+          a({"HREF" => escapeHTML(succ) + HtmlExt}) {
+            addHtml(escapeHTML(i == maxInd ? 'erstes' : 'n�chstes'))
+          }
+          br
+          img(imageName(currentInfo), escapeHTML(current))
+          br
+          addHtml(escapeHTML(comment))
+        }
+      }
+      File.open(File.join(imageOutputPath, current + HtmlExt), 'w') { | fp |
+        fp.print(getPage)
+      }
+    }
+  end
+  
+  def buildSlideshowList(pathToImages = nil)
+    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], pathToImages)
+        fp.print("'#{current}'")
+        fp.print(i == maxInd ? "\n" : ",\n")
+      }
+      fp.print(")\n")
+    }
+    unless @inputFilenames.empty?
+      updateSlideshowTemplate(slideshowImage(@inputFilenames[1], pathToImages))
+    end
+  end
+
+  def slideshowImage(fileName, pathToImages = nil)
+    img = imageName(fileName)
+    if pathToImages
+      img = 'file:///' + File.join(WinShell.instance.rubyPath(pathToImages), img)
+    end
+    return img
+  end
+
+  def updateSlideshowTemplate(imageFile)
+    reset
+    file = File.join(imageOutputPath, 'slideshow.htm')
+    lines = File.readlines(file)
+    backlink = "href=\"#{getBacklinkString}\""
+    File.open(file, 'w') { |fp|
+      lines.each { |line|
+        line = line.gsub('PLACEHOLDER_FOR_IMAGE_NAME', imageFile)
+        line = line.gsub('href="index.htm"', backlink)
+        fp.print(line)
+      }
+    }
+  end
+  
+  def bytesAsString(bytes)
+    kb = bytes/1024
+    return "#{kb} KB" if kb < 1024
+    mb = kb/1024
+    return "#{mb} MB" if mb < 1024
+    gb = mb/1024
+    return  "#{gb} GB"
+  end
+  
+  def buildThumbnailPage(sizeOfZipfile = -1)
+    numCol = 5
+    matrix = Array.new(@inputFilenames.size() / numCol)
+    row = -1
+    col = 0
+    @inputFilenames.each { |info|
+      if col % numCol == 0
+        col = 0
+        row += 1
+        matrix[row] = Array.new(numCol) 
+      end
+      matrix[row][col] = info
+      col += 1
+    }
+    newTransitional
+    html() {
+      head() {
+        title() { @title }
+        commonHead()
+        stylesheet subStylesheetUrl
+      }
+      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
+	      }
+	    }
+	  }
+	}
+      }
+    }
+    File.open(File.join(imageOutputPath, indexName), 'w') { | fp |
+      fp.print(getPage) }
+  end
+
+  def imageTable(params, &block)
+    if @options.useTable?
+      table(params, &block)
+    else
+      dl(params, &block)
+    end
+  end
+
+  def imageRow(&block)
+     if @options.useTable?
+       tr({}, &block)
+     else
+       block.call
+     end
+  end
+
+  def imageColumn(&block)
+     if @options.useTable?
+       td({}, &block)
+     else
+       dd({}, &block)
+     end
+  end
+
+  def addPreview(info)
+    div({'class' => 'preview'}){
+      div({'class' => 'thumb'}){
+	p {
+	  name = escapeHtml(info.nameWithoutExtension)
+	  a({
+	      "href" => name + HtmlExt,
+	      'target' => '_top'}
+	    ) {
+	    img('t_'+ imageName(info), name)
+	  }
+	}
+      }
+    }
+  end
+  
+  def frameText()
+    newFrame
+    html(){
+      head(){
+        title { 'Bildindex' }
+        commonHead
+        stylesheet mainStylesheetUrl
+      }
+      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",
+            'frameborder'=>"0"
+          })
+          frame({
+            'src'=>"#{subDir + sep + indexName}",
+            'name'=>"Daten",
+            'frameborder'=>"0"
+          })
+        }
+        frame({
+          'src'=>"fuss.htm",
+          'name'=>"Fuss",
+          'scrolling'=>"no",
+          'frameborder'=>"0"
+        })
+        noframes(){
+          cr
+          addHtml('Ohne Frames siehe: ')
+          a({'href'=>"navigation.htm"}){
+            addHtml('Navigationsleiste')
+          }
+        }
+      }
+    }
+    return getPage
+  end
+  
+  def buildFramePage()
+    content = frameText
+    writeFile(File.join(outputPath, subDir + HtmlExt), content)
+    writeFile(File.join(outputPath, indexName), content)
+  end
+  
+  def writeFile(file, content)
+    return if File.exists?(file) && !isPiggyFile?(file)
+    File.open(file, 'w') { |fp| fp.print(content) }
+  end
+  
+  def buildZipfile(nameOfZipFile, progress)
+    require 'zip/zip'
+    progress.setTask("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)
+        entry = File.join(subDir, info.name)
+        src = info.nameWithPath
+        zipfile.add(entry, src) 
+      end
+    }
+  end
+  
+  def copyTemplateFiles()
+    if @options.generateFramePage
+      copyTemplates(['navigation.htm', 'kopf.htm', 'fuss.htm'],
+		    outputPath)
+      copyStyle(outputPath)
+    else
+      copyStyle(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)
+    end
+  end
+
+  def styleSourceDir
+    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))
+    }
+  end
+  
+  def copyTemplates(files, targetPath)
+    files.each do
+      |fName|
+      unless File.exists?(File.join(targetPath, fName))
+        templateFile = File.join(PIGGY_PATH, 'templates', fName)
+        File.copy(templateFile, targetPath) 
+      end
+    end
+  end
+  
+  # Insert insertion into file after any match of pattern
+  def insertInFile(file, pattern, insertion)
+    lines = File.readlines(file)
+    File.open(file, 'w') { |fp|
+      lines.each { |line|
+        fp.print(line)
+        fp.print(insertion) if line =~ pattern
+      }
+    }
+  end
+
+  def updateNavigationFrame()
+    reset
+    navFile = File.join(outputPath, 'navigation.htm')
+    a({
+      'href' => escapeHtml(subDir) + '/index.htm',
+      'target' => 'Daten'}) {
+      addHtml(escapeHTML(@title))
+    }
+    br
+    addHtml("\n")
+    link = getPage
+    insertInFile(navFile, /<!--NAV-->/, link) 
+  end
+  
+  def error msg
+    puts "Error: #{msg}"
+    return false
+  end
+  
+  ##
+  # 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)
+  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")
+    end
+    unless File.directory?(outputPath)
+      return error("#{outputPath} ist no directory}")
+    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)
+    end
+    buildHtmlPagesForImages(progress)
+    buildThumbnailPage(sizeOfZipfile)
+    copyTemplateFiles
+    buildSlideshowList if @options.addSlideshow?
+    if @options.generateFramePage?
+      buildFramePage
+      updateNavigationFrame
+    end
+    imageProcessing(progress)
+    return true
+  end
+
+  # This method will create an adhoc slideshow in the
+  # imageOutputPath without copying any image
+  # Just for testing issues
+  # Works fine if all the images allready have appropriate size
+  def onTheFlySlideshow
+    unless File.directory?(File.join(outputPath, subDir))
+      createSubdir
+    end
+    copyTemplates(['slideshow.htm', 'slideshow.js'], imageOutputPath)  
+    buildSlideshowList(@inputDir)
+    return File.join(imageOutputPath, 'slideshow.htm')
+  end
+  
+  protected
+  
+  ##
+  # Overwrite this hook method to add image processing
+  # to html genmeration
+  def imageProcessing(&block)
+  end
+  
+  ##
+  # Service which migt be useful if no client is set 
+  def runCommand(commandline, workingDir)
+    inPath(workingDir) { `#{commandline}` }
+  end
+end

data/lib/piggy-core/upload_info.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/ruby
+#$Id: file_info.rb 181 2007-12-12 23:33:46Z Sascha $
+
+# This file is used to compute byte sizes of
+# a set of given files and directories.
+# The size of directories is computed recursively.
+class UploadInfo
+  attr_reader(:bytes, :numFiles, :bytesHash)
+  
+  def initialize(filesWithPath)
+    @bytesHash = Hash.new
+    @bytes = 0
+    @numFiles = 0
+    add(filesWithPath)
+  end
+  
+  private
+
+  def add(filesWithPath)
+    filesWithPath.each do |fileWithPath|
+      unless @bytesHash.has_key?(fileWithPath)
+	if File.directory?(fileWithPath)
+	  subfiles = Dir.entries(fileWithPath).reject { |e|
+	    e =~ /^\./
+	  }
+	  subfilesWithPath = subfiles.collect { |e|
+	    FilePath.join(fileWithPath, e)
+	  }
+	  add(subfilesWithPath)
+	else
+	  fileSize = File.size(fileWithPath)
+	  @bytesHash[fileWithPath] = fileSize
+	  @bytes = @bytes + fileSize
+	  @numFiles = @numFiles + 1
+	end
+      end
+    end
+  end
+end
+
+

data/lib/piggy-core/version.rb

@@ -0,0 +1,18 @@
+#!/usr/bin/ruby
+#$Id: version.rb 195 2008-05-29 21:32:40Z Sascha $
+
+# Provide release information for Piggy.
+module PiggyVersion
+  def PiggyVersion.versionString
+    '0.4.2-2'
+  end
+  def PiggyVersion.copyrightString
+    'Copyright (C) 2008 Sascha D�rdelmann'
+  end
+  def PiggyVersion.developmentStatus
+    'alpha'
+  end
+  def PiggyVersion.displayString
+    "#{PiggyVersion.versionString} (#{PiggyVersion.developmentStatus})"
+  end
+end