gf-ralbum 0.0.2

data/lib/ralbum/cli/cli_ralbum.rb

@@ -0,0 +1,116 @@
+# stdlib
+require 'rubygems'
+require 'digest/md5'
+require 'rexml/document'
+require 'yaml'
+require 'pp'
+require 'optparse'
+require 'ostruct'
+require 'fileutils'
+
+# ralbum
+require 'tree_visitor/dir_tree_walker'
+require 'tree_visitor/tree_node_visitor'
+require 'ralbum/options'
+require 'ralbum/photo_tree_builder'
+require 'ralbum/catalog'
+require 'ralbum/generate_album_tree_node_visitor'
+require 'ralbum/skin_manager'
+require 'ralbum/project'
+
+class CliRAlbum
+
+  def self.run
+    self.new.parse_args( ARGV )
+  end
+  
+  def parse_args( argv )
+
+    skin_manager = SkinManager.new
+
+    $options = OpenStruct.new
+    $options.force = false
+    $options.verbose = 0
+    $options.inputfilter = "rubyalbum"
+    $options.list_skins = false
+    $options.skins = [ "gfold" ]
+    $options.inctemplate = nil
+
+    options = OptionParser.new do |opts|
+      opts.banner =
+        "Usage: #{File.basename($0)} <photo tree directory> <album tree directory>\n" +
+        "Create albums from a phototree"
+
+      opts.on("-f", "--force", "force the creation of directory") {
+        $options.force = true
+      }
+      opts.on("-v", "--verbose [NUM]", Integer, "verbosity level") { |num|
+        if num.nil?
+          $options.verbose = 1
+        else
+          $options.verbose = num
+        end
+      }
+      opts.on("-i", "--ifilter STRING", String, "input filter (phototree)" ) { |arg|
+        $options.inputfilter = arg
+      }
+      opts.on("-l", "--list-skins", "show a list of skins") { |arg|
+        puts "Available skins:"
+        puts skin_manager.describe_skins
+        exit 0
+      }
+      opts.on("-s", "--skin x,y,z", Array, "skin(s)") { |arg|
+        $options.skins = arg
+      }
+      opts.on("--inc STRING", String, "includes kwarts template" ) { |arg|
+        $options.inctemplate = arg
+      }
+      opts.on("--help", "-h", "help!") {
+        puts opts
+        exit 0
+      }
+    end
+    options.parse!(argv)
+    
+    if ARGV.length < 2
+      puts options
+      exit 1
+    end
+
+    phototree_dirname = argv[0]
+    album_dirname = argv[1]
+
+
+    $options.skins.each do |skin_name|
+      unless skin_manager.has_skin?(skin_name)
+        puts "skin:  #{skin_name} not exists"
+        exit 1
+      end
+    end
+
+    if not File.directory?( phototree_dirname )
+      puts "phototree_dir '#{phototree_dirname}' not exists or is not a directory"
+      exit 1
+    end
+    
+    if not File.directory?( album_dirname )
+      if $options.force
+        ralbum_verbose(1, "creating album_dir #{album_dirname}")
+        FileUtils.mkdir_p( album_dirname )
+      else
+        puts "albums_dir '#{album_dirname}' not exists or is not a directory"
+        puts "use -f to force the creation of directory"
+        exit 1
+      end
+    end
+    
+    phototree_dirname = File.expand_path( phototree_dirname )
+    album_dirname = File.expand_path( album_dirname )
+    project = Project.new(skin_manager)
+    project.phototree_dirname = phototree_dirname
+    project.album_dirname     = album_dirname
+    project.skin_names        = $options.skins
+    project.run
+  end
+  
+end

data/lib/ralbum/generate_album_tree_node_visitor.rb

