pwup 0.0.1

data/bin/pwupcli

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'ostruct'
+
+require 'pwup'
+
+$options = OpenStruct.new
+$options.files = []
+$options.album = nil
+$options.email = nil
+$options.password = nil
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: pwup.rb [$options]"
+
+  opts.on("-f", "--file=MANDATORY", "File to process") do |f|
+    $options.files << f
+  end
+
+  opts.on("-a", "--album=MANDATORY", "Album name") do |a|
+    $options.album = a
+  end
+
+  opts.on("-e", "--email=MANDATORY", "email") do |a|
+    $options.email = a
+  end
+
+  opts.on("-p", "--album=MANDATORY", "password") do |a|
+    $options.password = a
+  end
+end.parse!
+
+pwup = PwUp::PwUp.new($options.email, $options.password)
+pwup.process!($options.files, $options.album)

data/lib/picasa.rb

@@ -0,0 +1,575 @@
+# Copyright (c) 2008 Code71 Bangladesh
+# www.code71.com
+# http://code.google.com/p/picasaonrails/
+
+require 'rubygems'
+require 'cgi'
+require 'net/https'
+require 'net/http'
+require 'xmlsimple'
+
+module Picasa
+
+  class PicasaSession
+    attr_accessor :auth_key
+    attr_accessor :user_id
+  end
+
+  class Picasa
+    attr_accessor :picasa_session
+
+    def login(email, password)
+      url = "https://www.google.com/accounts/ClientLogin"
+      source = "MyCompany-TestProject-1.0.0" # source will be of CompanyName-ProjectName-ProjectVersion format
+
+      uri = URI.parse(url)
+
+      request = Net::HTTP.new(uri.host, uri.port)
+      request.use_ssl = true
+      request.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      response, data = request.post(uri.path, "accountType=GOOGLE&Email=#{email}&Passwd=#{password}&service=lh2&source=#{source}")
+      data = response.body
+      authMatch = Regexp.compile("(Auth=)([A-Za-z0-9_\-]+)\n").match(data.to_s)
+      if authMatch
+        authorizationKey = authMatch[2].to_s # substring that matched the pattern ([A-Za-z0-9_\-]+)
+      end
+
+      self.picasa_session = PicasaSession.new
+      self.picasa_session.auth_key = authorizationKey
+      self.picasa_session.user_id = email
+
+      return authorizationKey
+    end
+
+    def album(options = {})
+
+      if(options[:name] == nil)
+        return nil
+      end
+
+      albums = self.albums(options)
+      for album in albums
+        if(album.name == options[:name])
+          return album
+        end
+      end
+
+      return nil
+    end
+
+    def albums(options = {})
+
+      userId = options[:user_id] == nil ? self.picasa_session.user_id : options[:user_id]
+      access = options[:access] == nil ? "public" : options[:access]
+      url = "http://picasaweb.google.com/data/feed/api/user/#{userId}?kind=album&access=#{access}"
+
+      uri = URI.parse(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+
+      headers = {"Authorization" => "GoogleLogin auth=#{self.picasa_session.auth_key}"}
+
+      response, xml_response = http.get(uri.path, headers)
+
+      #xml_response = Net::HTTP.get_response(URI.parse(url)).body.to_s
+      albums = create_albums_from_xml(xml_response)
+
+      return albums
+    end
+
+    def photos(options = {})
+
+      options[:user_id] = options[:user_id].nil? ? self.picasa_session.user_id : options[:user_id]
+      options[:album] = options[:album].nil? ? "" : options[:album]
+
+      album = Album.new
+      album.picasa_session = self.picasa_session
+      photos = album.photos(options)
+
+      return photos
+    end
+
+    def create_album(options = {})
+
+      title = options[:title].nil? ? "" : options[:title]
+      summary = options[:summary].nil? ? "" : options[:summary]
+      location = options[:location].nil? ? "" : options[:location]
+      access = options[:access].nil? ? "public" : options[:access]
+      commentable = options[:commentable].nil? ? "true" : options[:commentable].to_s
+      keywords = options[:keywords].nil? ? "" : options[:keywords]
+      time_i = (Time.now).to_i
+
+      createAlbumRequestXml = "<entry xmlns='http://www.w3.org/2005/Atom'
+                    xmlns:media='http://search.yahoo.com/mrss/'
+                    xmlns:gphoto='http://schemas.google.com/photos/2007'>
+                      <title type='text'>#{title}</title>
+                      <summary type='text'>#{summary}</summary>
+                      <gphoto:location>#{location}</gphoto:location>
+                      <gphoto:access>#{access}</gphoto:access>
+                      <gphoto:commentingEnabled>#{commentable}</gphoto:commentingEnabled>
+                      <gphoto:timestamp>#{time_i}</gphoto:timestamp>
+                      <media:group>
+                        <media:keywords>#{keywords}</media:keywords>
+                      </media:group>
+                      <category scheme='http://schemas.google.com/g/2005#kind'
+                        term='http://schemas.google.com/photos/2007#album'></category>
+                    </entry>"
+
+      url = "http://picasaweb.google.com/data/feed/api/user/#{self.picasa_session.user_id}"
+
+      uri = URI.parse(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+
+      headers = {"Content-Type" => "application/atom+xml", "Authorization" => "GoogleLogin auth=#{self.picasa_session.auth_key}"}
+      response, data = http.post(uri.path, createAlbumRequestXml, headers)
+      data = response.body
+      album = create_album_from_xml(data)
+      return album
+    end
+
+    def load_album(album_url)
+      uri = URI.parse(album_url)
+      http = Net::HTTP.new(uri.host, uri.port)
+
+      headers = {"Authorization" => "GoogleLogin auth=#{self.picasa_session.auth_key}"}
+
+      response, album_entry_xml_response = http.get(uri.path, headers)
+
+      if(response.code == "200")
+        #parse the entry xml element and get the photo object
+        album = self.create_album_from_xml(album_entry_xml_response)
+        return album
+      else
+        return nil
+      end
+    end
+
+    def load_album_with_id(album_id)
+      album_url = "http://picasaweb.google.com/data/entry/api/user/#{self.picasa_session.user_id}/albumid/#{album_id}"
+
+      return load_album(album_url)
+    end
+
+    def load_photo(photo_url)
+      uri = URI.parse(photo_url)
+      http = Net::HTTP.new(uri.host, uri.port)
+
+      headers = {"Authorization" => "GoogleLogin auth=#{self.picasa_session.auth_key}"}
+
+      response, photo_entry_xml_response = http.get(uri.path, headers)
+
+      if(response.code == "200")
+        #parse the entry xml element and get the photo object
+        photo = self.create_photo_from_xml(photo_entry_xml_response)
+        return photo
+      else
+        return nil
+      end
+    end
+
+    def load_photo_with_id(photo_id, album_id)
+      photo_url = "http://picasaweb.google.com/data/entry/api/user/#{self.picasa_session.user_id}/albumid/#{album_id}/photoid/#{photo_id}"
+
+      return load_photo(photo_url)
+    end
+
+    def post_photo(image_data = nil, options = {})
+      summary = options[:summary] == nil ? "" : options[:summary]
+      album_name = options[:album] == nil ? "" : options[:album]
+      album_id = options[:album_id] == nil ? "" : options[:album_id]
+      local_file_name = options[:local_file_name] == nil ? "" : options[:local_file_name]
+      title = options[:title] == nil ? local_file_name : options[:title]
+
+      if(image_data == nil)
+        return nil
+        # Or throw an exception in next update
+      end
+
+      if(album_id != "")
+        url = "http://picasaweb.google.com/data/feed/api/user/#{self.picasa_session.user_id}/albumid/#{album_id}"
+      else
+        url = "http://picasaweb.google.com/data/feed/api/user/#{self.picasa_session.user_id}/album/#{album_name}"
+      end
+
+      uri = URI.parse(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+
+      headers = {"Content-Type" => "image/jpeg",
+        "Authorization" => "GoogleLogin auth=#{self.picasa_session.auth_key}",
+        "Slug" => title, "Content-Transfer-Encoding" => "binary"}
+
+      response, data = http.post(uri.path, image_data, headers)
+      data = response.body
+      photo = self.create_photo_from_xml(data)
+
+      return photo
+    end
+
+    def delete_photo(photo)
+      url = photo.edit_url
+
+      uri = URI.parse(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+
+      headers = {"Authorization" => "GoogleLogin auth=#{self.picasa_session.auth_key}"}
+
+      response, data = http.delete(uri.path, headers)
+      data = response.body
+
+      if(response.code == "200")
+        return true
+      else
+        return false
+      end
+
+    end
+
+    def delete_album(album)
+      url = album.edit_url
+
+      uri = URI.parse(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+
+      headers = {"Authorization" => "GoogleLogin auth=#{self.picasa_session.auth_key}"}
+
+      response, data = http.delete(uri.path, headers)
+      data = response.body
+
+      if(response.code == "200")
+        return true
+      else
+        return false
+      end
+
+    end
+
+    def create_albums_from_xml(xml_response)
+      albums = []
+      #response_hash = XmlSimple.xml_in(xml_response, { 'ForceArray' => false })
+      #puts response_hash.inspect
+
+      Picasa.entries(xml_response).each do |entry|
+        #parse the entry xml element and get the album object
+        album = Picasa.parse_album_entry(entry)
+
+        #enter session values in album object
+        album.picasa_session = PicasaSession.new
+        album.picasa_session.auth_key = self.picasa_session.auth_key
+        album.picasa_session.user_id = self.picasa_session.user_id
+
+        albums << album
+      end
+
+      return albums
+    end
+
+    def create_album_from_xml(xml_response)
+      album = nil
+
+      #parse the entry xml element and get the album object
+      album = Picasa.parse_album_entry(XmlSimple.xml_in(xml_response, { 'ForceArray' => false }))
+
+      #enter session values in album object
+      album.picasa_session = PicasaSession.new
+      album.picasa_session.auth_key = self.picasa_session.auth_key
+      album.picasa_session.user_id = self.picasa_session.user_id
+
+      return album
+    end
+
+    def create_photo_from_xml(xml_response)
+      photo = nil
+
+      #parse the entry xml element and get the photo object
+      photo = Picasa.parse_photo_entry(XmlSimple.xml_in(xml_response, { 'ForceArray' => false }))
+
+      #enter session values in photo object
+      photo.picasa_session = PicasaSession.new
+      photo.picasa_session.auth_key = self.picasa_session.auth_key
+      photo.picasa_session.user_id = self.picasa_session.user_id
+
+      return photo
+    end
+
+    def self.entries(xml_response)
+      document = XmlSimple.xml_in(xml_response, { 'ForceArray' => false });
+      return [] if (!document['totalResults'].nil? && document['totalResults'].to_i == 0)
+
+      entries = (document['totalResults']).to_i > 1 ? document["entry"] : [document["entry"]]
+      return entries.compact
+    end
+
+    def self.parse_album_entry(album_entry_xml)
+      #album_hash = XmlSimple.xml_in(album_entry_xml.to_s, { 'ForceArray' => false })
+      album_hash = album_entry_xml
+
+      album = Album.new
+      album.xml = album_entry_xml.to_s
+
+      album.id = album_hash["id"][1]
+      album.name = album_hash["name"]
+      album.user = album_hash["user"]
+      album.number_of_photos = album_hash["numphotos"]
+      album.number_of_comments = album_hash["commentCount"]
+      album.is_commentable = album_hash["commentingEnabled"] == true ? true : false
+      album.access = album_hash["access"]
+
+      album.author_name = album_hash["author"]["name"]
+      album.author_uri = album_hash["author"]["uri"]
+
+      album.title = album_hash["group"]["title"]["content"]
+      album.title_type = album_hash["group"]["title"]["type"]
+      album.description = album_hash["group"]["description"]["content"]
+      album.description_type = album_hash["group"]["description"]["type"]
+      album.image_url = album_hash["group"]["content"]["url"]
+      album.image_type = album_hash["group"]["content"]["type"]
+      album.thumbnail = Thumbnail.new()
+      album.thumbnail.url = album_hash["group"]["thumbnail"]["url"]
+      album.thumbnail.width = album_hash["group"]["thumbnail"]["width"]
+      album.thumbnail.height = album_hash["group"]["thumbnail"]["height"]
+
+      # make self xml url
+      links_from_hash = album_hash["link"]
+      if(links_from_hash.respond_to?(:each))
+        links_from_hash.each do |link|
+          if(link["rel"] == "self")
+            album.self_xml_url = link["href"]
+          elsif(link["rel"] == "edit")
+            album.edit_url = link["href"]
+          end
+        end
+      else
+        album.self_xml_url = nil
+        album.edit_url = nil
+      end
+
+      return album
+    end
+
+    def self.parse_photo_entry(photo_entry_xml)
+      #photo_hash = XmlSimple.xml_in(photo_entry_xml.to_s, { 'ForceArray' => false })
+      photo_hash = photo_entry_xml
+
+      photo = Photo.new
+      photo.xml = photo_entry_xml.to_s
+
+      photo.id = photo_hash["id"][1]
+      photo.album_id = photo_hash["albumid"]
+      photo.version_number = photo_hash["version"]
+      photo.is_commentable = photo_hash["commentingEnabled"]
+      photo.size = photo_hash["size"]
+      photo.client = photo_hash["client"]
+      photo.title = photo_hash["group"]["title"]["content"]
+      photo.description = photo_hash["group"]["description"]["content"]
+      photo.url = photo_hash["group"]["content"]["url"]
+      photo.width = photo_hash["group"]["content"]["width"]
+      photo.height = photo_hash["group"]["content"]["height"]
+      photo.type = photo_hash["group"]["content"]["type"]
+      photo.medium = photo_hash["group"]["content"]["medium"]
+
+      # make thumbnails
+      photo.thumbnails = []
+      thumbnails_from_hash = photo_hash["group"]["thumbnail"]
+      if(thumbnails_from_hash.respond_to?(:each))
+        thumbnails_from_hash.each do |thumb|
+          thumbnail = Thumbnail.new
+          thumbnail.url = thumb["url"]
+          thumbnail.width = thumb["width"]
+          thumbnail.height = thumb["height"]
+
+          photo.thumbnails << thumbnail
+        end
+      else
+
+      end
+
+      # make self xml url
+      links_from_hash = photo_hash["link"]
+      if(links_from_hash.respond_to?(:each))
+        links_from_hash.each do |link|
+          if(link["rel"] == "self")
+            photo.self_xml_url = link["href"]
+          elsif(link["rel"] == "edit")
+            photo.edit_url = link["href"]
+          end
+        end
+      else
+        photo.self_xml_url = nil
+        photo.edit_url = nil
+      end
+
+      return photo
+    end
+
+  end
+
+  class Album
+    attr_accessor :picasa_session
+
+    attr_accessor :id, :name
+    attr_accessor :user
+    attr_accessor :title, :title_type
+    attr_accessor :description, :description_type
+    attr_accessor :access
+    attr_accessor :author_name, :author_uri
+    attr_accessor :number_of_photos, :number_of_comments
+    attr_accessor :is_commentable
+    attr_accessor :image_url, :image_type
+    attr_accessor :thumbnail
+    attr_accessor :xml
+    attr_accessor :self_xml_url, :edit_url
+
+    def initialize()
+      thumbnail = Thumbnail.new()
+    end
+
+    def photos(options = {})
+
+      userId = options[:user_id].nil? ? self.user : options[:user_id]
+      albumName = options[:album].nil? ? self.name : options[:album]
+      albumId = options[:album_id].nil? ? self.id : options[:album_id]
+
+      if(albumId != nil && albumId != "")
+        url = "https://picasaweb.google.com/data/feed/api/user/#{userId}/albumid/#{albumId}?kind=photo"
+      else
+        url = "https://picasaweb.google.com/data/feed/api/user/#{userId}/album/#{albumName}?kind=photo"
+      end
+
+      uri = URI.parse(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+
+      headers = {"Authorization" => "GoogleLogin auth=#{self.picasa_session.auth_key}"}
+
+      response, xml_response = http.get(uri.path, headers)
+      photos = self.create_photos_from_xml(xml_response)
+
+      return photos
+    end
+
+    def create_photos_from_xml(xml_response)
+      photos = []
+      #response_hash = XmlSimple.xml_in(xml_response, { 'ForceArray' => false })
+      #puts response_hash.inspect
+
+      Picasa.entries(xml_response).each do |entry|
+        #parse the entry xml element and get the photo object
+        photo = Picasa.parse_photo_entry(entry)
+
+        #enter session values in photo object
+        photo.picasa_session = PicasaSession.new
+        photo.picasa_session.auth_key = self.picasa_session.auth_key
+        photo.picasa_session.user_id = self.picasa_session.user_id
+
+        photos << photo
+      end
+
+      return photos
+    end
+
+  end
+
+  class Photo
+    attr_accessor :picasa_session
+
+    attr_accessor :id
+    attr_accessor :title, :description
+    attr_accessor :album_id
+    attr_accessor :size
+    attr_accessor :client
+    attr_accessor :is_commentable, :number_of_comments
+    attr_accessor :url, :width, :height, :type, :medium
+    attr_accessor :thumbnails
+    attr_accessor :xml
+    attr_accessor :version_number
+    attr_accessor :self_xml_url, :edit_url
+
+    def initialize()
+      thumbnails = []
+    end
+
+    def update()
+
+      updatePhotoXml = "<entry xmlns='http://www.w3.org/2005/Atom'
+                    xmlns:media='http://search.yahoo.com/mrss/'
+                    xmlns:gphoto='http://schemas.google.com/photos/2007'>
+                      <title type='text'>#{self.title}</title>
+                      <summary type='text'>#{self.description}</summary>
+                      <gphoto:checksum></gphoto:checksum>
+                      <gphoto:client></gphoto:client>
+                      <gphoto:rotation>#{0}</gphoto:rotation>
+                      <gphoto:timestamp>#{Time.new.to_i.to_s}</gphoto:timestamp>
+                      <gphoto:commentingEnabled>#{self.is_commentable.to_s}</gphoto:commentingEnabled>
+                      <category scheme='http://schemas.google.com/g/2005#kind'
+                        term='http://schemas.google.com/photos/2007#photo'></category>
+                    </entry>"
+
+      url = "http://picasaweb.google.com/data/entry/api/user/#{self.picasa_session.user_id}/albumid/#{self.album_id}/photoid/#{self.id}/#{self.version_number}"
+
+      uri = URI.parse(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+
+      headers = {"Content-Type" => "application/atom+xml", "Authorization" => "GoogleLogin auth=#{self.picasa_session.auth_key}"}
+
+      response, data = http.put(uri.path, updatePhotoXml, headers)
+      data = response.body
+
+      if(response.code == "200")
+        #parse the entry xml element and get the photo object
+        #new_photo = Picasa.parse_photo_entry(data)
+        new_photo = Picasa.parse_photo_entry(XmlSimple.xml_in(data.to_s, { 'ForceArray' => false }))
+        self.version_number = new_photo.version_number
+
+        return true
+      else
+        return false
+      end
+    end
+
+    def move_to_album(picasa_album_id)
+
+      updatePhotoXml = "<entry xmlns='http://www.w3.org/2005/Atom'
+                    xmlns:media='http://search.yahoo.com/mrss/'
+                    xmlns:gphoto='http://schemas.google.com/photos/2007'>
+                      <title type='text'>#{self.title}</title>
+                      <summary type='text'>#{self.description}</summary>
+                      <gphoto:albumid>#{picasa_album_id}</gphoto:albumid>
+                      <gphoto:checksum></gphoto:checksum>
+                      <gphoto:client></gphoto:client>
+                      <gphoto:rotation>#{0}</gphoto:rotation>
+                      <gphoto:timestamp>#{Time.new.to_i.to_s}</gphoto:timestamp>
+                      <gphoto:commentingEnabled>#{self.is_commentable.to_s}</gphoto:commentingEnabled>
+                      <category scheme='http://schemas.google.com/g/2005#kind'
+                        term='http://schemas.google.com/photos/2007#photo'></category>
+                    </entry>"
+
+      url = "http://picasaweb.google.com/data/entry/api/user/#{self.picasa_session.user_id}/albumid/#{self.album_id}/photoid/#{self.id}/#{self.version_number}"
+
+      uri = URI.parse(url)
+      http = Net::HTTP.new(uri.host, uri.port)
+
+      headers = {"Content-Type" => "application/atom+xml", "Authorization" => "GoogleLogin auth=#{self.picasa_session.auth_key}"}
+
+      response, data = http.put(uri.path, updatePhotoXml, headers)
+      data = response.body
+
+      if(response.code == "200")
+        #parse the entry xml element and get the photo object
+        new_photo = Picasa.parse_photo_entry(XmlSimple.xml_in(data.to_s, { 'ForceArray' => false }))
+        self.version_number = new_photo.version_number
+        self.album_id = new_photo.album_id
+
+        return true
+      else
+        return false
+      end
+
+    end
+
+  end
+
+  class Thumbnail
+    attr_accessor :url, :width, :height
+  end
+
+end
+
+

data/lib/picasa_example.rb

@@ -0,0 +1,88 @@
+# http://code.google.com/p/picasaonrails/
+require "picasa"
+
+picasa = Picasa::Picasa.new
+puts picasa.login("you@gmail.com", "yourpass")
+puts picasa.picasa_session.auth_key
+
+albums = []
+# get albums of logged in account
+albums = picasa.albums(:access => "private")
+albums.each do |album|
+  puts "===== Album ======"
+  puts album.id
+  puts album.name
+
+  puts album.thumbnail.url
+  puts album.thumbnail.width
+  puts album.thumbnail.height
+
+  # get photos of an album
+  photos = album.photos
+  if(photos.size > 0)
+    photos.each do |photo|
+      puts "====== Photo ====="
+      puts photo.id
+      puts photo.title
+      puts photo.url
+      photo.thumbnails.each do |thumbnail|
+        puts thumbnail.url
+        puts thumbnail.width
+        puts thumbnail.height
+      end
+    end
+  else
+    puts "====== No photo for this album ====="
+  end
+
+end
+
+# get photos using album name
+photos = picasa.photos(:album => "AlbumFromRuby")
+puts "====== Photos of AlbumFromRuby ====="
+if(photos.size > 0)
+  photos.each do |photo|
+    puts "====== Photos ====="
+    puts photo.id
+    puts photo.title
+    puts photo.url
+    photo.thumbnails.each do |thumbnail|
+      puts thumbnail.url
+      puts thumbnail.width
+      puts thumbnail.height
+    end
+  end
+else
+  puts "====== No photo for this album ====="
+end
+
+# get photos using another user_id and album name
+photos = []
+photos = albums[0].photos(:user_id => "me")
+
+photos.each do |photo|
+  puts photo.id
+  puts photo.title
+  puts photo.description
+  puts photo.url
+  photo.thumbnails.each do |thumbnail|
+    puts thumbnail.url
+    puts thumbnail.width
+    puts thumbnail.height
+  end
+  puts "====== Photo ====="
+end
+
+# Create an album
+album = picasa.create_album(:title => "Album From Ruby",
+  :summary => "This album is created from ruby code",
+  :location => "Bangladesh", :keywords => "keyword1, keyword2")
+puts album.inspect
+
+# Post photo to an album
+fileName = "C:/Documents and Settings/All Users/Documents/My Pictures/Sample Pictures/Blue hills.jpg"
+image_data = open(fileName, "rb").read
+photo = picasa.post_photo(image_data, :album => "AlbumFromRuby",
+  :summary => "Upload2 from ruby api", :title => "From Ruby 2",
+  :local_file_name => "Blue hills.jpg")
+puts photo.inspect

data/lib/pwup.rb

@@ -0,0 +1,68 @@
+require 'date'
+require 'tmpdir'
+require 'picasa'
+
+module PwUp
+
+  class PwUp
+    # FILE_TYPES = %w[.rar .zip]
+    COMMANDS = {
+      ".rar" => "unrar x -ep \"%<file>s\" %<target_dir>s",
+      ".zip" => "unzip -j \"%<file>s\" -d %<target_dir>s",
+    }
+    IMAGE_TYPES = %w[.jpg .png .gif]
+
+    def initialize(email, password)
+      @email = email
+      @password = password
+      @picasa = Picasa::Picasa.new
+      p @picasa.login(email, password)
+    end
+
+    def process!(files, album_name)
+      # create a tmp folder
+      target_dir = Dir.mktmpdir('pwup', '/tmp')
+      # these are the compressed ones
+      files.each do |file|
+        if not process? file
+          puts "Skipping, can't process file #{file}"
+          next
+        end
+        # unpack file there
+        puts "Unpacking #{file}"
+        unpack file, target_dir
+      end
+      # filter only the images
+      images = Dir.foreach(target_dir).select {|f| IMAGE_TYPES.include? File.extname(f).downcase}
+      puts "Found #{images.length} images"
+      # exit if no images where found
+      return if images.length == 0
+      puts "Uploading to #{album_name}"
+      # create album
+      album = @picasa.create_album(:title => album_name,
+      :summary => album_name,
+      :location => "", :keywords => "", :timestamp => DateTime.now.to_time.to_i)
+      puts "album name = #{album.name}"
+      images.each do |image|
+        file_name = File.join(target_dir, image)
+        puts "Reading #{file_name}"
+        image_data = open(file_name, "rb").read
+        photo = @picasa.post_photo(image_data, :album => album.name,
+        :summary => file_name, :title => file_name)
+        puts "photo #{file_name} uploaded to #{album.name}"
+      end
+    end
+
+    private
+    def process?(file)
+      ext = File.extname(file)
+      COMMANDS.include? ext.downcase and File.exists? file
+    end
+
+    def unpack(file, target_dir)
+      ext = File.extname(file)
+      command = COMMANDS[ext] % {:file=>file, :target_dir=>target_dir}
+      system(command)
+    end
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: pwup
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Esteban Feldman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: xml-simple
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A simple picasa web uploador utility class that support compressed archives
+  (.rar, .zip)
+email: esteban.feldman@gmail.com
+executables:
+- pwupcli
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/picasa.rb
+- lib/picasa_example.rb
+- lib/pwup.rb
+- bin/pwupcli
+homepage: https://github.com/eka/pwup
+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:
+- unrar cli
+- unzip cli
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Picasa Web Uploader
+test_files: []