ruby-picasa 0.2.0 → 0.2.1

data/History.txt

@@ -1,3 +1,14 @@
+=== 0.2.1 / 2009-03-05
+
+* Now fully documented.
+* Full spec suite with 100% coverage.
+* Even easier to use the api.
+* Move thumbnail and url to Base so it can be used for Photos and Albums. 
+* Enable url to optionally return width and height for image_tag.
+* Use the numeric gphoto:id as id and rename tho standard atom feed id to feed_id
+* Fixed handling of cropped thumbnails and automatically query for valid thumbnail sizes.
+* Stopped using the wrong url to #load albums. Renamed method to #feed.
+
 === 0.2.0 / 2009-02-25
 
 * First public release.

data/Rakefile

@@ -20,4 +20,7 @@ Spec::Rake::SpecTask.new(:spec) do |t|
   t.spec_opts = ['--colour', '--format', 'specdoc']
 end
 
+Rake::Task[:default].clear
+task :default => [:spec]
+
 # vim: syntax=Ruby

data/lib/ruby_picasa.rb

@@ -6,7 +6,7 @@ require 'net/https'
 require File.join(File.dirname(__FILE__), 'ruby_picasa/types')
 
 module RubyPicasa
-  VERSION = '0.2.0'
+  VERSION = '0.2.1'
 
   class PicasaError < StandardError
   end
@@ -15,20 +15,53 @@ module RubyPicasa
   end
 end
 
+# == Authorization
+#
+# RubyPicasa makes authorizing a Rails app easy. It is a two step process: 
+#
+# First redirect the user to the authorization url, if the user authorizes your
+# application, Picasa will redirect the user back to the url you specify (in
+# this case authorize_picasa_url). 
+#
+# Next, pass the Rails request object to the authorize_token method which will
+# make the api call to upgrade the token and if successful return an initialized
+# Picasa session object ready to use. The token object can be retrieved from the
+# token attribute.
+#
+#   class PicasaController < ApplicationController
+#     def request_authorization
+#       redirect_to Picasa.authorization_url(authorize_picasa_url)
+#     end
+#
+#     def authorize
+#       if Picasa.token_in_request?(request)
+#         begin
+#           picasa = Picasa.authorize_request(request)
+#           current_user.picasa_token = picasa.token
+#           current_user.save
+#           flash[:notice] = 'Picasa authorization complete'
+#           redirect_to picasa_path
+#         rescue PicasaTokenError => e
+#           # 
+#           @error = e.message
+#           render
+#         end
+#       end
+#     end
+#   end
+#
 class Picasa
-  include RubyPicasa
-
   class << self
     # The user must be redirected to this address to authorize the application
     # to access their Picasa account. The token_from_request and
     # authorize_request methods can be used to handle the resulting redirect
     # from Picasa.
-    def authorization_url(return_to_url, request_session = true, secure = false)
+    def authorization_url(return_to_url, request_session = true, secure = false, authsub_url = nil)
       session = request_session ? '1' : '0'
       secure = secure ? '1' : '0'
       return_to_url = CGI.escape(return_to_url)
-      url = 'http://www.google.com/accounts/AuthSubRequest'
-      "#{ url }?scope=http%3A%2F%2Fpicasaweb.google.com%2Fdata%2F&session=#{ session }&secure=#{ secure }&next=#{ return_to_url }"
+      url = authsub_url || 'http://www.google.com/accounts/AuthSubRequest'
+      "#{ url }?scope=http%3A%2F%2F#{ host }%2Fdata%2F&session=#{ session }&secure=#{ secure }&next=#{ return_to_url }"
     end
 
     # Takes a Rails request object and extracts the token from it. This would
@@ -38,10 +71,14 @@ class Picasa
       if token = request.params['token']
         return token
       else
-        raise PicasaTokenError, 'No Picasa authorization token was found.'
+        raise RubyPicasa::PicasaTokenError, 'No Picasa authorization token was found.'
       end
     end
 
+    def token_in_request?(request)
+      request.params['token']
+    end
+
     # Takes a Rails request object as in token_from_request, then makes the
     # token authorization request to produce the permanent token. This will
     # only work if request_session was true when you created the
@@ -52,10 +89,20 @@ class Picasa
       p
     end
 
+    # The url to make requests to without the protocol or path.
     def host