@@ -0,0 +1,60 @@
+require 'rubygems'
+
+# ralbum
+require 'tree_visitor/tree_node_visitor'
+require 'ralbum/album'
+require 'ralbum/image_pool'
+require 'ralbum/image_file'
+
+class GenerateAlbumTreeNodeVisitor
+    
+  def initialize( album_dirname, catalog, image_strategies )
+    @album_dirname = album_dirname
+    @catalog = catalog
+    @image_strategies = image_strategies
+  end
+    
+  def run( photoTree )
+    ralbum_verbose( 1, "generate albumtree" )
+    ralbum_verbose( 1, "create images" )
+    visitor = CallbackTreeNodeVisitor2.new
+
+    visitor.onEnterTreeNode { |photoNode, parentAlbumNode|
+      album_key   = @catalog.album_key( photoNode.path_from_root )
+      album_title = photoNode["title"]
+      album_desc  = photoNode["shortdesc"]
+      albumNode   = Album.new( parentAlbumNode, album_key, album_title, album_desc )
+    }
+
+    visitor.onVisitLeafNode{ |photoItem, parentAlbumNode|
+      photo_key   = @catalog.key( photoItem.md5 )
+      photo_title = photoItem[ "title" ]
+      photo_desc  = photoItem[ "description" ]
+      imagePool   = ImagePool.new( parentAlbumNode, photoItem.md5, photo_key, photo_title, photo_desc )
+      msg = ""
+      @image_strategies.each_pair {|name,image_strategy|
+        image_basename = @catalog.photo_file( photoItem )
+        inpath = photoItem.path
+        outdir = File.join( @album_dirname, "images_" + image_strategy.name )
+        outpath = File.join( outdir, image_basename )
+        msg += "#{name} "
+        if File.exist?(outpath) and File.mtime(inpath) < File.mtime(outpath)
+          msg += "(s) "
+        else
+          Dir.mkdir( outdir ) unless File.exist?( outdir )
+          msg += image_strategy.build( inpath, outpath )
+        end
+          
+        # imagePool.thumb            = ImageFile.new( imagePool, @albums_dirname, "images_100x100/" + basename )
+        # imagePool.defaultImageFile = ImageFile.new( imagePool, @albums_dirname, "images_640x480/" + basename, basename + ".html")
+        image = ImageFile.new( imagePool, outpath, image_basename + ".html" )
+        imagePool.image( name, image )
+      }
+      ralbum_verbose( 2, sprintf("%40s: %s \n", photoItem.basename, msg ) )
+    }
+
+    photoTree.accept( visitor )
+    visitor.root
+  end
+    
+end

data/lib/ralbum/image_file.rb

@@ -0,0 +1,81 @@
+#gems
+require 'rubygems'
+require 'RMagick'
+require 'image_size'
+
+class ImageFile
+  
+  attr_reader   :imagePool
+
+  #
+  # url of image
+  #
+  # attr_reader   :url
+
+  #
+  # url of html page displaying the image
+  #
+  attr_reader :pageurl
+
+  attr_reader :size, :width, :height
+
+  def initialize( imagePool, path, pageurl)
+    @imagePool = imagePool
+    @pageurl       = pageurl
+
+    @size = File.size( path )
+    @size = @size / 1024
+
+    if not File.exist?(path)
+      raise RAlbumException.new "file '#{path}' not exist"
+    end
+    if File.directory?(path)
+      raise RAlbumException.new "expected '#{path}' as file but it is a directory"
+    end
+
+    blob = File.open(path, "rb") do |f|
+      f.read
+    end    
+    image = Magick::ImageList.new
+    image.from_blob( blob )
+    @width  = image.columns
+    @height = image.rows
+  end 
+  
+  def name
+    @imagePool.name
+  end
+  
+  def description
+    @imagePool.description
+  end
+  
+  def relroot
+    @imagePool.relroot
+  end
+  
+  def relroot_with_prefix
+    @imagePool.relroot_with_prefix
+  end
+  
+  def breadcrumbs
+    @imagePool.breadcrumbs
+  end
+      
+  def prev_pageurl
+    if @imagePool.prev  
+      @imagePool.prev.defaultImageFile.pageurl 
+    else 
+      nil 
+    end
+  end
+  
+  def next_pageurl
+    if @imagePool.next        
+      @imagePool.next.defaultImageFile.pageurl 
+    else 
+      nil
+    end      
+  end
+
+end

data/lib/ralbum/image_pool.rb

@@ -0,0 +1,71 @@
+# ralbum
+require 'tree_visitor/leaf_node'
+  
+#
+# ImagePool e' creata da una PhotoItem identificata da un md5
+# ImagePool ha una 'key' con cui viene identificata nel catalog
+# ha un 'title' che e' anche il 'name' del LeafNode
+# ha una 'description' della photo che rappresenta
+#
+class ImagePool < LeafNode
+  # include ObjectWithProperties
+    
+  #
+  # md5 of original photo
+  #
+  attr_reader   :md5
+    
+  #
+  # key (number) assigned by catalog for the original photo
+  #
+  attr_reader   :key
+
+  # title -> name
+  attr_reader   :description
+
+  def initialize( album, md5, key, title, description )
+    super( title, album )
+    @md5 = md5
+
+    @key = key
+    @album = album
+    @description = description
+
+    @images = {}
+  end
+    
+  def relroot
+    parent.relroot
+  end
+    
+  def relroot_with_prefix
+    parent.relroot_with_prefix
+  end
+    
+  def breadcrumbs
+    parent.breadcrumbs
+  end
+    
+  def image( type, image_file = nil)
+    if image_file
+      @images[ type ] = image_file
+    end
+    res = @images[ type ]
+    if res.nil?
+      raise "image type '#{type}' of photo '#{name}' not found"
+    end
+    res
+  end
+
+  def defaultImageFile
+    image("default")
+  end
+
+  def to_s
+    str = "ip: #{name.to_s} -#{@images.length}-"
+    @images.each_key { |key| str += key.to_s }
+    str
+  end
+    
+end
+    

