picasa 0.5.1 → 0.5.2

data/README.md

@@ -24,14 +24,21 @@ client.photo.create("album_id", file_path: "path/to/my-photo.png")
 # => Picasa::Presenter::Photo
 ```
 
-If password is specified, all requests will be authenticated.
-This affect results to contain private data, however it can be controlled by `access` parameter.
+### Authentication
 
-## Caveats
+When request is authenticated, response will contain private data, however this can be controlled by `access` parameter.
 
-Currently picasa wont work with `ox` xml parser.
-Using `rexml` parser wont return `etag` attribute properly.
-I recommend to use `libxml` or `nokogiri`.
+You can authenticate by specifing password:
+
+```ruby
+client = Picasa::Client.new(user_id: "some.user@gmail.com", password: "secret")
+```
+
+Or by setting custom authorization header, i.e. taken from OAuth authentication:
+
+```ruby
+client = Picasa::Client.new(user_id: "some.user@gmail.com", authorization_header: "OAuth token")
+```
 
 ## Extra
 
@@ -51,6 +58,8 @@ And then use it (it will create album taking title from folder name and upload a
 
 ```
 GOOGLE_USER_ID=your.email@gmail.com GOOGLE_PASSWORD=secret thor picasa_uploader:upload_all path-to-folder-with-photos
+# Without specifing password
+GOOGLE_USER_ID=your.email@gmail.com GOOGLE_AUTHORIZATION_HEADER="GoogleLogin auth=token" thor picasa_uploader:upload_all path-to-folder-with-photos
 ```
 
 If your upload was somehow interrupted, you can resume it by adding `--continue` option:
@@ -59,6 +68,16 @@ If your upload was somehow interrupted, you can resume it by adding `--continue`
 GOOGLE_USER_ID=your.email@gmail.com GOOGLE_PASSWORD=secret thor picasa_uploader:upload_all --continue path-to-folder-with-photos
 ```
 