-      'picasaweb.google.com'
+      @host ||= 'picasaweb.google.com'
+    end
+
+    # In the unlikely event that you need to access this api on a different url,
+    # you can set it here. It defaults to picasaweb.google.com
+    def host=(h)
+      @host = h
     end
 
+    # A simple test used to determine if a given resource id is it's full
+    # identifier url. This is not intended to be a general purpose method as the
+    # test is just a check for the http/https protocol prefix.
     def is_url?(path)
       path.to_s =~ %r{\Ahttps?://}
     end
@@ -99,6 +146,12 @@ class Picasa
         path = path.join('/')
       end
       options['kind'] = 'photo' if args[:recent_photos] or args[:album_id]
+      if args[:thumbsize] and not args[:thumbsize].split(/,/).all? { |s| RubyPicasa::Photo::VALID.include?(s) }
+        raise RubyPicasa::PicasaError, 'Invalid thumbsize.'
+      end
+      if args[:imgmax] and not RubyPicasa::Photo::VALID.include?(args[:imgmax])
+        raise RubyPicasa::PicasaError, 'Invalid imgmax.'
+      end
       [:max_results, :start_index, :tag, :q, :kind,
        :access, :thumbsize, :imgmax, :bbox, :l].each do |arg|
         options[arg.to_s.dasherize] = args[arg] if args[arg]
@@ -112,6 +165,8 @@ class Picasa
 
     private
 
+    # Extract the path and a hash of key/value pairs from a given url with
+    # optional query string.
     def parse_url(args)
       url = args[:url]
       url ||= args[:user_id] if is_url?(args[:user_id]) 
@@ -133,6 +188,7 @@ class Picasa
     end
   end
 
+  # The AuthSub token currently in use.
   attr_reader :token
 
   def initialize(token)
@@ -140,6 +196,8 @@ class Picasa
     @request_cache = {}
   end
 
+  # Attempt to upgrade the current AuthSub token to a permanent one. This only
+  # works if the Picasa session is initialized with a single use token.
   def authorize_token!
     http = Net::HTTP.new("www.google.com", 443)
     http.use_ssl = true
@@ -153,15 +211,22 @@ class Picasa
     @token
   end
 
-  def user(user_id_or_url = 'default', options = {})
-    get(options.merge(:user_id => user_id_or_url))
+  # Retrieve a RubyPicasa::User record including all user albums.
+  def user(user_id_or_url = nil, options = {})
+    options = make_options(:user_id, user_id_or_url, options)
+    get(options)
   end
 
+  # Retrieve a RubyPicasa::Album record. If you pass an id or a feed url it will
+  # include all photos. If you pass an entry url, it will not include photos.
   def album(album_id_or_url, options = {})
-    get(options.merge(:album_id => album_id_or_url))
+    options = make_options(:album_id, album_id_or_url, options)
+    get(options)
   end
 
-  # This request does not require authentication.
+  # This request does not require authentication. Returns a RubyPicasa::Search
+  # object containing the first 10 matches. You can call #next and #previous to
+  # navigate the paginated results on the Search object.
   def search(q, options = {})
     h = {}
     h[:max_results] = 10
@@ -171,27 +236,32 @@ class Picasa
     get(h.merge(options).merge(:q => q))
   end
 
+  # Retrieve a RubyPicasa object determined by the type of xml results returned
+  # by Picasa. Any supported type of RubyPicasa resource can be requested with
+  # this method.
   def get_url(url, options = {})
-    get(options.merge(:url => url))
+    options = make_options(:url, url, options)
+    get(options)
   end
 
-  def recent_photos(user_id_or_url = 'default', options = {})
-    if user_id_or_url.is_a?(Hash)
-      options = user_id_or_url
-      user_id_or_url = 'default'
-    end
-    h = {}
-    h[:user_id] = user_id_or_url
-    h[:recent_photos] = true
-    get(options.merge(h))
+  # Retrieve a RubyPicasa::RecentPhotos object, essentially a User object which
+  # contains photos instead of albums.
+  def recent_photos(user_id_or_url, options = {})
+    options = make_options(:user_id, user_id_or_url, options)
+    options[:recent_photos] = true
+    get(options)
   end
 
+  # Retrieves the user's albums and finds the first one with a matching title.
+  # Returns a RubyPicasa::Album object.
   def album_by_title(title, options = {})
     if a = user.albums.find { |a| title === a.title }
       a.load options
     end
   end
 
+  # Returns the raw xml from Picasa. See the Picasa.path method for valid
+  # options.
   def xml(options = {})
     http = Net::HTTP.new(Picasa.host, 80)
     path = Picasa.path(options)
@@ -201,14 +271,31 @@ class Picasa
     end
   end
 
+  private
+
+  # If the value parameter is a hash, treat it as the options hash, otherwise
+  # insert the value into the hash with the key specified.
+  #
+  # Uses merge to ensure that a new hash object is returned to prevent caller's
+  # has from accidentally being modified.
+  def make_options(key, value, options)
+    if value.is_a? Hash
+      {}.merge value
+    else
+      options ||= {}
+      options.merge(key => value)
+    end
+  end
+
+  # Combines the cached xml request with the class_from_xml factory. See the
+  # Picasa.path method for valid options.
   def get(options = {})
     with_cache(options) do |xml|
       class_from_xml(xml)
     end
   end
 
-  private
-
+  # Returns the header data needed to make AuthSub requests.
   def auth_header
     if token
       { "Authorization" => %{AuthSub token="#{ token }"} }
@@ -217,6 +304,7 @@ class Picasa
     end
   end
 
+  # Caches the raw xml returned from the API. Keyed on request url.
   def with_cache(options)
     path = Picasa.path(options)
     @request_cache.delete(path) if options[:reload]
@@ -231,6 +319,10 @@ class Picasa
     end
   end
 
+  # Returns the first xml element in the document (see
+  # Objectify::Xml.first_element) with the xml data types of the feed and first entry
+  # element in the document, used to determine which RubyPicasa object should
+  # be initialized to handle the data.
   def xml_data(xml)
     if xml = Objectify::Xml.first_element(xml)
       # There is something wrong with Nokogiri xpath/css search with
@@ -244,6 +336,8 @@ class Picasa
     end
   end
 
+  # Initialize the correct RubyPicasa object depending on the type of feed and
+  # entries in the document.
   def class_from_xml(xml)
     xml, feed_scheme, entry_scheme = xml_data(xml)
     if xml
@@ -251,28 +345,28 @@ class Picasa
       when /#user$/
         case entry_scheme
         when /#album$/
-          User.new(xml, self)
+          RubyPicasa::User.new(xml, self)
         when /#photo$/
-          RecentPhotos.new(xml, self)
+          RubyPicasa::RecentPhotos.new(xml, self)
         end
       when /#album$/
         case entry_scheme
         when nil, /#photo$/
-          Album.new(xml, self)
+          RubyPicasa::Album.new(xml, self)
         end
       when /#photo$/
         case entry_scheme
         when /#photo$/
-          Search.new(xml, self)
+          RubyPicasa::Search.new(xml, self)
         when nil
-          Photo.new(xml, self)
+          RubyPicasa::Photo.new(xml, self)
         end
       end
       if r
         r.session = self
         r
       else
-        raise PicasaError, "Unknown feed type\n feed:  #{ feed_scheme }\n entry: #{ entry_scheme }"
+        raise RubyPicasa::PicasaError, "Unknown feed type\n feed:  #{ feed_scheme }\n entry: #{ entry_scheme }"
       end
     end
   end

data/lib/ruby_picasa/types.rb

@@ -2,34 +2,43 @@
 # about. If you care about them, please feel free to add support for them,
 # which should not be difficult.
 #
-# Plural attribute names will be treated as arrays unless the element name
-# in the xml document is already plural. (Convention seems to be to label
-# repeating elements in the singular.)
-#
-# If an attribute should be a non-trivial datatype, define the mapping from
-# the fully namespaced attribute name to the class you wish to use in the
-# class method #types.
-#
-# Define which namespaces you support in the class method #namespaces. Any
+# Declare which namespaces are supported with the namespaces method. Any
 # elements defined in other namespaces are automatically ignored.
 module RubyPicasa
+  # attributes :url, :height, :width
   class PhotoUrl < Objectify::ElementParser
     attributes :url, :height, :width
   end
 
 
   class ThumbnailUrl < PhotoUrl
+
+    # The name of the current thumbnail. For possible names, see Photo#url
     def thumb_name
-      url.scan(%r{/([^/]+)/[^/]+$}).flatten.compact.first
+      name = url.scan(%r{/s([^/]+)/[^/]+$}).flatten.compact.first
+      if name
+        name.sub(/-/, '')
+      end
     end
   end
 
 
+  # Base class for User, Photo and Album types, not used independently.
+  #
+  #   attribute :id, 'gphoto:id'
+  #   attribute :feed_id, 'id'
+  #   attributes :updated, :title
+  #   
+  #   has_many :links, Objectify::Atom::Link, 'link'
+  #   has_one :content, PhotoUrl, 'media:content'
+  #   has_many :thumbnails, ThumbnailUrl, 'media:thumbnail'
+  #   has_one :author, Objectify::Atom::Author, 'author'
   class Base < Objectify::DocumentParser
     namespaces :openSearch, :gphoto, :media
     flatten 'media:group'
 
-    attribute :id, 'id'
+    attribute :id, 'gphoto:id'
+    attribute :feed_id, 'id'
     attributes :updated, :title
 
     has_many :links, Objectify::Atom::Link, 'link'
@@ -37,14 +46,16 @@ module RubyPicasa
     has_many :thumbnails, ThumbnailUrl, 'media:thumbnail'
     has_one :author, Objectify::Atom::Author, 'author'
 
+    # Return the link object with the specified rel attribute value.
     def link(rel)
-      links.find { |l| l.rel == rel }
+      links.find { |l| rel === l.rel }
     end
 
     def session=(session)
       @session = session
     end
 
+    # Should return the Picasa instance that retrieved this data.
     def session
       if @session
         @session
@@ -53,24 +64,93 @@ module RubyPicasa
       end
     end
 
-    def load(options = {})
-      session.get_url(id, options)
+    # Retrieves the data feed at the url of the current record.
+    def feed(options = {})
+      session.get_url(link('http://schemas.google.com/g/2005#feed').href, options)
     end
 
+    # If the results are paginated, retrieve the next page.
     def next
       if link = link('next')
         session.get_url(link.href)
       end
     end
 
+    # If the results are paginated, retrieve the previous page.
     def previous
       if link = link('previous')
         session.get_url(link.href)
       end
     end
+
+    # Thumbnail names are by image width in pixels. Sizes up to 160 may be
+    # either cropped (square) or uncropped:
+    #
+    #   cropped:        32c, 48c, 64c, 72c, 144c, 160c
+    #   uncropped:      32u, 48u, 64u, 72u, 144u, 160u
+    #
+    # The rest of the image sizes should be specified by the desired width
+    # alone. Widths up to 800px may be embedded on a webpage:
+    # 
+    #   embeddable:     200, 288, 320, 400, 512, 576, 640, 720, 800
+    #   not embeddable: 912, 1024, 1152, 1280, 1440, 1600
+    #
+    # if a options is set to true or a hash is given, the width and height of
+    # the image will be added to the hash and returned. Useful for passing to
+    # the rails image_tag helper as follows:
+    #
+    #   image_tag(*image.url('72c', { :class => 'thumb' }))
+    #   
+    # which results in:
+    #
+    #   <img href="..." class="thumb" width="72" height="72">
+    #
+    def url(thumb_name = nil, options = nil)
+      url = nil
+      if thumb_name.is_a? Hash
+        options = thumb_name
+        thumb_name = nil
+      end
+      options = {} if options and not options.is_a? Hash
+      if thumb_name
+        if thumb = thumbnail(thumb_name)
+          url = thumb.url
+          options = { :width => thumb.width, :height => thumb.height }.merge(options) if options
+        end
+      else
+        url = content.url
+        options = { :width => content.width, :height => content.height }.merge(options) if options
+      end
+      if options
+        [url, options]
+      else
+        url
+      end
+    end
+
+    # See +url+ for possible image sizes
+    def thumbnail(thumb_name)
+      raise PicasaError, 'Invalid thumbnail size' unless Photo::VALID.include?(thumb_name.to_s)
+      thumb = thumbnails.find { |t| t.thumb_name == thumb_name }
+      if thumb
+        thumb
+      elsif session
+        f = feed(:thumbsize => thumb_name)
+        if f
+          f.thumbnails.first
+        end
+      end
+    end
   end
 
 
+  # Includes attributes and associations defined on Base, plus:
+  #
+  #   attributes :total_results, # represents total number of albums
+  #     :start_index,
+  #     :items_per_page,
+  #     :thumbnail
+  #   has_many :entries, :Album, 'entry'
   class User < Base
     attributes :total_results, # represents total number of albums
       :start_index,
@@ -78,15 +158,20 @@ module RubyPicasa
       :thumbnail
     has_many :entries, :Album, 'entry'
 
+    # The current page of albums associated to the user.
     def albums
       entries
     end
   end
 
 
+  # Includes attributes and associations defined on Base and User, plus:
+  #
+  #   has_many :entries, :Photo, 'entry'
   class RecentPhotos < User
     has_many :entries, :Photo, 'entry'
 
+    # The current page of recently updated photos associated to the user.
     def photos
       entries
     end
@@ -95,11 +180,23 @@ module RubyPicasa
   end
 
 
+  # Includes attributes and associations defined on Base, plus:
+  #
+  #   attributes :published,
+  #     :summary,
+  #     :rights,
+  #     :name,
+  #     :access,
+  #     :numphotos, # number of pictures in this album
+  #     :total_results, # number of pictures matching this 'search'
+  #     :start_index,
+  #     :items_per_page,
+  #     :allow_downloads
+  #   has_many :entries, :Photo, 'entry'
   class Album < Base
     attributes :published,
       :summary,
       :rights,
-      :gphoto_id,
       :name,
       :access,
       :numphotos, # number of pictures in this album
@@ -109,19 +206,25 @@ module RubyPicasa
       :allow_downloads
     has_many :entries, :Photo, 'entry'
 
+    # True if this album's rights are set to public
     def public?
       rights == 'public'
     end
 
+    # True if this album's rights are set to private
     def private?
       rights == 'private'
     end
 
+    # The current page of photos in the album.
     def photos(options = {})
       if entries.blank? and !@photos_requested
         @photos_requested = true
-        self.session ||= parent.session
-        self.entries = session.album(id, options).entries if self.session
+        if session and data = feed
+          self.entries = data.entries 
+        else
+          []
+        end
       else
         entries
       end
@@ -130,13 +233,35 @@ module RubyPicasa
 
 
   class Search < Album
+    # The current page of photos matching the search.
+    def photos(options = {})
+      super
+    end
   end
 
 
+  # Includes attributes and associations defined on Base, plus:
+  #
+  #   attributes :published,
+  #     :summary,
+  #     :version, # can use to determine if need to update...
+  #     :position,
+  #     :albumid, # useful from the recently updated feed for instance.
+  #     :width,
+  #     :height,
+  #     :description,
+  #     :keywords,
+  #     :credit
+  #   has_one :author, Objectify::Atom::Author, 'author'
   class Photo < Base
+    CROPPED = %w[ 32c 48c 64c 72c 144c 160c ]
+    UNCROPPED = %w[ 32u 48u 64u 72u 144u 160u 32 48 64 72 144 160 ]
+    MEDIUM = %w[ 200 288 320 400 512 576 640 720 800 ]
+    LARGE = %w[ 912 1024 1152 1280 1440 1600 ]
+    VALID = CROPPED + UNCROPPED + MEDIUM + LARGE
+
     attributes :published,
       :summary,
-      :gphoto_id,
       :version, # can use to determine if need to update...
       :position,
       :albumid, # useful from the recently updated feed for instance.
@@ -147,19 +272,6 @@ module RubyPicasa
       :credit
     has_one :author, Objectify::Atom::Author, 'author'
 
-    def url(thumb_name = nil)
-      if thumb_name
-        if thumb = thumbnail(thumb_name)
-          thumb.url
-        end
-      else
-        content.url
-      end
-    end
-
-    def thumbnail(thumb_name)
-      thumbnails.find { |t| t.thumb_name == thumb_name }
-    end
   end
 end
 

data/spec/ruby_picasa/types_spec.rb

@@ -3,8 +3,8 @@ require File.join(File.dirname(__FILE__), '../spec_helper')
 include RubyPicasa
 
 describe 'a RubyPicasa document', :shared => true do
-  it 'should have an id' do
-    @object.id.should_not be_nil
+  it 'should have a feed_id' do
+    @object.feed_id.should_not be_nil
   end
 
   it 'should have an author' do
@@ -25,9 +25,11 @@ describe 'a RubyPicasa document', :shared => true do
     @object.next.should be_nil if @object.link('next').nil?
   end
 
-  it 'should load' do
-    @object.session.expects(:get_url).with(@object.id, {})
-    @object.load
+  it 'should get the feed' do
+    @object.session.expects(:get_url).with(@object.feed_id.
+                                            gsub(/entry/, 'feed').
+                                            gsub(/default/, 'liz'), {})
+    @object.feed
   end
 
   it 'should have links' do
@@ -119,6 +121,11 @@ describe Album do
     @album.session = mock('session')
   end
 
+  it 'should have a numeric id' do
+    @object.id.should_not be_nil
+    @object.id.to_s.should match(/\A\d+\Z/)
+  end
+
   it 'should have 1 entry' do
     @album.entries.length.should == 1
   end
@@ -137,9 +144,24 @@ describe Album do
     it 'should request photos if needed' do
       @album.entries = []
       new_album = mock('album', :entries => [:photo])
-      @album.session.expects(:album).with(@album.id, {}).returns(new_album)
+      @album.session.expects(:get_url).with(@album.link(/feed/).href, {}).returns(new_album)
       @album.photos.should == [:photo]
     end
+
+    it 'should not request photos twice if there are none' do
+      @album.entries = []
+      new_album = mock('album', :entries => [])
+      @album.session.expects(:get_url).with(@album.link(/feed/).href, {}).times(1).returns(new_album)
+      @album.photos.should == []
+      # note that mocks are set to accept only one get_url request
+      @album.photos.should == []
+    end
+
+    it 'should not request photos if there is no session' do
+      @album.entries = []
+      @album.expects(:session).returns(nil)
+      @album.photos.should == []
+    end
   end
 
   it 'should be public' do
@@ -175,16 +197,64 @@ describe Album do
       end
     end
 
+    it 'should have a numeric id' do
+      @object.id.should_not be_nil
+      @object.id.to_s.should match(/\A\d+\Z/)
+    end
+
     it 'should have a default url' do
       @photo.url.should == 'http://lh5.ggpht.com/liz/SKXR5BoXabI/AAAAAAAAAzs/tJQefyM4mFw/invisible_bike.jpg'
     end
 
     it 'should have thumbnail urls' do
-      @photo.url('s72').should == 'http://lh5.ggpht.com/liz/SKXR5BoXabI/AAAAAAAAAzs/tJQefyM4mFw/s72/invisible_bike.jpg'
+      @photo.url('72').should == 'http://lh5.ggpht.com/liz/SKXR5BoXabI/AAAAAAAAAzs/tJQefyM4mFw/s72/invisible_bike.jpg'
+    end
+
+    it 'should have a default url with options true' do
+      @photo.url(nil, true).should == [
+        'http://lh5.ggpht.com/liz/SKXR5BoXabI/AAAAAAAAAzs/tJQefyM4mFw/invisible_bike.jpg',
+        { :width => 410, :height => 295 }
+      ]
+    end
+
+    it 'should have a default url with options' do
+      @photo.url(nil, :id => 'p').should == [
+        'http://lh5.ggpht.com/liz/SKXR5BoXabI/AAAAAAAAAzs/tJQefyM4mFw/invisible_bike.jpg',
+        { :width => 410, :height => 295, :id => 'p' }
+      ]
+    end
+
+    it 'should have a default url with options first' do
+      @photo.url(:id => 'p').should == [
+        'http://lh5.ggpht.com/liz/SKXR5BoXabI/AAAAAAAAAzs/tJQefyM4mFw/invisible_bike.jpg',
+        { :width => 410, :height => 295, :id => 'p' }
+      ]
+    end
+
+    it 'should have thumbnail urls with options' do
+      @photo.url('72', {:class => 'x'}).should == [
+        'http://lh5.ggpht.com/liz/SKXR5BoXabI/AAAAAAAAAzs/tJQefyM4mFw/s72/invisible_bike.jpg',
+        { :width => 72, :height => 52, :class => 'x' }
+      ]
     end
 
     it 'should have thumbnail info' do
-      @photo.thumbnail('s72').width.should == 72
+      @photo.thumbnail('72').width.should == 72
+    end
+
+    it 'should retrieve valid thumbnail info' do
+      photo = mock('photo')
+      thumb = mock('thumb')
+      photo.expects(:thumbnails).returns([thumb])
+      @photo.session.expects(:get_url).with('http://picasaweb.google.com/data/feed/api/user/liz/albumid/5228155363249705041/photoid/5234820919508560306',
+                                      {:thumbsize => '32c'}).returns(photo)
+      @photo.thumbnail('32c').should == thumb
+    end
+
+    it 'should retrieve valid thumbnail info and handle not found' do
+      @photo.session.expects(:get_url).with('http://picasaweb.google.com/data/feed/api/user/liz/albumid/5228155363249705041/photoid/5234820919508560306',
+                                      {:thumbsize => '32c'}).returns(nil)
+      @photo.thumbnail('32c').should be_nil
     end
   end
 end
@@ -208,6 +278,10 @@ describe Search do
     @search.entries.first.should be_an_instance_of(Photo)
   end
 
+  it 'should alias entries to photos' do
+    @search.photos.should == @search.entries
+  end
+
   it 'should request next' do
     @search.session.expects(:get_url).with('http://picasaweb.google.com/data/feed/api/all?q=puppy&start-index=3&max-results=1').returns(:result)
     @search.next.should == :result

data/spec/ruby_picasa_spec.rb

@@ -15,6 +15,18 @@ describe 'Picasa class methods' do
     url.should match(/session=1/)
   end
 
+  describe 'token_in_request?' do
+    it 'should be nil if no token' do
+      request = mock('request', :params => { })
+      Picasa.token_in_request?(request).should be_nil
+    end
+
+    it 'should not be nil if there is a token' do
+      request = mock('request', :params => { 'token' => 'abc' })
+      Picasa.token_in_request?(request).should_not be_nil
+    end
+  end
+
   describe 'token_from_request' do
     it 'should pluck the token from the request' do
       request = mock('request', :params => { 'token' => 'abc' })
@@ -42,10 +54,9 @@ describe 'Picasa class methods' do
     Picasa.is_url?('12323412341').should_not be_true
   end
 
-  it 'should recognize relative urls?' do
-    pending 'not currently needed'
-    Picasa.is_url?('something.com/else').should be_true
-    Picasa.is_url?('/else').should be_true
+  it 'should allow host change' do
+    Picasa.host = 'abc'
+    Picasa.host.should == 'abc'
   end
 
   describe 'path' do
@@ -67,12 +78,25 @@ describe 'Picasa class methods' do
         "/data/feed/api/all"
     end
     [ :max_results, :start_index, :tag, :q, :kind,
-      :access, :thumbsize, :imgmax, :bbox, :l].each do |arg|
+      :access, :bbox, :l].each do |arg|
       it "should add #{ arg } to options" do
         Picasa.path(:url => 'url', arg => '!value').should ==
           "url?#{ arg.to_s.dasherize }=%21value"
       end
     end