data/lib/ralbum/image_strategy.rb

@@ -0,0 +1,143 @@
+# stdlib
+require "fileutils"
+
+# gems
+require 'rubygems'
+require 'RMagick'
+
+#
+# Strategy for build a scaled image
+#
+class ScaledImageStrategy
+
+  attr_reader :name, :width, :height, :quality
+
+  def initialize( name, width, height, quality )
+    @name = name
+    @width = width
+    @height = height
+    @quality = quality
+  end
+
+  #
+  # build a scaled image and store it in outpath
+  #
+  # inpath source image file
+  # outpath destination image file
+  #
+  def build( inpath, outpath )
+    # TODO: ritornare un risultato per es. 1 = skipped 2 = copiato 3 = scalata immagine
+    result_msg = ""
+    img = Magick::ImageList.new(inpath)
+    
+    if @width > img.columns and @height > img.rows
+      result_msg = "(c) "
+      # FileUtils.cp( inpath, outpath )
+      # rimuovere i metadata
+    else
+      result_msg = "(#{@quality}%) "
+      img.resize_to_fit!(@width, @height) 
+    end
+    img.profile!('*', nil)
+
+    img.write(outpath) {|i| i.quality = quality }
+    result_msg
+  end
+  
+  def write_xml( xml_iss )
+    xml_is = xml_iss.add_element( "image_strategy")
+    xml_is.attributes["name"] = self.class.to_s
+    xml_par = xml_is.add_element("par")
+    xml_par.attributes["width"] = @width.to_s
+    xml_par.attributes["height"] = @height.to_s
+    xml_par.attributes["quality"] = @quality.to_s
+  end
+  
+end
+
+#
+# Strategy for build a scaled image
+#
+class SepiaScaledImageStrategy
+
+  attr_reader :name, :width, :height, :quality
+
+  def initialize( name, width, height, quality )
+    @name = name
+    @width = width
+    @height = height
+    @quality = quality
+  end
+
+  #
+  # build a scaled image and store it in outpath
+  #
+  # inpath source image file
+  # outpath destination image file
+  #
+  def build( inpath, outpath )
+    # TODO: ritornare un risultato per es. 1 = skipped 2 = copiato 3 = scalata immagine
+    result_msg = ""
+    img = Magick::ImageList.new(inpath)
+    
+    if @width > img.columns and @height > img.rows
+      result_msg = "(c) "
+      # FileUtils.cp( inpath, outpath )
+      # rimuovere i metadata
+    else
+      result_msg = "(#{@quality}%) "
+      img.resize_to_fit!(@width, @height) 
+    end
+    img = img.sepiatone
+    img.profile!('*', nil)
+
+    img.write(outpath) {|i| i.quality = quality }
+    result_msg
+  end
+  
+  def write_xml( xml_iss )
+    xml_is = xml_iss.add_element( "image_strategy")
+    xml_is.attributes["name"] = self.class.to_s
+    xml_par = xml_is.add_element("par")
+    xml_par.attributes["width"] = @width
+    xml_par.attributes["height"] = @height
+    xml_par.attributes["quality"] = @quality      
+  end
+  
+end
+
+#
+# Create a link from inpath to outpath
+#
+class LinkedImageStrategy
+
+  attr_reader :name
+
+  def initialize( name )
+    @name = name
+  end
+
+  def build( inpath, outpath )
+    return if File.exist?( outpath )
+    ralbum_verbose( 1, "link " )
+    File.symlink( inpath, outpath )
+  end
+
+end
+
+#
+# Copy an image from inpath to outpath
+#
+class CopyImageStrategy
+  attr_reader :name
+
+  def initialize( name )
+    @name = name
+  end
+
+  def build( inpath, outpath )
+    FileUtils.cp( inpath, outpath )
+  end
+
+end
+