gf-ralbum 0.0.2

data/lib/ralbum/options.rb

@@ -0,0 +1,15 @@
+if ! defined?( $options )
+  require 'ostruct'
+  $options = OpenStruct.new
+  # $options.force = false
+  $options.verbose = 0
+  # $options.inputfilter = "rubyalbum"
+  # $options.outputfilters = [ "html" ]
+  # $options.inctemplate = nil
+end
+
+def ralbum_verbose( level, msg )
+  if level < $options.verbose
+    puts msg
+  end
+end

data/lib/ralbum/photo_tree_builder.rb

@@ -0,0 +1,165 @@
+# stdlib
+require 'rubygems'
+require "rexml/document"
+
+# ralbum
+require 'tree_visitor/tree_node_visitor'
+require 'tree_visitor/dir_tree_walker'
+require 'ralbum/photo_tree_item'
+require 'ralbum/photo_tree_node'
+
+#
+# Crea un PhotoTree a partire da una
+# stuttura gerarchia di foto presente sul filesystem
+#
+class PhotoTreeBuilder 
+        
+  def run( phototree_dirname )
+    photoTree = buildPhotoTreeFromDirectory( phototree_dirname )
+    readMetaInfoOldFormat( photoTree )
+    updateMetaInfo( photoTree )
+    photoTree
+  end
+        
+  # ------------------------------------------------------------------------------
+  #
+  # build photo tree senza metainfo
+  #
+    
+  def buildPhotoTreeFromDirectory( phototree_dirname )
+    ralbum_verbose( 1, "phototree - building phototree from #{phototree_dirname}" )
+    visitor = CallbackTreeNodeVisitor2.new
+
+    visitor.onEnterTreeNode { |pathname, parent|
+      if not parent.nil?
+        pathname = File.basename( pathname )
+      end
+      PhotoTreeNode.new( pathname, parent )
+    }
+      
+    visitor.onVisitLeafNode{ |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
+  end
+    
+  # ---------------------------------------------------------------------------------------
+  #
+  # Read Metainfo vecchio formato
+  #
+  def readMetaInfoOldFormat( photoTree )
+    ralbum_verbose( 1, "phototree - reading metainfo" )
+    visitor = CallbackTreeNodeVisitor.new
+    visitor.onEnterTreeNode { |photoTreeNode|
+      read_photo_tree_node_xml(  photoTreeNode )
+    }
+    visitor.onVisitLeafNode{ |photoTreeItem|
+      read_photo_item_xml( photoTreeItem )
+    }
+    photoTree.accept( visitor )
+  end
+    
+  #
+  # old metainfo
+  #
+    
+  def read_photo_item_xml(photoTreeItem)
+    xml_file = File.join( photoTreeItem.parent.path, photoTreeItem.basename + ".xml" )
+      
+    if File.exist?(xml_file)
+      ralbum_verbose( 2, "NOTE: reading file xml for #{photoTreeItem.name}" )
+    else
+      ralbum_verbose( 1, "WARNING: file xml for #{photoTreeItem.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+/, " " )
+    }
+  end
+    
+  def read_photo_tree_node_xml( photoTreeNode )
+    xml_file = File.join(photoTreeNode.path, "album.xml")
+
+    if File.exist?(xml_file)
+      ralbum_verbose( 2, "NOTE: reading xml for node '#{photoTreeNode.path_from_root}'" )
+    else
+      ralbum_verbose( 1, "WARNING: xml for node '#{photoTreeNode.path_from_root}' 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+/, " " )
+    }
+  end
+    
+  # ---------------------------------------------------------------------------------------
+  #
+  # TODO: read meta info nuovo formato
+
+  def readMetaInfoNewFormat( photoTree, catalog_dirname )
+    ralbum_verbose( 1, "phototree - writing metainfo in #{catalog_dirname}" )
+    xml_project = File.join( catalog_dirname, "project.xml")
+
+    if File.exist?(xml_project)
+      ralbum_verbose( 2, "NOTE: reading xml for project" )
+    else
+      ralbum_verbose( 1, "WARNING: xml project not exists" )
+      return
+    end
+      
+    doc = REXML::Document.new File.new( xml_project )
+     
+  end
+    
+  # ---------------------------------------------------------------------------------------
+  #
+  # check meta info nuovo formato
+  #
+  def updateMetaInfo( photoTree )
+    ralbum_verbose( 1, "phototree - updating metainfo" )
+    visitor = CallbackTreeNodeVisitor.new
+    visitor.onVisitLeafNode{ |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
+    }
+    photoTree.accept( visitor )
+      
+  end
+    
+  # ---------------------------------------------------------------------------------------
+  #
+  # scrive meta info nuovo formato
+  #
+  # write xml - new format
+  #
+    
+  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|
+      photoTreeNode.write_xml( xml_el )
+    }
+    visitor.onVisitLeafNode{ |photoTreeItem, xml_el|
+      photoTreeItem.write_xml( xml_el )
+    }
+    photoTree.accept( visitor )
+  end
+    
+end 
+  

data/lib/ralbum/photo_tree_item.rb

@@ -0,0 +1,89 @@
+# rubygem
+require 'rubygems'
+require 'RMagick'
+
+# ralbum
+require 'gf_utility/md5'
+require 'tree_visitor/leaf_node'
+require 'ralbum-common/object_with_properties'
+require 'ralbum/options'
+require 'ralbum/ralbum_exception'
+
+#
+# Un photoTreeItem contiene una "foto" (da distinguersi con un'immagine)
+# e le metainformazioni sulla foto
+# un photoTreeItem appartiene sempre ad un photoTreeNode
+#
+class PhotoTreeItem < LeafNode
+  include ObjectWithProperties
+
+  attr_accessor :md5
+
+  def initialize( filename, photoTreeNode )
+    if photoTreeNode.nil?
+      raise "photoTreeNode non puo' essere nil!!"
+    end
+    super( filename, photoTreeNode )
+    init_object_with_properties
+    @time = nil      
+  end
+  
+  def basename
+    File.basename( name )
+  end
+
+  def time
+    return @time if ! @time.nil?
+    @time = File.mtime( parent.path )
+  end
+
+  def force_read_metainfo
+    unless File.exist?(path)
+      raise RAlbumException.new "photo '#{path}' not exists"
+    end
+    blob = File.open(path, "rb") do |f|
+      f.read
+    end
+    @md5 = MD5.new( blob ).to_s
+    ralbum_verbose( 2, sprintf("%40s: %d %s \n", name, time, @md5 ) )
+    
+    image = Magick::ImageList.new
+    image.from_blob( blob )
+    set_exif_property(image, "model", "Model")
+    set_exif_property(image, "date_and_time", "DateTimeOriginal")
+    set_exif_property(image, "FocalLength", "FocalLengthIn35mmFilm")
+    set_exif_property(image, "exposure_time", "ExposureTime")
+    set_exif_property(image, "white_balance", "WhiteBalance")
+    set_exif_property(image, "iso_speed", "ISOSpeedRatings")
+    
+    @properties['width']  = image.columns
+    @properties['height'] = image.rows
+  end
+      
+  def write_xml( xml_el )
+    xml_photo = xml_el.add_element( "photo" )            
+    xml_photo.add_element("md5").text = md5
+    xml_photo.add_element("title").text = name
+    xml_photo.add_element("description").text = self["description"]
+    xml_photo.add_element("file_date").text = time
+    
+    xml_exif = xml_photo.add_element("exif")
+    xml_exif.add_element("model").text         = self["model"]
+    xml_exif.add_element("date_and_time").text = self["date_and_time"]
+    xml_exif.add_element("FocalLength").text   = self["FocalLength"]
+    xml_exif.add_element("exposure_time").text = self["exposure_time"]
+    xml_exif.add_element("white_balance").text = self["white_balance"]
+    xml_exif.add_element("iso_speed").text     = self["iso_speed"]
+  end
+
+  private
+  
+  def set_exif_property(image, key_xml, key_exif )
+    a = image.get_exif_by_entry(key_exif)
+    if a && ( value = a[0][1] )
+      @properties[key_xml] = value
+    end
+  end
+
+end
+

data/lib/ralbum/photo_tree_node.rb

@@ -0,0 +1,40 @@
+# ralbum
+require 'rubygems'
+require 'ralbum-common/object_with_properties'
+require 'tree_visitor/tree_node'
+
+
+#
+# phototree contiene una gerarchia di phototreenode
+#           contiene una lista di photoitem
+#
+class PhotoTreeNode < TreeNode
+  include ObjectWithProperties
+
+  def initialize( dirname, parentPhotoTreeNode = nil )
+    super( dirname, parentPhotoTreeNode )
+
+    init_object_with_properties
+  end
+  
+  def write_xml( xml_el )    
+    xml_album = xml_el.add_element( "album" )
+    xml_album.add_element("title").text = name
+    xml_album.add_element("thumbnail")
+    xml_album.add_element("shortdesc")
+    xml_album.add_element("longdesc")
+    xml_album.add_element("date")
+    xml_album.add_element("order")
+    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/project.rb