+    [ :imgmax, :thumbsize ].each do |arg|
+      it "should raise PicasaError with invalid #{ arg } option" do
+        lambda do
+          Picasa.path(:url => 'url', arg => 'invalid')
+        end.should raise_error(RubyPicasa::PicasaError)
+      end
+    end
+    [ :imgmax, :thumbsize ].each do |arg|
+      it "should add #{ arg } to options" do
+        Picasa.path(:url => 'url', arg => '72').should ==
+          "url?#{ arg.to_s.dasherize }=72"
+      end
+    end
     it 'should ignore unknown options' do
       Picasa.path(:url => 'place', :eggs => 'over_easy').should == 'place'
     end
@@ -151,7 +175,7 @@ describe Picasa do
   end
 
   it 'should get the user' do
-    @p.expects(:get).with(:user_id => 'default')
+    @p.expects(:get).with(:user_id => nil)
     @p.user
   end
 
@@ -177,7 +201,7 @@ describe Picasa do
   end
 
   it 'should get recent photos' do
-    @p.expects(:get).with(:user_id => 'default', :recent_photos => true, :max_results => 10)
+    @p.expects(:get).with(:recent_photos => true, :max_results => 10)
     @p.recent_photos :max_results => 10
   end
 
@@ -223,13 +247,13 @@ describe Picasa do
     it 'should call class_from_xml if with_cache yields' do
       @p.expects(:with_cache).with({}).yields(:xml).returns(:result)
       @p.expects(:class_from_xml).with(:xml)
-      @p.get.should == :result
+      @p.send(:get).should == :result
     end
 
     it 'should do nothing if with_cache does not yield' do
       @p.expects(:with_cache).with({}) # doesn't yield
       @p.expects(:class_from_xml).never
-      @p.get.should be_nil
+      @p.send(:get).should be_nil
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ruby-picasa
 version: !ruby/object:Gem::Version 
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors: 
 - pangloss
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-02 00:00:00 -05:00
+date: 2009-03-05 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -30,7 +30,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.8.3
+        version: 1.9.0
     version: 
 description: Provides a super easy to use object layer for authenticating and accessing Picasa through their API.
 email: