gf-ralbum 0.0.2 → 0.0.5

data/lib/ralbum.rb

@@ -1,19 +1,23 @@
 class Ralbum
-  VERSION = '0.0.1'
+  VERSION = '0.0.5'
 end
 
 #
 # Check dependecies
 #
 require 'rubygems'
+
+
+# gem 'treevisitor', '~> 3.0'
+
 begin
-  require 'tree_visitor'
+  require 'treevisitor'
 rescue LoadError
-  abort 'tree_visitor gem required!!'
+  abort 'treevisitor gem required!!'
 end
 
 begin
-  require 'image_size'
+  require 'RMagick'
 rescue LoadError
-  abort 'imagesize gem required!!' 
+  abort 'rmagick required!!'
 end

data/lib/ralbum/album_tree/album.rb

@@ -0,0 +1,74 @@
+# treevisitor
+require 'treevisitor/tree_node'
+
+#
+# subalbum -> childs
+# leaves -> photos o image_pools
+#
+class Album < TreeNode
+  
+  attr_reader   :key
+  attr_reader   :description
+
+  def initialize( parent, key, title, description )
+    super( title, parent )
+
+    @key = key
+    @description = description
+    @default_image_pool = nil
+  end
+
+  ############################################################################
+  # paths
+  #
+
+  def relroot
+    "../" * depth
+  end
+  
+  def relroot_with_prefix
+    if root.prefix_path
+      root.prefix_path + relroot
+    else
+      relroot
+    end
+  end
+
+  def page_url_from_root
+    File.join( path, "index.html" ) 
+  end
+  
+  def page_url
+    File.join( name, "index.html" )       
+  end
+
+  def breadcrumbs
+    h = { :title => name, :path => page_url_from_root }
+    if parent
+      parent.breadcrumbs <<  h
+    else
+      [ h ]
+    end
+  end
+
+  ###########################################################################
+
+  def default_image_pool
+    return @default_image_pool unless @default_image_pool.nil?
+    if leaves.length > 0
+      @default_image_pool = leaves[0]
+    elsif childs.length > 0
+      @default_image_pool = childs[0].default_image_pool
+    end
+    if @default_image_pool.nil?
+      msg =  "cannot determine defaultphoto for album #{title} #{reldir} #{@leaves.length} #{@childs.length}"
+      raise msg
+    end
+    @default_image_pool
+  end
+
+  def to_s
+    "a: #{name.to_s}"
+  end
+  
+end 

data/lib/ralbum/album_tree/generate_album_tree_node_visitor.rb

@@ -0,0 +1,73 @@
+#treevisitor
+require 'treevisitor/tree_node_visitor'
+require 'treevisitor/visitors/callback_tree_node_visitor2'
+
+# ralbum
+require 'ralbum/album_tree/album'
+require 'ralbum/album_tree/image_pool'
+require 'ralbum/album_tree/image_file'
+
+
+class GenerateAlbumTreeNodeVisitor < CallbackTreeNodeVisitor2
+    
+  def initialize( album_dirname, catalog, image_strategies )
+    super()
+    @album_dirname = album_dirname
+    @catalog = catalog
+    @image_strategies = image_strategies
+
+    # TODO: eliminare le seguenti chiamate, trovare il visitor giusto da cui ereditare
+    on_enter_tree_node do |photo_tree_node, parentAlbumNode|
+      _on_enter_tree_node photo_tree_node, parentAlbumNode
+    end
+
+    on_visit_leaf_node do |photo_item, parent_album_node|
+      _on_visit_leaf_node photo_item, parent_album_node
+    end
+  end
+
+  def run( photo_tree )
+    ralbum_verbose( 1, "generate albumtree" )
+    ralbum_verbose( 1, "create images" )
+    photo_tree.accept( self )
+    root
+  end
+
+  def _on_enter_tree_node(photo_tree_node, parent_album_node)
+    album_key   = @catalog.album_key( photo_tree_node.path )
+    album_title = photo_tree_node.name    # instead of photo_tree_node["title"]
+    album_desc  = photo_tree_node["shortdesc"]
+    albumNode   = Album.new( parent_album_node, album_key, album_title, album_desc )
+  end
+
+  def _on_visit_leaf_node(photo_item, parent_album_node)
+    photo_key   = @catalog.key( photo_item.photo_file.md5 )
+    photo_title = photo_item.title
+    photo_desc  = photo_item.description
+    image_pool   = ImagePool.new( parent_album_node, photo_item.photo_file.md5, photo_key, photo_title, photo_desc )
+    msg = ""
+
+    @image_strategies.each_pair {|name,image_strategy|
+      image_basename = @catalog.photo_file( photo_item )
+
+      inpath = photo_item.photo_file.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
+
+      src_url  = File.join(image_pool.relroot_with_prefix, "images_" + image_strategy.name, image_basename)
+      image = ImageFile.new( image_pool, outpath, src_url, image_basename + ".html" )
+
+      image_pool.image( name, image )
+    }
+    ralbum_verbose( 2, sprintf("%40s: %s \n", photo_item.basename, msg ) )
+  end
+
+end

data/lib/ralbum/album_tree/image_file.rb

@@ -0,0 +1,88 @@
+# gems
+require 'rubygems'
+require 'RMagick'
+
+class ImageFile
+  
+  attr_reader :image_pool
+  
+  # properties of image
+  attr_reader :size
+  attr_reader :width
+  attr_reader :height
+
+  #
+  # page_url is the url of html page relative to the webroot f.e. "img_88.html"
+  #         used to link html pages
+  # url is the name of image f.e. "img_88.jpg"
+  #         used in the src=<...> of the image tag
+  #
+  def initialize( image_pool, local_path, src_url, page_url )
+    @image_pool = image_pool
+    @src_url     = src_url
+    @page_url    = page_url
+
+    if not File.exist?(local_path)
+      raise RAlbumException.new "file '#{local_path}' not exist"
+    end
+    if File.directory?(local_path)
+      raise RAlbumException.new "expected '#{local_path}' as file but it is a directory"
+    end
+
+    image = Magick::Image::read(local_path).first
+    @width  = image.columns
+    @height = image.rows
+    @size = image.filesize / 1024
+  end
+
+  #############################################################################
+  # properties
+  #
+  def name
+    @image_pool.name
+  end
+  
+  def description
+    @image_pool.description
+  end
+
+  #############################################################################
+  # paths
+
+  attr_reader :src_url  # path where is the image
+  attr_reader :page_url # url of html page displaying the image
+
+  def page_url_from_root
+    @image_pool.path + "/" + page_url
+  end
+
+  def relroot
+    @image_pool.relroot
+  end
+  
+  def relroot_with_prefix
+    @image_pool.relroot_with_prefix
+  end
+
+  
+  def breadcrumbs
+    @image_pool.breadcrumbs
+  end
+      
+  def prev_page_url
+    if @image_pool.prev
+      @image_pool.prev.default_image_file.page_url
+    else 
+      nil 
+    end
+  end
+  
+  def next_page_url
+    if @image_pool.next
+      @image_pool.next.default_image_file.page_url
+    else 
+      nil
+    end      
+  end
+
+end

data/lib/ralbum/{image_pool.rb → album_tree/image_pool.rb}

@@ -1,5 +1,5 @@
 # ralbum
-require 'tree_visitor/leaf_node'
+require 'treevisitor/leaf_node'
   
 #
 # ImagePool e' creata da una PhotoItem identificata da un md5
@@ -33,7 +33,10 @@ class ImagePool < LeafNode
 
     @images = {}
   end
-    
+
+  ############################################################################
+  # paths
+
   def relroot
     parent.relroot
   end
@@ -45,7 +48,10 @@ class ImagePool < LeafNode
   def breadcrumbs
     parent.breadcrumbs
   end
-    
+
+  ############################################################################
+  # images management
+  
   def image( type, image_file = nil)
     if image_file
       @images[ type ] = image_file
@@ -57,10 +63,16 @@ class ImagePool < LeafNode
     res
   end
 
-  def defaultImageFile
+  def default_image_file
     image("default")
   end
 
+  def thumb
+    image("thumb")
+  end
+
+  ############################################################################
+
   def to_s
     str = "ip: #{name.to_s} -#{@images.length}-"
     @images.each_key { |key| str += key.to_s }

data/lib/ralbum/catalog.rb

@@ -1,23 +1,23 @@
 # stlib
-require 'singleton'
 require 'yaml'
 
 # ralbums
-require 'ralbum/image_pool'
-require 'ralbum/image_strategy'
-
+require 'ralbum/ralbum_exception'
+require 'ralbum/album_tree/image_pool'
 
 #
 # All photos are stored here by md5
 #
 class Catalog
 
+  DEFAULT_CATALOG_DIRNAME = "ralbum"
+
   attr_reader :catalog_dirname
 
   def initialize( catalog_dirname )
     @catalog_dir =  catalog_dirname
     if not FileTest.directory?( catalog_dirname )
-      raise "Catog.init: catalog directory '#{catalog_dir}' not exists"
+      raise RAlbumException.new, "Catog.init: catalog directory '#{@catalog_dir}' not exists"
     end
 
     @md5_to_key = {}
