Piggy 0.4.2.2

data/lib/piggy-core/alive_check.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env ruby
+
+require 'timeout'
+
+# This class works similar to a timeout.
+# Run it like this:
+#
+#   x = AliveCheck(10)
+#   begin
+#     x.check { ... x.alive! ... }
+#   rescue Timeout::Error => msg
+#     ...
+#   end
+#
+# If x doesn't get an alive! notification for
+# 10 to 20 seconds, it will raise a Timeout::Error
+class AliveCheck
+  def initialize(check_interval_sec, ex_msg = 'execution expired')
+    @sec = check_interval_sec
+    @alive = false
+    @ex_msg = ex_msg
+  end
+
+  def check
+    checked_thread = Thread.current
+    @alive = true
+    aliveChecker = Thread.new {
+      while(@alive) do
+	@alive = false
+	sleep(@sec)
+      end
+      checked_thread.raise(Timeout::Error, @ex_msg) if checked_thread.alive?
+    }
+    begin 
+      yield
+    ensure
+      aliveChecker.kill if aliveChecker and aliveChecker.alive?
+    end
+  end
+
+  def alive!
+    @alive = true
+  end
+end

data/lib/piggy-core/debug.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+
+# Global methods temporaryly used for debugging.
+# Inspired by the book
+# "Programmieren mit Ruby" by R�hrl/Schmiedl/Weyss"
+
+def beginTrace
+  $stderr.puts "Begin Trace in: #{caller.first}"
+  set_trace_func proc {
+    |event, file, line, id, binding, classname|
+    unless File.basename(file) == 'debug.rb'
+      $stderr.printf("%8s %s-, %-2d %10s %8s\n",
+      event, file, line, id, classname)
+    end
+  }
+end
+
+def endTrace
+  $stderr.set_trace_func(nil)
+  puts "End Trace in: #{caller.first}"
+end

data/lib/piggy-core/encoding.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/ruby
+# $Id: require-fox.rb 188 2007-12-16 14:10:39Z Sascha $
+
+def utf8_as_string(aString)
+  return aString.unpack("U*").pack("C*")
+end
+
+def string_as_utf8(aString)
+  aString.unpack("C*").pack("U*")
+end
+

data/lib/piggy-core/environment.rb

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+
+# Require this file will set global constants to appropriate values:
+# 
+# - PIGGY_PATH points to piggy's lib directory.
+# - RMAGICK_AVAILIABLE will be true if RMagick is installed
+# 
+# The standard method is to find the installed gem and let
+# PIGGY_PATH point to the subdirectory lib.
+#
+# If the gem isn't found, we assume that piggy has been started
+# from within the lib directory itself and therefore set
+# PIGGY_PATH = '.'. (This is often the case during development.)
+#
+# Note that PIGGY_PATH uses the Ruby notation of the path.
+#
+# So, what ist this good for? We'll find all resource files,
+# icons or other user-independent configuration files using
+# paths relative to PIGGY_PATH.
+
+begin
+  require 'rubygems'
+  require 'piggy-core/version.rb'
+  
+  # Try to find lib directory of this specific Piggy gem version
+  def findPiggyDirectory
+    puts "Checking $LOAD_PATH"
+    $LOAD_PATH.each do
+      |d|
+      if /piggy.lib$/ =~ d
+        return d.gsub(/\\/, '/')
+      end
+    end
+    puts "Checking Gems"
+    piggyGemDir = "Piggy-#{PiggyVersion.versionString.gsub(/-/, '.')}"
+    all = Gem::path.collect { |gempath|
+      File.join(gempath, 'gems', piggyGemDir)
+    }.select { |f|
+      File.directory?(f)
+    }
+    return all.empty? ? '.' : File.join(all.first, 'lib')
+  end
+  PIGGY_PATH = findPiggyDirectory
+  puts "Successfully detecting piggy gem lib in #{PIGGY_PATH}"
+rescue LoadError
+  PIGGY_PATH = '.'
+end
+
+# Temporary change working dir while executing a given block
+# (depriciated)
+def inPath(path, &block)
+  workingDirSik = Dir.getwd
+  begin
+    Dir.chdir(path)
+    block.call
+  ensure
+    Dir.chdir(workingDirSik)
+  end
+end
+
+begin
+  require 'RMagick'
+  RMAGICK_AVAILIABLE = true
+rescue LoadError
+  RMAGICK_AVAILIABLE = false
+end

data/lib/piggy-core/exifr_adapter.rb