@@ -0,0 +1,89 @@
+class Project
+  
+  attr_accessor :phototree_dirname
+  attr_accessor :album_dirname
+
+  attr_accessor :skin_names
+
+  def initialize(skin_manager)
+    @skin_manager = skin_manager
+  end
+
+
+  def run
+        
+    # TODO: carica file xml di project
+    # TODO: da file xml di project ricava le image strategy
+    
+    @phototree_dirname = File.expand_path( @phototree_dirname )
+    @album_dirname     = File.expand_path( @album_dirname )
+    catalog_dirname    = File.join( @phototree_dirname, "catalog_data" )
+    FileUtils.mkpath( catalog_dirname ) unless File.directory?( catalog_dirname )
+    
+    #
+    # =================================
+    #
+    skin_name = @skin_names.first
+    skin = @skin_manager.get_skin( skin_name )
+    skin.skin_engine.album_dirname = @album_dirname
+    # TODO: skin.configure( xml_project )
+
+    #
+    # step 1: reading phototree
+    #
+    
+    photoTreeBuilder = PhotoTreeBuilder.new
+    photoTree = photoTreeBuilder.run( phototree_dirname )
+    # TODO: photoTreeBuilder.configure( xml_project )
+    
+    #
+    # step 2: build catalog
+    #
+    
+    catalog = Catalog.new( catalog_dirname )
+    # catalog.create_images( photoTree, @album_dirname, skin.image_strategies )
+    # albums = catalog.create_model( phototree, albums_dir )
+    # catalog.model_to_txt( albums )
+
+    #
+    # 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 )
+
+
+
+    #
+    # step 3: generate albums
+    #
+    # $options.outputfilters.each { |filter|
+    #   skin = Generator::SkinFactory.get( filter )
+    #   skin.create( albums_dir, albums )
+    # }
+    
+    
+    #
+    # output album tree
+    #
+    # puts "------------------------------------ AlbumTree"
+    # albumTree.accept( PrintTreeNodeVisitor.new )
+    
+    # TODO: se generare l'album nella directory "skin_name" oppure nella root
+    skin.create( albumTree )
+    
+    #
+    # save project
+    #
+    ralbum_verbose( 1, "phototree - writing metainfo in #{catalog_dirname}" )
+    doc = REXML::Document.new
+    doc << REXML::XMLDecl.new
+    xml_project = doc.add_element( "project" )
+    photoTreeBuilder.write_xml(photoTree, xml_project)
+    xml_project = File.join( catalog_dirname, "project.xml")
+    File.open( xml_project, "w") {|f|
+      doc.write( f, 0 )
+    }    
+  end
+
+end

data/lib/ralbum/ralbum_exception.rb

@@ -0,0 +1,2 @@
+class RAlbumException <  RuntimeError
+end

data/lib/ralbum/resource.rb

@@ -0,0 +1,17 @@
+
+  
+class Resource
+    
+  def photos
+    "photos"
+  end
+    
+  def thumbnails
+    "Thumbnails"
+  end
+    
+  def subalbums
+    "Sub-Albums"
+  end
+end
+

data/lib/ralbum/skin.rb

@@ -0,0 +1,76 @@
+# rubygems
+require 'rubygems'
+
+#ralbum
+require 'gf_utility/file_utilities'
+require 'ralbum/skin_engine'
+  
+class Skin 
+
+  attr_reader :skin_dirname
+
+  attr_reader :skin_name
+  attr_reader :skin_description
+  attr_reader :skin_author
+
+  def initialize( skin_name, skin_dirname )
+    @metainfo    = nil
+    @skin_engine = nil
+    @skin_dirname = skin_dirname
+
+    @skin_name        = skin_name
+    @skin_author      = "please enter skin author name"
+    @skin_description = "no description"
+    load_info
+  end
+
+  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
+    end
+  end
+
+  def create( albumTree )
+    skin_engine.create( albumTree )
+  end
+
+  def skin_engine
+    if @skin_engine
+      return @skin_engine
+    end
+
+    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
+    end
+
+    engine = @metainfo['engine']
+    unless engine
+      puts "warning non engine defined for skin #{skin_name} using erb engine"
+      engine = 'erb'
+    end
+
+    case engine
+    when 'erb'    then  
+      require 'ralbum/skin_engines/erb_skin_engine'
+      @skin_engine = ErbSkinEngine.new( self )
+    when 'kwartz' then  
+      require 'ralbum/skin_engines/kwartz_skin_engine'
+      @skin_engine = KwartzSkinEngine.new( self )
+    else
+      raise RAlbumException.new, "skin engine #{engine} unknow"
+    end
+  end
+
+end