@@ -43,8 +43,8 @@ class Catalog
     sprintf("%04d", k )
   end
 
-  def photo_file( phototreeitem )
-    "img_" + key( phototreeitem.md5.to_s ) + ".jpg"
+  def photo_file( photo_tree_item )
+    "img_" + key( photo_tree_item.photo_file.md5.to_s ) + ".jpg"
   end
 
   def album_key( reldir )

data/lib/ralbum/cli/cli_ralbum.rb

@@ -3,19 +3,13 @@ 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'
 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
@@ -28,22 +22,36 @@ class CliRAlbum
 
     skin_manager = SkinManager.new
 
+    ### common
     $options = OpenStruct.new
-    $options.force = false
     $options.verbose = 0
-    $options.inputfilter = "rubyalbum"
-    $options.list_skins = false
+    ### input
+    $options.photo_tree_type = "rubyphoto"
+    ### output
+    $options.force = false
     $options.skins = [ "gfold" ]
     $options.inctemplate = nil
+    ### debug
+    $options.debug_photo_tree = false
+    $options.debug_album_tree = false
 
     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
+      ##### common options
+      opts.separator ""
+      opts.separator "common options:"
+      opts.on("--help", "-h", "help!") {
+        puts opts
+        return 0
       }
+      opts.on("--version", "Show the version") do
+        puts "ralbum version #{Ralbum::VERSION}"
+        return 0
+      end
+
       opts.on("-v", "--verbose [NUM]", Integer, "verbosity level") { |num|
         if num.nil?
           $options.verbose = 1
@@ -51,13 +59,29 @@ class CliRAlbum
           $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
+        return 0
+      }
+
+      ##### input options
+      opts.separator ""
+      opts.separator "input options:"
+
+      algos = %w[rubyphoto jalbum]
+      algo_aliases = { "r" => "rubyphoto", "j" => "jalbum" }
+      algo_list = (algo_aliases.keys + algos).join(',')
+      opts.on("-i", "--ifilter ALGO", algos, algo_aliases, "input filter (phototree)","  (#{algo_list})") do |algo|
+        $options.photo_tree_type = algo
+      end
+
+      ##### output options
+      opts.separator ""
+      opts.separator "output options:"
+
+      opts.on("-f", "--force", "force the creation of directory") {
+        $options.force = true
       }
       opts.on("-s", "--skin x,y,z", Array, "skin(s)") { |arg|
         $options.skins = arg
@@ -65,16 +89,27 @@ class CliRAlbum
       opts.on("--inc STRING", String, "includes kwarts template" ) { |arg|
         $options.inctemplate = arg
       }
-      opts.on("--help", "-h", "help!") {
-        puts opts
-        exit 0
+
+      ##### debug options
+      opts.separator ""
+      opts.separator "debug options:"
+      opts.on("--debug-photo-tree") {
+        $options.debug_photo_tree = true
+      }
+      opts.on("--debug-album-tree") {
+        $options.debug_album_tree = true
       }
     end
     options.parse!(argv)
     
+    if ARGV.length < 1
+      puts "missing source (photo tree) directory. Use --help for a list of options"
+      return 1
+    end
+
     if ARGV.length < 2
-      puts options
-      exit 1
+      puts "missing destination (album_tree) directory. Use --help for a list of options"
+      return 1
     end
 
     phototree_dirname = argv[0]
@@ -84,13 +119,13 @@ class CliRAlbum
     $options.skins.each do |skin_name|
       unless skin_manager.has_skin?(skin_name)
         puts "skin:  #{skin_name} not exists"
-        exit 1
+        return 1
       end
     end
 
     if not File.directory?( phototree_dirname )
       puts "phototree_dir '#{phototree_dirname}' not exists or is not a directory"
-      exit 1
+      return 1
     end
     
     if not File.directory?( album_dirname )
@@ -100,17 +135,23 @@ class CliRAlbum
       else
         puts "albums_dir '#{album_dirname}' not exists or is not a directory"
         puts "use -f to force the creation of directory"
-        exit 1
+        return 1
       end
     end
     
     phototree_dirname = File.expand_path( phototree_dirname )
     album_dirname = File.expand_path( album_dirname )
     project = Project.new(skin_manager)
+    ### input
     project.phototree_dirname = phototree_dirname
+    project.photo_tree_type   = $options.photo_tree_type
+    ### output
     project.album_dirname     = album_dirname
     project.skin_names        = $options.skins
-    project.run
+    ### debug
+    project.debug_photo_tree  = $options.debug_photo_tree
+    project.debug_album_tree  = $options.debug_album_tree
+    return project.run
   end
   
 end