@@ -0,0 +1,85 @@
+#!/usr/bin/env ruby
+#$Id: options.rb 177 2007-11-21 21:59:52Z Sascha $
+
+require 'exifr'
+
+# This adapter is used as an additional
+# layer between Piggy and EXIFR.
+class ExifrAdapter
+  def initialize(file)
+    @exif = loadExif(file)
+  end
+
+  def exif?
+    @exif && @exif.exif?
+  end
+
+  def to_s
+    return 'no exif' unless exif?
+    desc = "Exif:\n\t"
+    h = @exif.exif.to_hash
+    desc += h.keys.collect { |k| "#{k.to_s}: #{h[k].to_s}" }.join("\n\t")
+    return desc
+  end
+
+  def viewDegrees
+    return 0 unless exif?
+    orientation = @exif.exif[:orientation]
+    return 0 if orientation.nil?
+    imageMock = ExifrDegreeComuter.new
+    orientation.transform_rmagick(imageMock)
+    return imageMock.degree
+  end
+
+  def width
+    exif? ? @exif.width : 0
+  end
+
+  def height
+    exif? ? @exif.height : 0
+  end
+
+  private
+
+  def loadExif(file)
+    if(hasExtension?(file, 'jpg'))
+      EXIFR::JPEG.new(file)
+    elsif(hasExtension?(file, 'tif'))
+      EXIFR::TIFF.new(file)
+    else
+      nil
+    end
+  end
+
+  def hasExtension?(filename, ext)
+    File.basename(filename.upcase, ext.upcase) !=
+    File.basename(filename.upcase)
+  end
+end
+
+# Simulate rmagick image to compte degree instead
+# of rotate.
+class ExifrDegreeComuter
+  attr_reader(:degree)
+
+  def initialize
+    @degree = 0
+  end
+  
+  def flop
+  end
+
+  def flip
+  end
+
+  def rotate(degree)
+    @degree = degree
+    self
+  end
+end
+
+class EXIFR::TIFF::Orientation
+  def to_s
+    @value.to_s + ' (' + @type.to_s + ')'
+  end
+end

data/lib/piggy-core/file_info.rb

@@ -0,0 +1,218 @@
+#!/usr/bin/ruby
+#$Id: file_info.rb 195 2008-05-29 21:32:40Z Sascha $
+
+# Provides classes to hold some information for single files,
+# directory contents and multiple files at different locations.
+
+# Some utility methods for path handling.
+module FilePath
+  
+  # Ruby path notation for a given operation system/file system
+  # specific path
+  def FilePath.internPath(pathString)
+    return '' unless pathString
+    newPath = pathString.gsub(/\\/, File::SEPARATOR)
+    return newPath =~ /:$/ ? newPath + File::SEPARATOR : newPath
+  end
+  
+  # Just as File.join but handles at least one possible error.
+  #
+  # ===Example
+  #
+  #  FilePath.join('bla/', '/blubb') # => 'bla/blubb'
+  def FilePath.join(string1, string2)
+    return string2 unless string1 && !string1.empty?
+    return string1 unless string2 && !string2.empty?
+    noLeadingSeps2 = string2.sub(Regexp.compile("#{File::SEPARATOR}*"), '')
+    return File.join(string1, noLeadingSeps2)
+  end
+  
+  # Sections of a given pathString
+  def FilePath.split(pathString)
+    pathString.split(File::SEPARATOR)
+  end
+  
+  # Removes the last section of a given pathString.
+  # Won't remove a section of a file system root.
+  # Possible roots are '/', 'C:', 'X:/', ...
+  def FilePath.oneDirUp(pathString)
+    return '' unless pathString
+    sections = FilePath.split(pathString)
+    return '' unless sections || !sections.empty?
+    if sections.size == 1
+      return pathString if pathString =~ /:/
+      return pathString if pathString == '/'
+      return ''
+    end
+    return '' unless sections[-1]
+    numOfCharsToStrip = sections[-1].size + 2
+    return FilePath.internPath(pathString[0..-numOfCharsToStrip])
+  end
+end
+
+# Every String could be a Filename but we want
+# a class containing name and path to make some things
+# more explicit.
+class FileName
+  attr_accessor(:name)
+  attr_reader(:path)
+  
+  def initialize(theName, thePath = '')
+    @name = theName
+    setPath(thePath)
+  end
+  
+  def path=(newPath)
+    setPath(newPath)
+  end
+  
+  def setPath(newPath)
+    @path = FilePath.internPath(newPath)
+  end
+  
+  def nameWithPath
+    return FilePath.join(path, name)
+  end
+  
+  def nameWithoutExtension
+    return File.basename(name, '.' + extension)
+  end
+  
+  def extension
+    return name.split('.')[-1]
+  end
+  
+  def pathSections
+    return FilePath.split(path)
+  end
+end
+
+# An entity object where you can set all attributes no matter
+# if (or where) the file exists. Next to a name and path it
+# has further attributes such as a creation and a modification
+# time and a size in bytes. New instances aren't directories by
+# default but you can set this flag, too.
+class FileInfo < FileName
+  attr_accessor(:size, :mtime, :ctime)
+  
+  def initialize(theName, thePath = '')
+    super(theName, thePath)
+    @size = 0
+    @isDirectory = false
+  end
+  
+  def directory?
+    return @isDirectory
+  end
+  
+  def directory!
+    @isDirectory = true
+  end
+  
+  def mtimeString
+    timeStringFor(mtime)
+  end
+  
+  def ctimeString
+    timeStringFor(ctime)
+  end
+  
+  protected
+  
+  def timeStringFor(time)
+    return 'unknown' unless time
+    time.strftime("%m/%d/%Y at %I:%M%p")
+  end
+end
+
+class CommentedFile < FileInfo
+  attr_accessor(:comment, :rotation, :width, :height)
+
+  def initialize(theName, thePath = '', theComment = '')EXIFR
+    super(theName, thePath)
+    @comment = theComment
+    @rotation = 0
+    @width = 0
+    @height = 0
+  end
+
+  def rotate?
+    @rotation && @rotation != 0
+  end
+end
+
+# An unordered list of FileInfos, accessible by name.
+# The directory location is stored as a path-String.
+class DirectoryContents
+  attr_accessor(:path)
+  
+  def initialize(thePath = '')
+    @path = thePath
+    @contents = Hash.new
+  end
+  
+  def add(aFileName)
+    @contents[aFileName.name] = aFileName
+  end
+  
+  def []=(aName, info)
+    @contents[aName] = info
+  end
+  
+  def get(aFileName)
+    return @contents[aFileName.name]
+  end
+  
+  def at(aName)
+    return @contents[aName]
+  end
+  
+  def [](aName)
+    return @contents[aName]
+  end
+  
+  alias has_key? []
+  
+  def keys
+    return @contents.keys
+  end
+  
+  def directories
+    return @contents.keys.select { |k| @contents[k].directory? }.sort
+  end
+  
+  def files
+    return @contents.keys.reject { |k| @contents[k].directory? }.sort
+  end
+end
+
+# A unordered list of FileInfos accessible by FileName.
+# (Which means that you need both, path and name, to store
+# the info in the repository. Unless DirectoryContents these
+# files do not need to have a common location.)
+class FileRepository
+  def initialize
+    @repository = Hash.new
+  end
+  
+  def add(aFileName)
+    self[aFileName] = aFileName
+  end
+  
+  def []=(aFileName, info)
+    hashOrNil =  @repository[aFileName.path]
+    if hashOrNil == nil
+      hashOrNil = Hash.new
+      @repository[aFileName.path] = hashOrNil
+    end
+    hashOrNil[aFileName.name] = info
+  end
+  
+  def get(aFileName)
+    subHash = @repository[aFileName.path]
+    return subHash == nil ? nil : subHash[aFileName.name]
+  end
+  alias [] get
+  alias has_key? get
+end
+

