gallery_sync 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.env
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in gallery_sync.gemspec
+gemspec

data/README.md

@@ -0,0 +1 @@
+not usable yet

data/Rakefile

@@ -0,0 +1,3 @@
+require "bundler/gem_tasks"
+require "gallery_sync/tasks"
+GallerySync::Tasks.install

data/gallery_sync.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "gallery_sync/version"
+
+Gem::Specification.new do |s|
+  s.name        = "gallery_sync"
+  s.version     = GallerySync::VERSION
+  s.authors     = ["Iwan Birrer"]
+  s.email       = ["iwanbirrer@bluewin.ch"]
+  s.homepage    = "https://github.com/ibirrer/gallery_sync"
+  s.summary     = %q{Photo gallery syncing for Amazon S3, Dropbox}
+  s.description = %q{Synchronizes directory based photo galleries between Amazon S3, Dropbox, local file system. Built for the purpose of managing a photo gallery solely through Dropbox and publishing it trhough Amazon S3. No Database involved, all metdata (e.g album descriptions is kept in the filesystem.}
+
+
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # runtime dependencies
+  s.add_runtime_dependency "dropbox-sdk"
+  s.add_runtime_dependency "rmagick", ">= 2.12.0"
+  s.add_runtime_dependency "aws-sdk"
+
+  # development dependencies
+  s.add_development_dependency "rspec"
+end

data/lib/gallery_sync.rb

@@ -0,0 +1,4 @@
+require "gallery_sync/version"
+
+module GallerySync
+end

data/lib/gallery_sync/gallery_sync.rb

@@ -0,0 +1,483 @@
+require 'dropbox_sdk'
+require 'aws/s3'
+require 'RMagick'
+require 'benchmark'
+
+module GallerySync
+  class Gallery
+    # options, :reload, to reload albums, returns a cached version otherwise.
+    def albums(options = {})
+      if @albums.nil? or options[:reload]
+        @albums = load_albums
+      end
+      @albums.sort! { |a, b|
+        rank_a = a.metadata.fetch('rank', 0)
+        rank_b = b.metadata.fetch('rank', 0)
+        date_a = a.metadata.fetch('date_from', Date.civil())
+        date_b = b.metadata.fetch('date_from', Date.civil())
+        if(rank_a == rank_b)
+          date_a <=> date_b
+        else
+          rank_a <=> rank_b
+        end
+      }.reverse!
+      @albums
+    end
+
+    def serialized_albums
+      ser_albums = []
+      albums.each { |album|  
+        ser_album = Album.new(album.name)
+        ser_album.metadata = album.metadata
+        ser_album.album_photo = SerPhoto::value_of(album.album_photo)
+        ser_album.photos = []
+        album.photos.each { |photo|  
+          ser_album.photos << SerPhoto::value_of(photo)
+        }
+        ser_albums << ser_album
+      }
+      ser_albums
+    end
+
+    def sync_to(dest_gallery)
+      src = self
+
+      src_albums = src.albums
+      dest_albums = dest_gallery.albums
+
+      to_be_deleted = dest_albums.map(&:name) - src_albums.map(&:name)
+      to_be_deleted.each { |album| dest_gallery.rm_album(album) }
+      src_albums.each { |album|
+        if(dest_gallery[album.name])
+          album.merge_to(dest_gallery[album.name], dest_gallery) if dest_gallery[album.name]
+        else
+          dest_gallery.upload_album(album)
+          # sync metadata
+          dest_gallery.update_album_metadata(album,album.metadata)
+        end
+      }
+    end
+
+    def [](album_name)
+      r = albums.select { |a| a.name == album_name }
+      r.empty? ? nil : r.first
+    end
+  end
+
+  class CacheableGallery < Gallery
+    def initialize(gallery)
+      @albums = gallery.serialized_albums()    
+    end
+
+    def load_albums
+      @albums
+    end
+  end
+
+  class FileGallery < Gallery
+    def initialize(name, root_path)
+      @root_path = root_path
+      @name = name
+    end
+
+    def load_albums
+      albums = []
+      album_dirs = Dir.glob(File.join(@root_path,'*',''))
+      album_dirs.each { |album_dir|
+        album = Album.new(File.basename(album_dir))
+        metadata_file = File.join(album_dir, "album.yml")
+        album.load_metadata_from_yaml(File.open(metadata_file)) if File.exist?(metadata_file)
+        photos = Dir.glob(File.join(album_dir, "*.{png,jpg}")).select { |f| File.file?(f)}.map { |f|
+          FilePhoto.new(album,File.basename(f),f)
+        }
+        if !photos.empty?
+          albums << album
+          album.photos = photos
+          album.album_photo = photos[0]
+        end
+      }
+      albums
+    end
+
+    def rm_photo photo
+      photo.rm    
+    end
+
+    def rm_album album_name
+      album = self[album_name]
+      album.photos.each { |p|
+        p.rm
+      }
+    end
+
+
+
+    def upload_album album
+      Dir.mkdir File.join(@root_path, album.name)
+      album.photos.each { |photo|  
+        upload_photo(photo) 
+      }
+    end
+
+    def upload_photo(photo)
+      path = File.join(@root_path, photo.album.name, photo.name)
+      File.open(path,'wb') {|io|io.write(photo.file)}
+    end
+
+    def update_album_metadata(album,metadata)
+      file = File.join(@root_path, album.name, "album.yml")
+      File.open(file, 'w') do |out| 
+        YAML::dump(metadata, out)
+      end
+    end
+
+    def to_s
+      @root_path
+    end
+  end
+
+  class Album
+    attr_accessor :photos, :album_photo, :metadata
+    attr_reader :name
+
+    def initialize(name)
+      @name = name
+    end
+
+    def metadata()
+      if(@metadata.nil?)
+        @metadata = {'name' => name()}
+      end 
+      @metadata
+    end
+
+    # loads metadata from a yaml string
+    # title, date_from, date_to
+    def load_metadata_from_yaml(file)
+      @metadata = {}
+      @metadata = YAML::load(file)
+    end
+
+    def get_merge_actions(dest_album)
+      r = {}
+      src_album = self
+      src_names = @photos.collect(&:name)
+      dest_names = dest_album.photos.collect(&:name)
+
+      to_add = src_names - dest_names
+      to_delete = dest_names - src_names
+
+      r[:add] = to_add.map { |name| src_album[name]  }
+      r[:delete] = to_delete.map { |name| dest_album[name]  }
+      return r
+    end
+
+    def merge_to(dest_album,dest_gallery)
+      merge_actions = get_merge_actions(dest_album)
+
+      # perform delete
+      merge_actions[:delete].each { |p|
+        dest_gallery.rm_photo p
+      }
+
+      # perform add
+      merge_actions[:add].each { |p|
+        dest_gallery.upload_photo(p)
+      }
+
+      # sync metadata
+      if(self.metadata != dest_album.metadata)
+        dest_gallery.update_album_metadata(dest_album,self.metadata)
+      end 
+    end
+
+    def [](photo_name)
+      r = photos.select { |p| p.name == photo_name }
+      r.empty? ? nil : r.first
+    end
+
+    def to_s
+      @name
+    end
+  end
+
+  class SerPhoto < Struct.new(:name, :path, :thumb_url, :medium_url, :full_url)
+    def self.value_of(photo)
+      SerPhoto.new(photo.name,photo.path,photo.thumb_url,photo.medium_url,photo.full_url)
+    end
+  end
+
+  class Photo
+    attr_reader :album 
+    def initialize(album, name)
+      @album = album
+      @name = name
+    end
+
+    def name
+      @name
+    end
+
+    def path
+      "#{@album.name}/#{@name}"
+    end
+
+    def ==(another_photo)
+      @name == another_photo.name
+    end
+
+    def to_s
+      @name
+    end
+  end
+
+  class FilePhoto < Photo
+    def initialize(album,name,filepath)
+      super(album,name)
+      @filepath = filepath
+    end
+
+    def rm
+      File.delete @filepath
+    end
+
+    def thumb_url
+      @filepath
+    end
+
+    def medium_url
+      @filepath
+    end
+
+    def full_url
+      @filepath    
+    end
+
+    def to_s
+      "#{name} (#{@filepath})"
+    end
+
+    def file
+      File.open(@filepath,"rb") {|io| io.read}
+    end
+  end
+
+  class DropboxPhoto < Photo
+    def initialize(album,name,dropbox_path,gallery)
+      super(album,name)
+      @dropbox_path = dropbox_path
+      @gallery = gallery
+    end
+
+    def db_path
+      @dropbox_path
+    end
+
+    def file
+      file =  @gallery.client.get_file(@dropbox_path)
+      return file
+    end
+  end
+
+  class S3Photo < Photo
+    def initialize(album,name,s3_path, gallery)
+      super(album,name)
+      @s3_path = s3_path
+      @gallery = gallery
+    end
+
+    def s3_path
+      @s3_path
+    end
+
+    def thumb_url
+      key = album.name + "/thumb/" + name
+      @gallery.bucket.objects[key].public_url(:secure => false).to_s
+    end
+
+    def medium_url
+      key = album.name + "/medium/" + name
+      @gallery.bucket.objects[key].public_url(:secure => false).to_s
+    end
+
+    def full_url
+      key = album.name + "/full/" + name
+      @gallery.bucket.objects[key].public_url(:secure => false).to_s
+    end
+  end
+
+  class DropboxSource < Gallery
+
+    # Creates a dropbox source.
+    # @param [String] root the dropbox root directory of albums, 
+    # given as an absolute directory relative to the dropbox 
+    # root directry. Must start with a slash ('/'), e.g. 
+    # /Photos/mygallery Directories are handled as albums.
+    def initialize(root, app_key, app_secret, user_key, user_secret)
+      @root = root
+      session = DropboxSession.new(app_key,app_secret)
+      session.set_access_token(user_key,user_secret)
+      session.assert_authorized
+      @client = DropboxClient.new(session,:dropbox)
+    end
+
+    def client
+      @client
+    end
+
+    def getFile photo
+      @client.get_file(@root + photo.db_path)
+    end
+
+    def load_albums
+      albums = []
+      # retrieve all albums
+      @client.metadata(@root)['contents'].map { |c| c['path'] if c['is_dir'] }.each { |dir|  
+        # retrieve all photos
+        photos = []
+        album = Album.new(File.basename(dir))
+        @client.metadata(dir)['contents'].map { |c| c['path'] unless c['is_dir'] }.each { |file|  
+          if(file =~ /(\.png|\.jpg)\z/i) 
+            photos << DropboxPhoto.new(album, File.basename(file), file, self)
+          end 
+          if(file =~ /album\.yml\z/)
+            album.load_metadata_from_yaml(@client.get_file(file))
+          end
+        }
+
+        # only add album if it contains at least one photo 
+        if( !photos.empty? )
+          album.photos = photos
+          album.album_photo = photos[0]
+          albums << album
+        end
+      }
+      albums
+    end
+  end
+
+  class S3Destination < Gallery
+    def initialize(bucket_name,s3_key,s3_secret)
+      @con = AWS::S3::new(
+        :access_key_id     => s3_key,
+        :secret_access_key => s3_secret
+      )
+      @bucket = @con.buckets.create bucket_name
+    end
+
+    def bucket
+      @bucket
+    end
+
+    def load_albums 
+      albums = []
+
+      dirs = @bucket.as_tree.children.select(&:branch?)
+      dirs.each { |dir|  
+        photos = []
+        album = Album.new(File.basename(dir.prefix))
+        metadata = @bucket.objects[File.join(dir.prefix,'album.yml')]
+        if(metadata.exists?)
+          album.load_metadata_from_yaml(metadata.read)
+        end
+
+        dir = dir.children.select(&:branch?)[0]
+        if (dir) 
+          dir.children.select(&:leaf?).each { |leaf|
+            if( !leaf.key.end_with?("/") )  
+              photos << S3Photo.new(album, File.basename(leaf.key), leaf.key, self)
+            end
+          }
+        end
+
+        # only add album if it contains at least one photo
+        if( !photos.empty? )
+          album.photos = photos
+          album.album_photo = photos[0]
+          albums << album
+        end
+      }
+      albums
+    end
+
+    def rm_album album_name
+      album = self[album_name]
+      album.photos.each { |p|
+        rm_photo p
+      }
+    end
+
+    def rm_photo photo
+      key_thumb = photo.album.name + "/thumb/" + photo.name
+      key_medium = photo.album.name + "/medium/" + photo.name
+      key_full = photo.album.name + "/full/" + photo.name
+      @bucket.objects[key_thumb].delete
+      @bucket.objects[key_medium].delete
+      @bucket.objects[key_full].delete
+    end
+
+    def upload_album album
+      album.photos.each { |photo|  
+        upload_photo(photo) 
+      }
+    end
+
+    def upload_photo(photo)
+      key_thumb = photo.album.name + "/thumb/" + photo.name
+      key_medium = photo.album.name + "/medium/" + photo.name
+      key_full = photo.album.name + "/full/" + photo.name
+
+      photos = ImageScaler.scale_image(photo.file)
+
+      @bucket.objects.create(key_thumb, :data => photos[:thumb], :acl => :public_read)
+      @bucket.objects.create(key_medium, :data => photos[:medium], :acl => :public_read)
+      #@bucket.objects.create(key_full, :data => photos[:full], :acl => :public_read)
+    end
+
+    def update_album_metadata(album,metadata)
+      metadata_key = album.name + "/album.yml"
+      @bucket.objects.create(metadata_key, :data => YAML::dump(metadata), :acl => :public_read)
+    end
+
+    def to_s 
+      @bucket.name
+    end
+  end
+
+
+  class ImageScaler 
+    # @param image an in-memory image
+    # @returns thre different versions of the 
+    #          given photo, thumb, medium and full. 
+    def self.scale_image(image)
+      r = {}
+
+      magick_image = Magick::Image.from_blob(image).first
+      magick_image.auto_orient!
+
+      # thumb (strip exif metadata to decrease size)
+      # ^ means minimum size
+      r[:thumb] = magick_image.change_geometry('100x100^') { |w,h,img|
+        resized = img.resize(w,h)
+        if(w > h)
+          # landscape
+          resized.crop((w-h)/2,0,h,h)
+        else
+          # portrait
+          resized.crop(0,0,w,w)
+        end
+      }.strip!.to_blob {
+        self.quality = 80
+      }
+
+      # medium
+      r[:medium] = magick_image.change_geometry('460x460') { |cols, rows, img|
+        img.resize(cols, rows)
+      }.to_blob { self.quality = 85 }
+
+      # full
+      r[:full] = image
+      return r
+    end
+  end
+end

data/lib/gallery_sync/tasks.rb

@@ -0,0 +1,36 @@
+require 'dropbox_sdk'
+module GallerySync 
+  class Tasks
+    extend Rake::DSL if defined? Rake::DSL
+    def self.install
+      namespace :gallery do
+        desc "Authorize Dropbpox"
+        task :authorize_dropbox do
+          # prompt app key and secret
+          print "Enter dropbox app key: "
+          app_key = $stdin.gets.chomp
+          print "Enter dropbox app secret: "
+          app_secret = $stdin.gets.chomp
+
+          # authorize user
+          session = DropboxSession.new(app_key,app_secret)
+          session.get_request_token
+          authorize_url = session.get_authorize_url
+          puts "AUTHORIZING"
+          puts authorize_url
+          print "Please visit that website and hit 'Allow', then hit Enter here."
+          $stdin.gets.chomp
+          
+          # print configuration
+          access_token = session.get_access_token
+          puts "\nAdd the following configuration to your .env file:\n\n"
+          puts "GALLERY_SYNC_DROPBOX_APP_KEY=#{app_key}"
+          puts "GALLERY_SYNC_DROPBOX_APP_SECRET=#{app_secret}"
+          puts "GALLERY_SYNC_DROPBOX_USER_KEY=#{access_token.key}"
+          puts "GALLERY_SYNC_DROPBOX_USER_SECRET=#{access_token.secret}"
+          puts "\n"
+        end
+      end
+    end
+  end
+end

data/lib/gallery_sync/version.rb

@@ -0,0 +1,3 @@
+module GallerySync
+  VERSION = "0.0.1"
+end

data/spec/gallery_sync_spec.rb

@@ -0,0 +1,374 @@
+require 'gallery_sync/gallery_sync'
+require 'tmpdir'
+
+module GallerySync
+
+  describe GallerySync do
+
+    CONFIG_KEYS = [
+      'GALLERY_SYNC_S3_KEY',
+      'GALLERY_SYNC_S3_SECRET',
+      'GALLERY_SYNC_DROPBOX_APP_KEY',
+      'GALLERY_SYNC_DROPBOX_APP_KEY',
+      'GALLERY_SYNC_DROPBOX_APP_SECRET',
+      'GALLERY_SYNC_DROPBOX_USER_KEY',
+      'GALLERY_SYNC_DROPBOX_USER_SECRET']
+
+      before (:all) do
+        env_file = File.expand_path('../../.env', __FILE__)
+        if File.exists? env_file
+          env_values = Hash[IO.read(env_file).split.collect {|line| line.split('=')}]
+          (CONFIG_KEYS).each { | key |
+            ENV[key] = env_values[key]
+          }
+        end
+
+        missing_config_keys = CONFIG_KEYS - ENV.keys
+        raise "missing config key(s): #{missing_config_keys}. Check #{env_file}" unless missing_config_keys.empty?
+
+        @dropbox_empty = DropboxSource.new("/Photos/rubytest/empty", 
+                                           ENV['GALLERY_SYNC_DROPBOX_APP_KEY'],
+                                           ENV['GALLERY_SYNC_DROPBOX_APP_SECRET'], 
+                                           ENV['GALLERY_SYNC_DROPBOX_USER_KEY'],
+                                           ENV['GALLERY_SYNC_DROPBOX_USER_SECRET'] )
+
+        @src = DropboxSource.new("/Photos/rubytest/test1", 
+                                 ENV['GALLERY_SYNC_DROPBOX_APP_KEY'],
+                                 ENV['GALLERY_SYNC_DROPBOX_APP_SECRET'], 
+                                 ENV['GALLERY_SYNC_DROPBOX_USER_KEY'],
+                                 ENV['GALLERY_SYNC_DROPBOX_USER_SECRET'] )
+      end
+
+      describe DropboxSource, "empty dropbox directory" do
+        it "should return no albums" do
+          @dropbox_empty.albums.should be_empty
+        end
+      end
+
+      describe DropboxSource, "for each non-empty dropbox directory" do
+        before(:all) do
+          @albums = @src.albums
+        end
+
+        it "an album should be created" do
+          @albums.should have(2).items
+        end
+
+        it "the albums should have the correct name" do
+          @albums[0].name.should == "one"
+        end
+
+        it "each file in an album should be depicted as one photo" do
+          @albums[0].photos.should have(3).photos 
+        end
+
+        it "each photo should contain the correct path" do
+          @albums[0].photos[0].db_path.should eq "/Photos/rubytest/test1/one/IMG_0225.jpg"
+        end 
+
+        it "each photo should contain the correct path" do
+          @albums[0].photos[0].path.should eq "one/IMG_0225.jpg"
+        end 
+
+        it "the first photo is the album photo" do
+          @albums[0].album_photo.should == @albums[0].photos[0]
+        end
+
+        it "should read metadata correctly" do
+          @src['one'].metadata['name'].should == "Album 1"
+          @src['one'].metadata['date_from'].should == Date.parse('2011-09-09')
+          @src['one'].metadata['date_to'].should == Date.parse('2011-09-10')
+        end 
+      end
+
+      describe Album do
+        before(:all) do
+          @album = Album.new("album")
+          photos = [Photo.new(@album, "p1"), Photo.new(@album,"p2")]
+          @album.photos = photos
+          @album.album_photo = photos[0]
+        end
+        it "path of photo must macht <gallery_name>/<photo_name>" do
+          @album.photos[0].path.should == "album/p1"
+        end
+      end
+
+      describe "DropboxToS3" do
+        before(:all) do
+          @albums = @src.albums
+          @dest = S3Destination.new("therech_rubytest_dropbox", ENV['GALLERY_SYNC_S3_KEY'], ENV['GALLERY_SYNC_S3_SECRET'])
+        end
+
+        it "should sync the gallery from dropbox to s3" do
+          @src.sync_to(@dest) 
+          @dest.albums.size.should == @src.albums.size
+          @dest['one'].metadata.should == @src['one'].metadata
+        end
+      end
+
+      describe "FileToS3" do
+        before(:all) do
+          @gal1_dir  = File.join(File.expand_path(File.dirname(__FILE__)),"resources/gal1")
+          @gal1 = FileGallery.new "foo", @gal1_dir 
+          @dest = S3Destination.new("therech_rubytest_fromfile",ENV['GALLERY_SYNC_S3_KEY'], ENV['GALLERY_SYNC_S3_SECRET'])
+        end
+
+        it "should upload the complete album" do
+          @gal1.sync_to(@dest)
+          albums = @gal1.albums
+          albums.size.should == 2
+          album_names = @dest.albums.map(&:name)
+          album_names.size.should == 2
+          album_names.should include 'album1' 
+          album_names.should include 'album2' 
+          album_names.should_not include 'album3' 
+          album_names.should_not include 'album4' 
+          @dest["album2"].photos.size.should == 2
+          @dest["album1"].photos.size.should == 3
+          @dest["album1"].metadata.should == @gal1['album1'].metadata
+        end 
+      end
+
+      describe S3Destination, "each directory on s3" do
+        before(:all) do
+          @dest = S3Destination.new("therech_rubytest",ENV['GALLERY_SYNC_S3_KEY'], ENV['GALLERY_SYNC_S3_SECRET'])
+          @albums = @dest.albums
+        end
+
+        it "accessor for album" do
+          @dest['one'].should_not be nil
+          @dest['two'].should_not be nil
+          @dest['four'].should be nil
+        end
+
+        it "should serialize albums correctly" do
+          ser_albums = @dest.serialized_albums()
+          albums = Marshal.load(Marshal.dump(ser_albums))
+          albums.size.should == 2
+        end
+
+        it "should represent an album" do
+          @albums.should have(2).items
+        end
+
+        it "should return albums in correct order" do
+          @albums[0].name.should == "one"
+        end
+
+        it "each file in an album should be depicted as one photo" do
+          @albums[0].photos.should have(3).photos 
+        end
+
+        it "each photo should contain the correct path" do
+          @albums[0].photos[0].s3_path.should eq "one/full/IMG_0225.jpg"
+        end 
+
+        it "each photo should contain the correct path" do
+          @albums[0].photos[0].path.should eq "one/IMG_0225.jpg"
+        end 
+
+        it "the first photo is the album photo" do
+          @albums[0].album_photo.should == @albums[0].photos[0]
+        end
+
+        it "should have three versions of photos" do
+          @albums[0].photos[0].full_url.should match "one/full/IMG_0225.jpg"
+          @albums[0].photos[0].medium_url.should match "one/medium/IMG_0225.jpg"
+          @albums[0].photos[0].thumb_url.should match "one/thumb/IMG_0225.jpg"
+        end
+
+        it "should read metadata correctly" do
+          @dest['one'].metadata['name'].should == "Album 1"
+          @dest['one'].metadata['date_from'].should == Date.parse('2011-09-09')
+          @dest['one'].metadata['date_to'].should == Date.parse('2011-09-10')
+        end 
+      end
+
+      # test gallery looks as follows:
+      #  -gal1
+      #    -album1
+      #      -p1.png
+      #      -p2.png
+      #      -p3.png
+      #    -album2
+      #      -empty_dir
+      #      -p1.png
+      #      -p4.png
+      #    -album3
+      describe FileGallery do  
+        before(:all) do
+          @gal1_dir  = File.join(File.expand_path(File.dirname(__FILE__)),"resources/gal1")
+          @gal1 = FileGallery.new "foo", @gal1_dir 
+        end
+
+        it "should serialize albums correctly" do
+          ser_albums = @gal1.serialized_albums()
+          albums = Marshal.load(Marshal.dump(ser_albums))
+          albums.size.should == 2
+        end
+
+        it "empty albums must not be included" do
+          @gal1.albums.size.should == 2
+        end
+
+        it "albums should have the name of the directory" do
+          album_names = @gal1.albums.map(&:name)
+          album_names.should include 'album1' 
+          album_names.should include 'album2' 
+          album_names.should_not include 'album3' 
+        end
+
+        it "directories in albums must be ignored" do
+          @gal1["album2"].photos.size.should == 2
+          @gal1["album1"].photos.size.should == 3
+        end
+
+        it "shuld read metadata correctly" do
+          @album1 = @gal1['album1']
+          metadata = @album1.metadata() 
+          @album1.name.should == "album1"
+          metadata['name'].should == "Album 1"
+          metadata['date_from'].should == Date.parse('2011-09-09')
+          metadata['date_to'].should == Date.parse('2011-09-10')
+        end
+
+        # provides src and dest gallery through a block
+        def sync()
+          #dir = Dir.mktmpdir
+
+          Dir.mktmpdir{ |dir| 
+            FileUtils.cp_r @gal1_dir, dir
+            dest = File.join(dir, "gal1")
+            File.delete File.join(dest, 'album1/p1.png')
+            File.delete File.join(dest, 'album1/album.yml')
+            FileUtils.cp File.join(@gal1_dir, 'album1/p1.png'), File.join(dest, 'album3')
+            FileUtils.cp File.join(@gal1_dir, 'album1/p2.png'), File.join(dest, 'album2')
+            Dir.mkdir File.join(dest, 'album4')
+            FileUtils.cp_r Dir.glob(File.join(@gal1_dir, 'album1', '/*')), File.join(dest, 'album4')
+
+            @gal2 = FileGallery.new "gal2", dest
+            @gal1.sync_to(@gal2)
+            @gal2 = FileGallery.new "gal2", dest
+            yield(@gal1,@gal2)
+          }
+        end
+
+        # destination album is created on the fly in temp directory
+        # content is as follows
+        # -gal1
+        #   -album1
+        #     -p2.png
+        #     -p3.png
+        #   -album2
+        #     -empty_dir
+        #     -p1.png
+        #     -p2.png
+        #     -p4.png
+        #   -album3
+        #     -p1.png
+        #   -album4
+        #     -p1.png
+        #     -p2.png
+        #     -p3.png
+        it "sync_to" do
+          sync() { |src,dst|
+            album_names = dst.albums.map(&:name)
+            album_names.size.should == 2
+            album_names.should include 'album1' 
+            album_names.should include 'album2' 
+            album_names.should_not include 'album3' 
+            album_names.should_not include 'album4' 
+            dst["album2"].photos.size.should == 2
+            dst["album1"].photos.size.should == 3
+          }
+        end
+
+        it "should sync metadata" do
+          sync() { |src,dst|
+            src_album = src['album1']
+            dst_album = dst['album1']
+            dst_album.metadata.should == src_album.metadata
+          }
+        end
+
+        it "should sync full album when dest is empty" do
+          Dir.mktmpdir {|dir|
+            gal_dir = File.join(dir, "gal")
+            Dir.mkdir gal_dir
+            gal = FileGallery.new "gal", gal_dir
+
+            @gal1.sync_to(gal)
+            gal = FileGallery.new "gal", gal_dir
+            album_names = gal.albums.map(&:name)
+            album_names.size.should == 2
+            album_names.should include 'album1' 
+            album_names.should include 'album2' 
+            album_names.should_not include 'album3' 
+            album_names.should_not include 'album4' 
+            gal["album2"].photos.size.should == 2
+            gal["album1"].photos.size.should == 3
+          }
+        end
+      end
+
+      describe Album, "get_merge_actions" do
+        before(:all) do
+          @src = Album.new "album"
+          @dest = Album.new "album" 
+
+          @src.photos = [
+            Photo.new(@src,"f1"),
+            Photo.new(@src, "f2"),
+            Photo.new(@src, "f3")]
+
+            @dest.photos = [
+              Photo.new(@dest,"f2"),
+              Photo.new(@dest, "f5")]
+              @diff = @src.get_merge_actions(@dest)
+        end
+
+        it "returns the difference between two path" do
+          @diff[:add].should == [Photo.new(@src,"f1"),Photo.new(@src,"f3")]
+          @diff[:delete].should == [Photo.new(@dest,"f5")]
+        end
+      end
+
+      describe Photo do
+        before(:all) do
+          @a1 = Album.new("a1")
+          @a2 = Album.new("a2")
+        end
+
+        it { Photo.new(@a1,"p1").should == Photo.new(@a2, "p1") }
+        it { Photo.new(@a1,"p1").should == Photo.new(@a1, "p1") }
+        it { Photo.new(@a1,"p1").should_not == Photo.new(@a1, "p2") }
+      end
+
+      describe ImageScaler do
+        describe "scale_image" do
+          it "should return 3 differently scaled versions" do
+            portrait = File.join(File.expand_path(File.dirname(__FILE__)),
+                                 "resources/images/portrait.jpg")
+            landscape = File.join(File.expand_path(File.dirname(__FILE__)),
+                                  "resources/images/landscape.jpg")
+
+            file_portrait = open(portrait, "rb") {|io| io.read }
+            file_landscape = open(landscape, "rb") {|io| io.read }
+            scaled_images_portrait = ImageScaler.scale_image(file_portrait)
+            scaled_images_landscape = ImageScaler.scale_image(file_landscape)
+            #p scaled_images[:thumb].size
+            #p scaled_images[:medium].size
+            #p scaled_images[:full].size
+
+            med_file = open("/tmp/portrait_thumb.jpg", "wb").write(scaled_images_portrait[:thumb])
+            med_file = open("/tmp/portrait_med.jpg", "wb").write(scaled_images_portrait[:medium])
+            med_file = open("/tmp/portrait_full.jpg", "wb").write(scaled_images_portrait[:full])
+
+            med_file = open("/tmp/landscape_thumb.jpg", "wb").write(scaled_images_landscape[:thumb])
+            med_file = open("/tmp/landscape_med.jpg", "wb").write(scaled_images_landscape[:medium])
+            med_file = open("/tmp/landscape_full.jpg", "wb").write(scaled_images_landscape[:full])
+          end
+        end
+      end
+  end
+end

data/spec/resources/gal1/album1/album.yml

@@ -0,0 +1,4 @@
+name: "Album 1"
+date_from: 2011-09-09
+date_to: 2011-09-10
+

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: gallery_sync
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Iwan Birrer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dropbox-sdk
+  requirement: &15524860 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *15524860
+- !ruby/object:Gem::Dependency
+  name: rmagick
+  requirement: &15524120 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *15524120
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: &15523180 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *15523180
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &15521600 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *15521600
+description: Synchronizes directory based photo galleries between Amazon S3, Dropbox,
+  local file system. Built for the purpose of managing a photo gallery solely through
+  Dropbox and publishing it trhough Amazon S3. No Database involved, all metdata (e.g
+  album descriptions is kept in the filesystem.
+email:
+- iwanbirrer@bluewin.ch
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- gallery_sync.gemspec
+- lib/gallery_sync.rb
+- lib/gallery_sync/gallery_sync.rb
+- lib/gallery_sync/tasks.rb
+- lib/gallery_sync/version.rb
+- spec/gallery_sync_spec.rb
+- spec/resources/gal1/album1/album.yml
+- spec/resources/gal1/album1/p1.png
+- spec/resources/gal1/album1/p2.png
+- spec/resources/gal1/album1/p3.png
+- spec/resources/gal1/album2/p1.png
+- spec/resources/gal1/album2/p4.png
+- spec/resources/images/landscape.jpg
+- spec/resources/images/portrait.jpg
+homepage: https://github.com/ibirrer/gallery_sync
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Photo gallery syncing for Amazon S3, Dropbox
+test_files: []