gf-ralbum 0.0.2 → 0.0.5

data/lib/ralbum/{photo_tree_node.rb → photo_tree/photo_tree_node.rb}

@@ -1,7 +1,8 @@
-# ralbum
 require 'rubygems'
-require 'ralbum-common/object_with_properties'
-require 'tree_visitor/tree_node'
+require 'treevisitor/tree_node'
+
+# ralbum
+require 'ralbum/object_with_properties'
 
 
 #
@@ -13,10 +14,20 @@ class PhotoTreeNode < TreeNode
 
   def initialize( dirname, parentPhotoTreeNode = nil )
     super( dirname, parentPhotoTreeNode )
-
     init_object_with_properties
   end
-  
+
+  def to_s
+    if self['title'] and not self['title'].empty?
+      "'#{name}'" + ": '" + self['title'] +"'"
+    else
+      "'#{name}'"
+    end
+  end
+
+  #############################################################################
+  # configurations
+
   def write_xml( xml_el )    
     xml_album = xml_el.add_element( "album" )
     xml_album.add_element("title").text = name
@@ -28,13 +39,5 @@ class PhotoTreeNode < TreeNode
     xml_album
   end 
 
-  def to_str( prefix = "" )
-    str << ""
-    str += prefix + name + "\n"
-    str += prefix + " photoItems: "
-    @childs.each{ |c| str += c.name }
-    str
-  end
-
 end
 

data/lib/ralbum/{photo_tree_builder.rb → photo_tree/rubyphoto_photo_tree.rb}

@@ -2,11 +2,16 @@
 require 'rubygems'
 require "rexml/document"
 
+# treevisitor
+require 'treevisitor/tree_node_visitor'
+require 'treevisitor/dir_tree_walker'
+require 'treevisitor/visitors/callback_tree_node_visitor2'
+require 'treevisitor/visitors/callback_tree_node_visitor'
+
 # ralbum
-require 'tree_visitor/tree_node_visitor'
-require 'tree_visitor/dir_tree_walker'
-require 'ralbum/photo_tree_item'
-require 'ralbum/photo_tree_node'
+require 'ralbum/photo_tree/photo_tree_item'
+require 'ralbum/photo_tree/photo_tree_node'
+require 'ralbum/catalog'
 
 #
 # Crea un PhotoTree a partire da una
@@ -15,9 +20,9 @@ require 'ralbum/photo_tree_node'
 class PhotoTreeBuilder 
         
   def run( phototree_dirname )
-    photoTree = buildPhotoTreeFromDirectory( phototree_dirname )
-    readMetaInfoOldFormat( photoTree )
-    updateMetaInfo( photoTree )
+    photoTree = build_photo_tree_from_directory( phototree_dirname )
+    read_meta_info_old_format( photoTree )
+    update_meta_info( photoTree )
     photoTree
   end
         
@@ -26,88 +31,102 @@ class PhotoTreeBuilder
   # build photo tree senza metainfo
   #
     
-  def buildPhotoTreeFromDirectory( phototree_dirname )
+  def build_photo_tree_from_directory( phototree_dirname )
     ralbum_verbose( 1, "phototree - building phototree from #{phototree_dirname}" )
+
+    dtw = DirTreeWalker.new( phototree_dirname )
+
+    # TODO: ignorare tutti le directory che iniziano per "." questa deve essere un'opzione di DirTreeWalker
+    dtw.add_ignore_dir( ".svn" )
+    dtw.add_ignore_dir( ".csv" )
+    dtw.add_ignore_dir( ".git" )
+
+    dtw.add_ignore_dir( Catalog::DEFAULT_CATALOG_DIRNAME )
+    dtw.add_inspect_file( /.jpg/ )
+    dtw.add_ignore_file( /.xml/ )
+    dtw.add_ignore_file( /(ignore)|(orig)/ )
+
     visitor = CallbackTreeNodeVisitor2.new
 