+If you run out of quota and want to resize images to fit Picasa free storage limits, you might be interested in Thor task for [that job](https://github.com/morgoth/ripper#usage)
+
+## Caveats
+
+Currently picasa wont work with `ox` xml parser.
+
+Using `rexml` parser wont return `etag` attribute properly.
+
+I recommend to use `libxml` or `nokogiri`.
+
 ## Continuous Integration
 [![Build Status](https://secure.travis-ci.org/morgoth/picasa.png)](http://travis-ci.org/morgoth/picasa)
 

data/extra/Thorfile

@@ -1,4 +1,5 @@
 require "picasa"
+require "thread"
 
 # Temporary requirement
 MultiXml.parser = :libxml
@@ -7,7 +8,8 @@ class PicasaUploader < Thor
   include Thor::Actions
 
   desc "upload_all DIR", "Uploads all photos from given directory (pass --continue to resume uploading)"
-  method_options continue: false
+  method_option :continue, type: :boolean, default: false, aliases: "-c", desc: "continue aborted upload"
+  method_option :threads, type: :numeric, default: 8, aliases: "-t", desc: "specify threads number"
   def upload_all(dir = File.basename(Dir.getwd))
     require_credentials
 
@@ -34,23 +36,34 @@ class PicasaUploader < Thor
         album = create_album(album_name)
       end
 
-      entries.each do |file|
-        photos_number += 1
-        say("Uploading photo #{file} to album #{album.title} - #{photos_number}/#{entries.size}")
-        create_photo(album, file)
-      end
-      say "Finished uploading #{photos_number} photos"
+      mutex = Mutex.new
+      entries_size = entries.size
+      number = 0
+      options[:threads].times.map do
+        Thread.new(entries) do |files|
+          while file = mutex.synchronize { files.pop }
+            mutex.synchronize { number += 1 }
+            say("Uploading photo #{file} to album #{album.title} - #{number}/#{entries_size}")
+            create_photo(album, file)
+          end
+        end
+      end.each(&:join)
+      say "Finished uploading #{number} photos"
     end
   end
 
   no_tasks do
     def client
-      @client ||= Picasa::Client.new(user_id: ENV["GOOGLE_USER_ID"], password: ENV["GOOGLE_PASSWORD"])
+      @client ||= Picasa::Client.new(user_id: ENV["GOOGLE_USER_ID"],
+        authorization_header: ENV["GOOGLE_AUTHORIZATION_HEADER"],
+        password: ENV["GOOGLE_PASSWORD"])
     end
 
     def require_credentials
-      say "You must specify GOOGLE_USER_ID env variable" and exit unless ENV["GOOGLE_USER_ID"]
-      say "You must specify GOOGLE_PASSWORD env variable" and exit unless ENV["GOOGLE_PASSWORD"]
+      say "You must specify GOOGLE_USER_ID env variable" and exit if ENV["GOOGLE_USER_ID"].nil?
+      if ENV["GOOGLE_AUTHORIZATION_HEADER"].nil? && ENV["GOOGLE_PASSWORD"].nil?
+        say "You must specify GOOGLE_PASSWORD or GOOGLE_AUTHORIZATION_HEADER env variable" and exit
+      end
     end
 
     def create_album(title)

data/lib/picasa/api/album.rb

@@ -14,9 +14,9 @@ module Picasa
       # @return [Presenter::AlbumList]
       def list(options = {})
         uri = URI.parse("/data/feed/api/user/#{user_id}")
-        parsed_body = Connection.new(credentials).get(uri.path, options)
+        response = Connection.new.get(:path => uri.path, :query => options, :headers => auth_header)
 
-        Presenter::AlbumList.new(parsed_body["feed"])
+        Presenter::AlbumList.new(MultiXml.parse(response.body)["feed"])
       end
 
       # Returns photo list for given album
@@ -31,9 +31,9 @@ module Picasa
       # @raise [NotFoundError] raised when album cannot be found
       def show(album_id, options = {})
         uri = URI.parse("/data/feed/api/user/#{user_id}/albumid/#{album_id}")
-        parsed_body = Connection.new(credentials).get(uri.path, options)
+        response = Connection.new.get(:path => uri.path, :query => options, :headers => auth_header)
 
-        Presenter::Album.new(parsed_body["feed"])
+        Presenter::Album.new(MultiXml.parse(response.body)["feed"])
       end
 
       # Creates album
@@ -53,8 +53,9 @@ module Picasa
 
         template = Template.new(:new_album, params)
         uri = URI.parse("/data/feed/api/user/#{user_id}")
-        parsed_body = Connection.new(credentials).post(uri.path, template.render)
-        Presenter::Album.new(parsed_body["entry"])
+        response = Connection.new.post(:path => uri.path, :body => template.render, :headers => auth_header)
+
+        Presenter::Album.new(MultiXml.parse(response.body)["entry"])
       end
 
       # Destroys given album
@@ -67,9 +68,9 @@ module Picasa
       # @raise [NotFoundError] raised when album cannot be found
       # @raise [PreconditionFailedError] raised when ETag does not match
       def destroy(album_id, options = {})
-        headers = {"If-Match" => options.fetch(:etag, "*")}
+        headers = auth_header.merge({"If-Match" => options.fetch(:etag, "*")})
         uri = URI.parse("/data/entry/api/user/#{user_id}/albumid/#{album_id}")
-        Connection.new(credentials).delete(uri.path, headers)
+        Connection.new.delete(:path => uri.path, :headers => headers)
         true
       end
       alias :delete :destroy

data/lib/picasa/api/base.rb

@@ -1,17 +1,23 @@
 module Picasa
   module API
     class Base
-      attr_reader :user_id, :credentials
+      attr_reader :user_id, :authorization_header
 
       # @param [Hash] credentials
       # @option credentials [String] :user_id google username/email
-      # @option credentials [String] :password password for given username/email
-      def initialize(credentials)
+      # @option credentials [String] :authorization_header header for authenticating requests
+      def initialize(credentials = {})
         if MultiXml.parser.to_s == "MultiXml::Parsers::Ox"
           raise StandardError, "MultiXml parser is set to :ox - picasa gem will not work with it currently, use one of: :libxml, :nokogiri, :rexml"
         end
         @user_id  = credentials.fetch(:user_id)
-        @credentials = credentials
+        @authorization_header = credentials[:authorization_header]
+      end
+
+      def auth_header
+        {}.tap do |header|
+          header["Authorization"] = authorization_header if authorization_header
+        end
       end
     end
   end

data/lib/picasa/api/photo.rb

@@ -20,11 +20,12 @@ module Picasa
         params[:content_type] ||= (file && file.content_type) || raise(ArgumentError.new("content_type must be specified"))
 
         template = Template.new(:new_photo, params)
-        headers = {"Content-Type" => "multipart/related; boundary=\"#{params[:boundary]}\""}
+        headers = auth_header.merge({"Content-Type" => "multipart/related; boundary=\"#{params[:boundary]}\""})
 
         uri = URI.parse("/data/feed/api/user/#{user_id}/albumid/#{album_id}")
-        parsed_body = Connection.new(credentials).post(uri.path, template.render, headers)
-        Presenter::Photo.new(parsed_body["entry"])
+        response = Connection.new.post(:path => uri.path, :body => template.render, :headers => headers)
+
+        Presenter::Photo.new(MultiXml.parse(response.body)["entry"])
       end
 
 	    # Destroys given photo
@@ -38,9 +39,9 @@ module Picasa
       # @raise [NotFoundError] raised when album or photo cannot be found
       # @raise [PreconditionFailedError] raised when ETag does not match
       def destroy(album_id, photo_id, options = {})
-        headers = {"If-Match" => options.fetch(:etag, "*")}
+        headers = auth_header.merge({"If-Match" => options.fetch(:etag, "*")})
         uri = URI.parse("/data/entry/api/user/#{user_id}/albumid/#{album_id}/photoid/#{photo_id}")
-        Connection.new(credentials).delete(uri.path, headers)
+        Connection.new.delete(:path => uri.path, :headers => headers)
         true
       end
       alias :delete :destroy

data/lib/picasa/api/tag.rb

@@ -11,8 +11,8 @@ module Picasa
       #
       # @return [Presenter::TagList]
       def list(options = {})
-        album_id = options[:album_id]
-        photo_id = options[:photo_id]
+        album_id = options.delete(:album_id)
+        photo_id = options.delete(:photo_id)
         raise(ArgumentError, "You must specify album_id when providing photo_id") if photo_id && !album_id
 
         path = "/data/feed/api/user/#{user_id}"
@@ -20,8 +20,9 @@ module Picasa
         path << "/photoid/#{photo_id}" if photo_id
 
         uri = URI.parse(path)
-        parsed_body = Connection.new(credentials).get(uri.path, options.merge(:kind => "tag"))
-        Presenter::TagList.new(parsed_body["feed"])
+        response = Connection.new.get(:path => uri.path, :query => options.merge(:kind => "tag"), :headers => auth_header)
+
+        Presenter::TagList.new(MultiXml.parse(response.body)["feed"])
       end
 
       # Creates a tag for a photo.
@@ -42,8 +43,9 @@ module Picasa
         template = Template.new("new_tag", params)
 
         uri = URI.parse(path)
-        parsed_body = Connection.new(credentials).post(uri.path, template.render)
-        Presenter::Tag.new(parsed_body["entry"])
+        response = Connection.new.post(:path => uri.path, :body => template.render, :headers => auth_header)
+
+        Presenter::Tag.new(MultiXml.parse(response.body)["entry"])
       end
     end
   end

data/lib/picasa/client.rb

@@ -1,13 +1,15 @@
 module Picasa
   class Client
-    attr_reader :credentials
+    attr_reader :user_id, :password, :authorization_header
 
     # @param [Hash] credentials
     # @option credentials [String] :user_id google username/email
     # @option credentials [String] :password password for given username/email
+    # @option credentials [String] :authorization_header custom authorization header (i.e. taken from OAuth2)
     def initialize(credentials = {})
-      credentials[:user_id] || raise(ArgumentError, "You must specify user_id")
-      @credentials = credentials
+      @user_id              = credentials[:user_id] || raise(ArgumentError, "You must specify user_id")
+      @password             = credentials[:password]
+      @authorization_header = credentials[:authorization_header]
     end
 
     # @return [API::Album]
@@ -18,6 +20,7 @@ module Picasa
     #   album_list.title
     #   # => "My album"
     def album
+      authenticate if authenticates?
       API::Album.new(credentials)
     end
 
@@ -29,6 +32,7 @@ module Picasa
     #   photo.id
     #   # => "4322232322421"
     def photo
+      authenticate if authenticates?
       API::Photo.new(credentials)
     end
 
@@ -40,7 +44,45 @@ module Picasa
     #   tag_list.title
     #   # => "holidays"
     def tag
+      authenticate if authenticates?
       API::Tag.new(credentials)
     end
+
+    # @return [String]
+    def authenticate
+      response = Connection.new.post(
+        :host => API_AUTH_URL,
+        :headers => {"Content-Type" => "application/x-www-form-urlencoded"},
+        :path => "/accounts/ClientLogin",
+        :body => Utils.inline_query(
+          "accountType" => "HOSTED_OR_GOOGLE",
+          "Email"       => user_id,
+          "Passwd"      => password,
+          "service"     => "lh2",
+          "source"      => "ruby-gem-v#{VERSION}"
+        )
+      )
+
+      key = extract_auth_key(response.body)
+      @authorization_header = "GoogleLogin auth=#{key}"
+    end
+
+    private
+
+    def authenticates?
+      password && authorization_header.nil?
+    end
+
+    def credentials
+      {:user_id => user_id}.tap do |credentials|
+        credentials[:authorization_header] = authorization_header if authorization_header
+      end
+    end
+
+    def extract_auth_key(data)
+      response = data.split("\n").map { |v| v.split("=") }
+      params = Hash[response]
+      params["Auth"]
+    end
   end
 end

data/lib/picasa/connection.rb

@@ -4,13 +4,6 @@ require "uri"
 
 module Picasa
   class Connection
-    attr_reader :user_id, :password
-
-    def initialize(credentials = {})
-      @user_id  = credentials.fetch(:user_id)
-      @password = credentials.fetch(:password, nil)
-    end
-
     def http(url = API_URL)
       uri = URI.parse(url)
       http = Net::HTTP.new(uri.host, uri.port)
@@ -18,40 +11,41 @@ module Picasa
       http
     end
 
-    def get(path, params = {})
-      authenticate if auth?
-
-      path = path_with_params(path, params)
-      request = Net::HTTP::Get.new(path, headers)
-      response = handle_response(http.request(request))
-      MultiXml.parse(response.body)
+    # @param [Hash] params request arguments
+    # @option params [String] :host host of request
+    # @option params [String] :path request path
+    # @option params [String] :body request body (for POST)
+    # @option params [String] :query request url query
+    # @option params [String] :headers request headers
+    def get(params = {})
+      params[:headers] ||= {}
+      params[:query] ||= {}
+      params[:host] ||= API_URL
+
+      path = path_with_query(params[:path], params[:query])
+      request = Net::HTTP::Get.new(path, headers.merge(params[:headers]))
+      handle_response(http(params[:host]).request(request))
     end
 
-    def post(path, body, custom_headers = {})
-      authenticate if auth?
+    def post(params = {})
+      params[:headers] ||= {}
+      params[:host] ||= API_URL
 
-      request = Net::HTTP::Post.new(path, headers.merge(custom_headers))
-      request.body = body
-      response = handle_response(http.request(request))
-      MultiXml.parse(response.body)
+      request = Net::HTTP::Post.new(params[:path], headers.merge(params[:headers]))
+      request.body = params[:body]
+      handle_response(http(params[:host]).request(request))
     end
 
-    def delete(path, custom_headers = {})
-      authenticate if auth?
+    def delete(params = {})
+      params[:headers] ||= {}
+      params[:host] ||= API_URL
 
-      request = Net::HTTP::Delete.new(path, headers.merge(custom_headers))
-      handle_response(http.request(request))
+      request = Net::HTTP::Delete.new(params[:path], headers.merge(params[:headers]))
+      handle_response(http(params[:host]).request(request))
     end
 
-    def inline_params(params)
-      params.map do |key, value|
-        dasherized = key.to_s.gsub("_", "-")
-        "#{CGI.escape(dasherized)}=#{CGI.escape(value.to_s)}"
-      end.join("&")
-    end
-
-    def path_with_params(path, params = {})
-      path = path + "?" + inline_params(params) unless params.empty?
+    def path_with_query(path, query = {})
+      path = path + "?" + Utils.inline_query(query) unless query.empty?
       URI.parse(path).to_s
     end
 
@@ -74,38 +68,10 @@ module Picasa
 
     def headers
       {
-        "User-Agent"    => client_name,
+        "User-Agent"    => "ruby-gem-v#{VERSION}",
         "GData-Version" => API_VERSION,
         "Content-Type"  => "application/atom+xml"
-      }.tap do |headers|
-        headers["Authorization"] = "GoogleLogin auth=#{@auth_key}" if @auth_key
-      end
-    end
-
-    def auth?
-      !password.nil?
-    end
-
-    def authenticate
-      data = inline_params({"accountType" => "HOSTED_OR_GOOGLE",
-                            "Email"       => user_id,
-                            "Passwd"      => password,
-                            "service"     => "lh2",
-                            "source"      => client_name})
-
-      response = handle_response(http(API_AUTH_URL).post("/accounts/ClientLogin", data))
-
-      @auth_key = extract_auth_key(response.body)
-    end
-
-    def extract_auth_key(data)
-      response = data.split("\n").map { |v| v.split("=") }
-      params = Hash[response]
-      params["Auth"]
-    end
-
-    def client_name
-      "ruby-gem-v#{Picasa::VERSION}"
+      }
     end
   end
 end

data/lib/picasa/utils.rb

@@ -39,6 +39,13 @@ module Picasa
       end
     end
 
-    module_function :safe_retrieve, :array_wrap, :map_to_integer, :map_to_boolean, :map_to_date
+    def inline_query(query)
+      query.map do |key, value|
+        dasherized = key.to_s.gsub("_", "-")
+        "#{CGI.escape(dasherized)}=#{CGI.escape(value.to_s)}"
+      end.join("&")
+    end
+
+    module_function :safe_retrieve, :array_wrap, :map_to_integer, :map_to_boolean, :map_to_date, :inline_query
   end
 end

data/lib/picasa/version.rb

@@ -1,3 +1,3 @@
 module Picasa
-  VERSION = "0.5.1"
+  VERSION = "0.5.2"
 end

data/test/client_test.rb

@@ -1,14 +1,35 @@
 require "helper"
 
 describe Picasa::Client do
-  it "has credentials" do
-    client = Picasa::Client.new(:user_id => "john.doe")
-    assert_equal({:user_id => "john.doe"}, client.credentials)
-  end
-
   it "raises ArgumentError when user_id is missing" do
     assert_raises(Picasa::ArgumentError, /user_id/) do
       Picasa::Client.new
     end
   end
+
+  it "allows to assign custom authorization header" do
+    client = Picasa::Client.new(:user_id => "john.doe", :authorization_header => "OAuth token")
+    assert_equal "OAuth token", client.authorization_header
+  end
+
+  describe "#authenticate" do
+    it "successfully authenticates" do
+      client = Picasa::Client.new(:user_id => "john.doe@domain.com", :password => "secret")
+
+      stub_request(:post, "https://www.google.com/accounts/ClientLogin").to_return(fixture("auth/success.txt"))
+
+      client.authenticate
+      refute_nil client.authorization_header
+    end
+
+    it "raises an ForbiddenError when authentication failed" do
+      client = Picasa::Client.new(:user_id => "john.doe@domain.com", :password => "invalid")
+
+      stub_request(:post, "https://www.google.com/accounts/ClientLogin").to_return(fixture("exceptions/forbidden.txt"))
+
+      assert_raises(Picasa::ForbiddenError) do
+        client.authenticate
+      end
+    end
+  end
 end

data/test/connection_test.rb

@@ -1,86 +1,42 @@
-# -*- encoding: utf-8 -*-
 require "helper"
 
 describe Picasa::Connection do
   before do
-    @connection = Picasa::Connection.new(:user_id => "joe.doe")
+    @connection = Picasa::Connection.new
   end
 
-  describe "#inline_params" do
-    it "converts params to inline style" do
-      params = @connection.inline_params({:alt => "json", :kind => "photo"})
-      # make ruby 1.8 tests pass
-      assert_equal "alt=json", params.split("&").sort[0]
-      assert_equal "kind=photo", params.split("&").sort[1]
-    end
-
-    it "changes param keys underscore to dash" do
-      params = @connection.inline_params({:max_results => 10})
-      assert_equal "max-results=10", params
-    end
-
-    it "escapes values" do
-      params = @connection.inline_params({:kind => "żółć"})
-      assert_equal "kind=%C5%BC%C3%B3%C5%82%C4%87", params
-    end
-  end
-
-  describe "#path_with_params" do
+  describe "#path_with_query" do
     it "returns path when no params provided" do
-      path = @connection.path_with_params("/data/feed/api")
+      path = @connection.path_with_query("/data/feed/api")
       assert_equal "/data/feed/api", path
     end
 
     it "adds params to path" do
-      path = @connection.path_with_params("/data/feed/api", {:q => "bomb"})
+      path = @connection.path_with_query("/data/feed/api", {:q => "bomb"})
       assert_equal "/data/feed/api?q=bomb", path
     end
   end
 
   it "raises NotFound exception when 404 returned" do
-    connection = Picasa::Connection.new(:user_id => "john.doe@domain.com")
-    uri        = URI.parse("/data/feed/api/user/#{connection.user_id}/albumid/non-existing")
+    connection = Picasa::Connection.new
+    uri        = URI.parse("/data/feed/api/user/some.user/albumid/non-existing")
 
     stub_request(:get, "https://picasaweb.google.com" + uri.path).to_return(fixture("exceptions/not_found.txt"))
 
     assert_raises Picasa::NotFoundError, "Invalid entity id: non-existing" do
-      connection.get(uri.path)
+      connection.get(:path => uri.path)
     end
   end
 
   it "raises PreconditionFailed exception when 412 returned" do
-    connection = Picasa::Connection.new(:user_id => "john.doe@domain.com", :password => "secret")
-    uri        = URI.parse("/data/feed/api/user/#{connection.user_id}/albumid/123")
+    connection = Picasa::Connection.new
+    uri        = URI.parse("/data/feed/api/user/some.user/albumid/123")
 
     stub_request(:post, "https://www.google.com/accounts/ClientLogin").to_return(fixture("auth/success.txt"))
     stub_request(:delete, "https://picasaweb.google.com" + uri.path).to_return(fixture("exceptions/precondition_failed.txt"))
 
     assert_raises Picasa::PreconditionFailedError, "Mismatch: etags = [oldetag], version = [7]" do
-      connection.delete(uri.path, {"If-Match" => "oldetag"})
-    end
-  end
-
-  describe "authentication" do
-    it "successfully authenticates" do
-      connection = Picasa::Connection.new(:user_id => "john.doe@domain.com", :password => "secret")
-      uri        = URI.parse("/data/feed/api/user/#{connection.user_id}")
-
-      stub_request(:post, "https://www.google.com/accounts/ClientLogin").to_return(fixture("auth/success.txt"))
-      stub_request(:get, "https://picasaweb.google.com/data/feed/api/user/john.doe@domain.com").to_return(fixture("album/album-list.txt"))
-
-      connection.expects(:authenticate).returns(:result)
-      refute_nil connection.get(uri.path)
-    end
-
-    it "raises an ResponseError when authentication failed" do
-      connection = Picasa::Connection.new(:user_id => "john.doe@domain.com", :password => "secret")
-      uri        = URI.parse("/data/feed/api/user/#{connection.user_id}")
-
-      stub_request(:post, "https://www.google.com/accounts/ClientLogin").to_return(fixture("exceptions/forbidden.txt"))
-
-      assert_raises(Picasa::ForbiddenError) do
-        connection.get(uri.path)
-      end
+      connection.delete(:path => uri.path, :headers => {"If-Match" => "oldetag"})
     end
   end
 end

data/test/helper.rb

@@ -15,7 +15,7 @@ class MiniTest::Unit::TestCase
   end
 
   def image_path(filename)
-    ::File.join("test", "fixtures", filename)
+    File.join("test", "fixtures", filename)
   end
 
   # Recording response is as simple as writing in terminal:

data/test/utils_test.rb

@@ -1,3 +1,4 @@
+# -*- encoding: utf-8 -*-
 require "helper"
 
 describe Picasa::Utils do
@@ -81,4 +82,23 @@ describe Picasa::Utils do
       assert_nil Picasa::Utils.map_to_boolean("truthy")
     end
   end
+
+  describe "#inline_query" do
+    it "converts params to inline style" do
+      params = Picasa::Utils.inline_query({:alt => "json", :kind => "photo"})
+      # make ruby 1.8 tests pass
+      assert_equal "alt=json", params.split("&").sort[0]
+      assert_equal "kind=photo", params.split("&").sort[1]
+    end
+
+    it "changes param keys underscore to dash" do
+      params = Picasa::Utils.inline_query({:max_results => 10})
+      assert_equal "max-results=10", params
+    end
+
+    it "escapes values" do
+      params = Picasa::Utils.inline_query({:kind => "żółć"})
+      assert_equal "kind=%C5%BC%C3%B3%C5%82%C4%87", params
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: picasa
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-15 00:00:00.000000000 Z
+date: 2012-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_xml