data/lib/piggy-core/ftp_adapter.rb

@@ -0,0 +1,106 @@
+#!/usr/bin/env ruby
+
+require 'timeout'
+require 'net/ftp'
+require 'piggy-core/alive_check'
+require 'piggy-core/options'
+
+# This is a wrapper around Net::FTP. It has a different interface
+# and introduces two additional timeouts. Configure the timeouts
+# and other parameters through PiggyOptions.
+class FtpAdapter
+
+  attr_accessor(:host, :user, :password)
+
+  def initialize(options)
+    @connection = nil
+    @options = options # some options may change any time
+  end
+
+  def connect(host, user, password)
+    cTimeout { @connection = Net::FTP.open(host, user, password) }
+    @connection.debug_mode = @options.debug
+  end
+
+  def chdir(path)
+    if path && !path.empty?
+      cTimeout { @connection.chdir(path) }
+    end
+  end
+
+  def nlst
+    cTimeout { @connection.nlst }
+  end
+
+  def info(file, path)
+    info = FileInfo.new(file, path)
+    begin
+      mtime = cTimeout {
+	@connection.mtime(file, @options.ftpHasLocaltime?)
+      }
+      mtime = mtime.localtime unless @options.ftpHasLocaltime?
+      info.mtime = mtime
+    rescue Net::FTPError
+      info.directory!
+    end
+    info
+  end
+
+  def mkdir(dir)
+    cTimeout { @connection.mkdir(dir) }
+  end
+
+  def delete(file)
+    cTimeout { @connection.delete(file) }
+  end
+
+  # Upload with progress events.
+  #
+  # Example:
+  #   upload('C:\tmp\bla\big.zip', 'C:\tmp') {
+  #     |data|
+  #     ...
+  #     data.size
+  #     ...
+  #   }
+  # This will create a remote file bla/big.zip
+  # and every chunk of transferred data will
+  # be given to the block.
+  def upload(localPath, file, &block)
+    depthOffset = FilePath.split(localPath).size
+    pathSections = FilePath.split(file)
+    dirs = pathSections[depthOffset..-2]
+    unless dirs == nil
+      dirs.each do
+	|dir|
+	begin
+	  chdir(dir)
+	rescue Net::FTPError
+	  mkdir(dir)
+	  chdir(dir)
+	end
+      end
+    end
+    aliveChecker = AliveCheck.new(@options.ftpTransferTimeout,
+				  "ftp transfer timeout")
+    aliveChecker.check do 
+      @connection.putbinaryfile(file) { |data|
+	aliveChecker.alive!
+	block.call(data)
+      }
+    end
+    unless dirs == nil
+      dirs.each { |dir| chdir('..') }
+    end
+  end
+
+  def close
+    @connection.close unless @connection.nil?
+  end
+
+  private
+
+  def cTimeout(&block)
+    timeout(@options.ftpConnectionTimeout, &block)
+  end
+end