-    visitor.onEnterTreeNode { |pathname, parent|
+    visitor.on_enter_tree_node { |pathname, parent|
       if not parent.nil?
         pathname = File.basename( pathname )
       end
       PhotoTreeNode.new( pathname, parent )
     }
       
-    visitor.onVisitLeafNode{ |pathname, parent|
+    visitor.on_visit_leaf_node{ |pathname, parent|
       PhotoTreeItem.new(File.basename( pathname ), parent )
     }
-      
-    dtw = DirTreeWalker.new( phototree_dirname )
-    dtw.add_ignore_dir( ".svn" )
-    dtw.add_ignore_dir( "catalog_data" )
-    dtw.add_inspect_file( /.jpg/ )
-    dtw.add_ignore_file( /.xml/ )
-    dtw.add_ignore_file( /(ignore)|(orig)/ )
-      
-    photoTree = dtw.run( visitor )
-    # puts "------------------------------------ PhotoTree"
-    # photoTree.accept( PrintTreeNodeVisitor.new )
-    photoTree
+            
+    dtw.run( visitor ).root # return a photo_tree
   end
     
   # ---------------------------------------------------------------------------------------
   #
   # Read Metainfo vecchio formato
   #
-  def readMetaInfoOldFormat( photoTree )
+  def read_meta_info_old_format( photo_tree )
     ralbum_verbose( 1, "phototree - reading metainfo" )
     visitor = CallbackTreeNodeVisitor.new
-    visitor.onEnterTreeNode { |photoTreeNode|
+    visitor.on_enter_tree_node { |photoTreeNode|
       read_photo_tree_node_xml(  photoTreeNode )
     }
-    visitor.onVisitLeafNode{ |photoTreeItem|
+    visitor.on_visit_leaf_node{ |photoTreeItem|
       read_photo_item_xml( photoTreeItem )
     }
-    photoTree.accept( visitor )
+    photo_tree.accept( visitor )
   end
     
   #
   # old metainfo
   #
     
-  def read_photo_item_xml(photoTreeItem)
-    xml_file = File.join( photoTreeItem.parent.path, photoTreeItem.basename + ".xml" )
+  def read_photo_item_xml(photo_tree_item)
+    xml_file = File.join( photo_tree_item.parent.path, photo_tree_item.basename + ".xml" )
       
     if File.exist?(xml_file)
-      ralbum_verbose( 2, "NOTE: reading file xml for #{photoTreeItem.name}" )
+      ralbum_verbose( 2, "NOTE: reading file xml for #{photo_tree_item.name}" )
     else
-      ralbum_verbose( 1, "WARNING: file xml for #{photoTreeItem.name} not exists" )
+      ralbum_verbose( 1, "WARNING: file xml for #{photo_tree_item.name} not exists" )
       return
     end
       
     doc = REXML::Document.new File.new( xml_file )
     doc.elements["photo"].each_element { |e|
-      photoTreeItem[e.name.to_s] = e.text.to_s.strip.gsub( /\n/, "" ).gsub( /\s+/, " " )
+      #
+      # photo_tree_item[e.name.to_s] = e.text.to_s.strip.gsub( /\n/, "" ).gsub( /\s+/, " " )
+      #
+      key = e.name.to_s
+      value = e.text.to_s.strip.gsub( /\n/, "" ).gsub( /\s+/, " " )
+      case key
+      when "title"
+        photo_tree_item.title = value
+      when "description"
+        photo_tree_item.description = value
+      else
+        ralbum_verbose(1, "rubyphoto - read_photo_item_xml unknow #{key} found")
+      end
     }
   end
     
-  def read_photo_tree_node_xml( photoTreeNode )
-    xml_file = File.join(photoTreeNode.path, "album.xml")
+  def read_photo_tree_node_xml( photo_tree_node )
+    xml_file = File.join(photo_tree_node.path, "album.xml")
 
     if File.exist?(xml_file)
-      ralbum_verbose( 2, "NOTE: reading xml for node '#{photoTreeNode.path_from_root}'" )
+      ralbum_verbose( 2, "NOTE: reading xml for node '#{photo_tree_node.path}'" )
     else
-      ralbum_verbose( 1, "WARNING: xml for node '#{photoTreeNode.path_from_root}' not exists" )
+      ralbum_verbose( 1, "WARNING: xml for node '#{photo_tree_node.path}' not exists" )
       return
     end
       
     doc = REXML::Document.new File.new( xml_file )
     doc.elements["album"].each_element { |e|
-      photoTreeNode[e.name.to_s] = e.text.to_s.strip.gsub( /\n/, "" ).gsub( /\s+/, " " )
+      photo_tree_node[e.name.to_s] = e.text.to_s.strip.gsub( /\n/, "" ).gsub( /\s+/, " " )
     }
   end
     
-  # ---------------------------------------------------------------------------------------
-  #
+  # ---------------------------------------------------------------------------
   # TODO: read meta info nuovo formato
 
   def readMetaInfoNewFormat( photoTree, catalog_dirname )
@@ -122,21 +141,20 @@ class PhotoTreeBuilder
     end
       
     doc = REXML::Document.new File.new( xml_project )
-     
   end
     
   # ---------------------------------------------------------------------------------------
   #
   # check meta info nuovo formato
   #
-  def updateMetaInfo( photoTree )
+  def update_meta_info( photoTree )
     ralbum_verbose( 1, "phototree - updating metainfo" )
     visitor = CallbackTreeNodeVisitor.new
-    visitor.onVisitLeafNode{ |photoTreeItem|
+    visitor.on_visit_leaf_node{ |photoTreeItem|
       # TODO: updatare metainfo solo se il file della photo e' piu' aggionato del metainfo
-      if photoTreeItem['file_date'].empty? or photoTreeItem['file_date'] < photoTreeItem.time
-        photoTreeItem.force_read_metainfo
-      end
+      # if photoTreeItem['file_date'].empty? or photoTreeItem['file_date'] < photoTreeItem.time
+      #   photoTreeItem.force_read_metainfo
+      # end
     }
     photoTree.accept( visitor )
       
@@ -152,10 +170,10 @@ class PhotoTreeBuilder
   def write_xml( photoTree, xml_project )
     xml_photo_tree = xml_project.add_element("photo_tree")
     visitor = CallbackTreeNodeVisitor2.new( xml_photo_tree )
-    visitor.onEnterTreeNode { |photoTreeNode, xml_el|
+    visitor.on_enter_tree_node { |photoTreeNode, xml_el|
       photoTreeNode.write_xml( xml_el )
     }
-    visitor.onVisitLeafNode{ |photoTreeItem, xml_el|
+    visitor.on_visit_leaf_node{ |photoTreeItem, xml_el|
       photoTreeItem.write_xml( xml_el )
     }
     photoTree.accept( visitor )

data/lib/ralbum/project.rb

@@ -1,10 +1,19 @@
+require 'ralbum/catalog'
+require 'ralbum/skin_manager'
+require 'ralbum/album_tree/generate_album_tree_node_visitor'
+
 class Project
   
   attr_accessor :phototree_dirname
+  attr_accessor :photo_tree_type
+
   attr_accessor :album_dirname
 
   attr_accessor :skin_names
 
+  attr_accessor :debug_photo_tree
+  attr_accessor :debug_album_tree
+
   def initialize(skin_manager)
     @skin_manager = skin_manager
   end
@@ -17,7 +26,7 @@ class Project
     
     @phototree_dirname = File.expand_path( @phototree_dirname )
     @album_dirname     = File.expand_path( @album_dirname )
-    catalog_dirname    = File.join( @phototree_dirname, "catalog_data" )
+    catalog_dirname    = File.join( @phototree_dirname, Catalog::DEFAULT_CATALOG_DIRNAME )
     FileUtils.mkpath( catalog_dirname ) unless File.directory?( catalog_dirname )
     
     #
@@ -25,17 +34,36 @@ class Project
     #
     skin_name = @skin_names.first
     skin = @skin_manager.get_skin( skin_name )
-    skin.skin_engine.album_dirname = @album_dirname
+    skin.engine.album_dirname = @album_dirname
     # TODO: skin.configure( xml_project )
 
     #
     # step 1: reading phototree
     #
-    
-    photoTreeBuilder = PhotoTreeBuilder.new
-    photoTree = photoTreeBuilder.run( phototree_dirname )
+
+    case @photo_tree_type
+    when "rubyphoto"
+      require 'ralbum/photo_tree/rubyphoto_photo_tree'
+      photo_tree_builder = PhotoTreeBuilder.new
+    when "jalbum"
+      require 'ralbum/photo_tree/jalbum_photo_tree'
+      photo_tree_builder = JalbumPhotoTreeBuilder.new
+    else
+      raise RAlbumException.new("photo tree type '#{@photo_tree_type}' unknow" )
+    end
+    photo_tree = photo_tree_builder.run( phototree_dirname )
     # TODO: photoTreeBuilder.configure( xml_project )
-    
+
+
+    if(@debug_photo_tree)
+      puts "---------- PhotoTree"
+      puts "root is " + photo_tree.path_with_prefix
+      puts photo_tree.to_str
+      puts "----------"
+    end
+
+
+
     #
     # step 2: build catalog
     #
@@ -49,10 +77,15 @@ class Project
     # step : generate album_tree
     #
     # TODO: l'album tree e' generato in base allo skin
-    generator = GenerateAlbumTreeNodeVisitor.new( album_dirname, catalog, skin.skin_engine.image_strategies )
-    albumTree = generator.run( photoTree )
-
+    generator = GenerateAlbumTreeNodeVisitor.new( album_dirname, catalog, skin.engine.image_strategies )
+    album_tree = generator.run( photo_tree )
 
+    if(@debug_album_tree)
+      puts "---------- AlbumTree"
+      puts "root is " + album_tree.path_with_prefix
+      puts album_tree.to_str
+      puts "----------"
+    end
 
     #
     # step 3: generate albums
@@ -70,8 +103,10 @@ class Project
     # albumTree.accept( PrintTreeNodeVisitor.new )
     
     # TODO: se generare l'album nella directory "skin_name" oppure nella root
-    skin.create( albumTree )
+    skin.create( album_tree )
     
+    retun 0
+
     #
     # save project
     #
@@ -79,11 +114,12 @@ class Project
     doc = REXML::Document.new
     doc << REXML::XMLDecl.new
     xml_project = doc.add_element( "project" )
-    photoTreeBuilder.write_xml(photoTree, xml_project)
+    photo_tree_builder.write_xml(photo_tree, xml_project)
     xml_project = File.join( catalog_dirname, "project.xml")
     File.open( xml_project, "w") {|f|
       doc.write( f, 0 )
-    }    
+    }
+    return 0
   end
 
 end

data/lib/ralbum/skin.rb

@@ -2,7 +2,7 @@
 require 'rubygems'
 
 #ralbum
-require 'gf_utility/file_utilities'
+require 'gf_utilities/file_utilities'
 require 'ralbum/skin_engine'
   
 class Skin 
@@ -14,8 +14,8 @@ class Skin
   attr_reader :skin_author
 
   def initialize( skin_name, skin_dirname )
-    @metainfo    = nil
-    @skin_engine = nil
+    @metainfo     = {}
+    @engine       = nil
     @skin_dirname = skin_dirname
 
     @skin_name        = skin_name
@@ -26,48 +26,55 @@ class Skin
 
   def load_info
     info_filename = File.join( @skin_dirname, "info.yml" )
-    if File.exist?( info_filename )
-      info = YAML::load( File.read(info_filename) )
-      if not info.kind_of?(Hash)
-        ralbum_verbose(1, "description skin file '#{info_filename}' is incorrect")
-      else
-        @metainfo         = info
-        @skin_author      = info["author"]
-        @skin_description = info["description"]
-      end
+
+    unless File.exist?( info_filename )
+      ralbum_verbose(1, "information file for skin '#{@skin_name}' doesn't exist")
+      return
+    end
+    info = YAML::load( File.read(info_filename) )
+    if not info.kind_of?(Hash)
+      ralbum_verbose(1, "description skin file '#{info_filename}' is incorrect")
+    else
+      @metainfo         = info
+      @skin_author      = info["author"]
+      @skin_description = info["description"]
     end
   end
 
-  def create( albumTree )
-    skin_engine.create( albumTree )
+  def create( album_tree )
+    engine.create( album_tree )
   end
 
-  def skin_engine
-    if @skin_engine
-      return @skin_engine
-    end
+  def compile
+    engine.compile
+  end
+
+  def engine
+    return @engine if @engine
 
-    skin_engine_rb = File.join( @skin_dirname, @skin_name + "_skin.rb" )
-    if File.exist?( skin_engine_rb )
-      require skin_engine_rb
-      clss = get_constant( @skin_name.capitalize + "SkinEngine" )
-      @skin_engine = clss.new( self )
-      return @skin_engine
+    engine_rb = File.join( @skin_dirname, @skin_name + "_skin_engine.rb" )
+    if File.exist?( engine_rb )
+      require engine_rb
+      engine_class_name = @skin_name.capitalize + "SkinEngine"
+      clss = Class.const_get( engine_class_name.to_sym )
+      @engine = clss.new( self )
+      return @engine
     end
 
     engine = @metainfo['engine']
     unless engine
-      puts "warning non engine defined for skin #{skin_name} using erb engine"
+      msg = "warning no engine defined for skin '#{skin_name}': I will be use ErbSkinEngine"
+      ralbum_verbose(0, msg)
       engine = 'erb'
     end
 
     case engine
     when 'erb'    then  
       require 'ralbum/skin_engines/erb_skin_engine'
-      @skin_engine = ErbSkinEngine.new( self )
+      @engine = ErbSkinEngine.new( self )
     when 'kwartz' then  
       require 'ralbum/skin_engines/kwartz_skin_engine'
-      @skin_engine = KwartzSkinEngine.new( self )
+      @engine = KwartzSkinEngine.new( self )
     else
       raise RAlbumException.new, "skin engine #{engine} unknow"
     end