fotonauts-flickr_fu 0.3.2

data/lib/flickr/photos.rb

@@ -0,0 +1,252 @@
+class Flickr::Photos < Flickr::Base
+  def initialize(flickr)
+    @flickr = flickr
+  end
+
+  # Return a list of photos matching some criteria. Only photos visible to the calling user will be returned. To return private or semi-private photos, 
+  # the caller must be authenticated with 'read' permissions, and have permission to view the photos. Unauthenticated calls will only return public photos.
+  # 
+  # == Authentication
+  # This method does not require authentication.
+  # 
+  # == Options
+  # * user_id (Optional)
+  #     The NSID of the user who's photo to search. If this parameter isn't passed then everybody's public photos will be searched. A value of "me" will 
+  #     search against the calling user's photos for authenticated calls.
+  # * tags (Optional)
+  #     A comma-delimited list of tags. Photos with one or more of the tags listed will be returned.
+  # * tag_mode (Optional)
+  #     Either 'any' for an OR combination of tags, or 'all' for an AND combination. Defaults to 'any' if not specified.
+  # * text (Optional)
+  #     A free text search. Photos who's title, description or tags contain the text will be returned.
+  # * min_upload_date (Optional)
+  #     Minimum upload date. Photos with an upload date greater than or equal to this value will be returned. The date should be in the form of a unix timestamp.
+  # * max_upload_date (Optional)
+  #     Maximum upload date. Photos with an upload date less than or equal to this value will be returned. The date should be in the form of a unix timestamp.
+  # * min_taken_date (Optional)
+  #     Minimum taken date. Photos with an taken date greater than or equal to this value will be returned. The date should be in the form of a mysql datetime.
+  # * max_taken_date (Optional)
+  #     Maximum taken date. Photos with an taken date less than or equal to this value will be returned. The date should be in the form of a mysql datetime.
+  # * license (Optional)
+  #     The license id for photos (for possible values see the flickr.photos.licenses.getInfo method). Multiple licenses may be comma-separated.
+  # * sort (Optional)
+  #     The order in which to sort returned photos. Deafults to date-posted-desc. The possible values are: date-posted-asc, date-posted-desc, date-taken-asc, 
+  #     date-taken-desc, interestingness-desc, interestingness-asc, and relevance.
+  # * privacy_filter (Optional)
+  #     Return photos only matching a certain privacy level. This only applies when making an authenticated call to view photos you own. Valid values are:
+  #       1 public photos
+  #       2 private photos visible to friends
+  #       3 private photos visible to family
+  #       4 private photos visible to friends & family
+  #       5 completely private photos
+  # * bbox (Optional)
+  #     A comma-delimited list of 4 values defining the Bounding Box of the area that will be searched. 
+  # 
+  #     The 4 values represent the bottom-left corner of the box and the top-right corner, minimum_longitude, minimum_latitude, maximum_longitude, maximum_latitude. 
+  # 
+  #     Longitude has a range of -180 to 180 , latitude of -90 to 90. Defaults to -180, -90, 180, 90 if not specified. 
+  # 
+  #     Unlike standard photo queries, geo (or bounding box) queries will only return 250 results per page. 
+  # 
+  #     Geo queries require some sort of limiting agent in order to prevent the database from crying. This is basically like the check against "parameterless searches" 
+  #     for queries without a geo component. 
+  # 
+  #     A tag, for instance, is considered a limiting agent as are user defined min_date_taken and min_date_upload parameters — If no limiting factor is passed we 
+  #     return only photos added in the last 12 hours (though we may extend the limit in the future).
+  # * accuracy (Optional)
+  #     Recorded accuracy level of the location information. Current range is 1-16 :
+  #       World level is 1
+  #       Country is ~3
+  #       Region is ~6
+  #       City is ~11
+  #       Street is ~16
+  #     Defaults to maximum value if not specified.
+  # * safe_search (Optional)
+  #     Safe search setting:
+  #       1 for safe.
+  #       2 for moderate.
+  #       3 for restricted.
+  #     (Please note: Un-authed calls can only see Safe content.)
+  # * content_type (Optional)
+  #     Content Type setting:
+  #       1 for photos only.
+  #       2 for screenshots only.
+  #       3 for 'other' only.
+  #       4 for photos and screenshots.
+  #       5 for screenshots and 'other'.
+  #       6 for photos and 'other'.
+  #       7 for photos, screenshots, and 'other' (all).
+  # * machine_tags (Optional)
+  #     Aside from passing in a fully formed machine tag, there is a special syntax for searching on specific properties :
+  #       Find photos using the 'dc' namespace : "machine_tags" => "dc:"
+  #       Find photos with a title in the 'dc' namespace : "machine_tags" => "dc:title="
+  #       Find photos titled "mr. camera" in the 'dc' namespace : "machine_tags" => "dc:title=\"mr. camera\"
+  #       Find photos whose value is "mr. camera" : "machine_tags" => "*:*=\"mr. camera\""
+  #       Find photos that have a title, in any namespace : "machine_tags" => "*:title="
+  #       Find photos that have a title, in any namespace, whose value is "mr. camera" : "machine_tags" => "*:title=\"mr. camera\""
+  #       Find photos, in the 'dc' namespace whose value is "mr. camera" : "machine_tags" => "dc:*=\"mr. camera\""
+  #     Multiple machine tags may be queried by passing a comma-separated list. The number of machine tags you can pass in a single query depends on 
+  #     the tag mode (AND or OR) that you are querying with. "AND" queries are limited to (16) machine tags. "OR" queries are limited to (8).
+  # * machine_tag_mode (Required)
+  #     Either 'any' for an OR combination of tags, or 'all' for an AND combination. Defaults to 'any' if not specified.
+  # * group_id (Optional)
+  #     The id of a group who's pool to search. If specified, only matching photos posted to the group's pool will be returned.
+  # * woe_id (Optional)
+  #     A 32-bit identifier that uniquely represents spatial entities. (not used if bbox argument is present). Experimental. 
+  # 
+  #     Geo queries require some sort of limiting agent in order to prevent the database from crying. This is basically like the check against "parameterless searches" 
+  #     for queries without a geo component. 
+  # 
+  #     A tag, for instance, is considered a limiting agent as are user defined min_date_taken and min_date_upload parameters &emdash; If no limiting factor is passed 
+  #     we return only photos added in the last 12 hours (though we may extend the limit in the future).
+  # * place_id (Optional)
+  #     A Flickr place id. (not used if bbox argument is present). Experimental. 
+  # 
+  #     Geo queries require some sort of limiting agent in order to prevent the database from crying. This is basically like the check against "parameterless searches" 
+  #     for queries without a geo component. 
+  # 
+  #     A tag, for instance, is considered a limiting agent as are user defined min_date_taken and min_date_upload parameters &emdash; If no limiting factor is passed 
+  #     we return only photos added in the last 12 hours (though we may extend the limit in the future).
+  # * per_page (Optional)
+  #     Number of photos to return per page. If this argument is omitted, it defaults to 100. The maximum allowed value is 500.
+  # * page (Optional)
+  #     The page of results to return. If this argument is omitted, it defaults to 1.
+  # * media (Optional)
+  #     The type of media to search for. 'photo', 'video', or 'both' are allowed arguments, with 'both' being the default.
+  # 
+  def search(options)
+    if options[:extras].nil?
+      # let the caller choose which extras to query.
+      # search request can be twice faster when we ask for less options.
+      options[:extras] = "license,date_upload,date_taken,owner_name,icon_server,original_format,last_update,geo,tags,machine_tags,o_dims,views,media"
+    end
+
+    rsp = @flickr.send_request('flickr.photos.search', options)
+
+    returning PhotoResponse.new(:page => rsp.photos[:page].to_i,
+                                :pages => rsp.photos[:pages].to_i,
+                                :per_page => rsp.photos[:perpage].to_i,
+                                :total => rsp.photos[:total].to_i,
+                                :photos => [],
+                                :api => self,
+                                :method => 'search',
+                                :options => options) do |photos|
+      rsp.photos.photo.each do |photo|
+        attributes = create_attributes(photo)
+
+        photos << Photo.new(@flickr, attributes)
+      end if rsp.photos.photo
+    end
+  end
+    
+  # Returns a list of the latest public photos uploaded to flickr.
+  # 
+  # == Authentication
+  # This method does not require authentication.
+  # 
+  # == Options
+  # * per_page (Optional)
+  #     Number of photos to return per page. If this argument is omitted, it defaults to 100. The maximum allowed value is 500.
+  # * page (Optional)
+  #     The page of results to return. If this argument is omitted, it defaults to 1.
+  # * media (Optional)
+  #     The type of media to search for. 'photo', 'video', or 'both' are allowed arguments, with 'both' being the default.
+  # 
+  def get_recent(options = {})
+    options.merge!({:extras => "license,date_upload,date_taken,owner_name,icon_server,original_format,last_update,geo,tags,machine_tags,o_dims,views,media"})
+
+    rsp = @flickr.send_request('flickr.photos.getRecent', options)
+
+    returning PhotoResponse.new(:page => rsp.photos[:page].to_i,
+                                :pages => rsp.photos[:pages].to_i,
+                                :per_page => rsp.photos[:perpage].to_i,
+                                :total => rsp.photos[:total].to_i,
+                                :photos => [], :api => self,
+                                :method => 'flickr.photos.getRecent',
+                                :options => options) do |photos|
+      rsp.photos.photo.each do |photo|
+        attributes = create_attributes(photo)
+
+        photos << Photo.new(@flickr, attributes)
+      end if rsp.photos.photo
+    end
+  end
+  
+  def interesting(options)
+    options.merge!({:extras => "license,date_upload,date_taken,owner_name,icon_server,original_format,last_update,geo,tags,machine_tags,o_dims,views,media"})
+
+    rsp = @flickr.send_request('flickr.interestingness.getList', options)
+
+    returning PhotoResponse.new(:page => rsp.photos[:page].to_i,
+                                :pages => rsp.photos[:pages].to_i,
+                                :per_page => rsp.photos[:perpage].to_i,
+                                :total => rsp.photos[:total].to_i,
+                                :photos => [],
+                                :api => self,
+                                :method => 'flickr.interestingness.getList',
+                                :options => options) do |photos|
+      rsp.photos.photo.each do |photo|
+        attributes = create_attributes(photo)
+
+
+        photos << Photo.new(@flickr, attributes)
+      end if rsp.photos.photo
+    end
+  end
+  
+  def licenses
+    @licenses ||= begin
+      rsp = @flickr.send_request('flickr.photos.licenses.getInfo')
+      
+      returning Hash.new do |licenses|
+        rsp.licenses.license.each do |license|
+          licenses[license[:id].to_i] = Flickr::Photos::License.new(:id => license[:id].to_i, :name => license[:name], :url => license[:url])
+        end
+      end
+    end
+  end
+
+  # creates and/or returns the Flickr::Photos::Geo object
+  def geo
+    @geo ||= Flickr::Photos::Geo.new(@flickr)
+  end
+  
+  # Returns a Flickr::Photos::Photo object of the given id.
+  # Raises an error if photo not found
+  def find_by_id(photo_id)
+    rsp = @flickr.send_request('flickr.photos.getInfo', :photo_id => photo_id)
+    Photo.new(@flickr, :id => rsp.photo[:id].to_i, :owner => rsp.photo.owner,
+      :secret => rsp.photo[:secret], :server => rsp.photo[:server].to_i, :farm => rsp.photo[:farm], 
+      :title => rsp.photo.title,
+      :is_public => rsp.photo.visibility[:public], :is_friend => rsp.photo.visibility[:is_friend], :is_family => rsp.photo.visibility[:is_family])
+  end
+  
+  protected
+  def create_attributes(photo)
+    {:id => photo[:id], 
+     :owner => photo[:owner], 
+     :secret => photo[:secret], 
+     :server => photo[:server], 
+     :farm => photo[:farm], 
+     :title => photo[:title], 
+     :is_public => photo[:ispublic], 
+     :is_friend => photo[:isfriend], 
+     :is_family => photo[:isfamily],
+     :license_id => photo[:license].to_i,
+     :uploaded_at => (Time.at(photo[:dateupload].to_i) rescue nil),
+     :taken_at => (Time.parse(photo[:datetaken]) rescue nil),
+     :owner_name => photo[:ownername],
+     :icon_server => photo[:icon_server],
+     :original_format => photo[:originalformat],
+     :updated_at => (Time.at(photo[:lastupdate].to_i) rescue nil),
+     :geo => photo[:geo],
+     :tags => photo[:tags],
+     :machine_tags => photo[:machine_tags],
+     :o_dims => photo[:o_dims],
+     :o_height => photo[:o_height],
+     :o_width => photo[:o_width],
+     :views => photo[:views].to_i,
+     :media => photo[:media]}
+  end
+  
+end

data/lib/flickr/photoset.rb

@@ -0,0 +1,37 @@
+class Flickr::Photosets::Photoset
+  attr_accessor :id,:num_photos,:title,:description
+  
+  def initialize(flickr, attributes)
+    @flickr = flickr
+    attributes.each do |k,v|
+      send("#{k}=", v)
+    end
+  end
+  
+  def get_photos(options={})
+    options = options.merge(:photoset_id=>id)
+    rsp = @flickr.send_request('flickr.photosets.getPhotos', options)
+    collect_photos(rsp)
+  end
+  
+  protected
+    def collect_photos(rsp)
+      photos = []
+      return photos unless rsp
+      if rsp.photoset.photo
+        rsp.photoset.photo.each do |photo|
+          attributes = create_attributes(photo)
+          photos << Flickr::Photos::Photo.new(@flickr,attributes)
+        end
+      end
+      return photos
+    end
+    
+    def create_attributes(photo)
+      {:id => photo[:id],
+       :secret => photo[:secret], 
+       :server => photo[:server], 
+       :farm => photo[:farm],
+       :title => photo[:title]}
+    end
+end

data/lib/flickr/photosets.rb

@@ -0,0 +1,39 @@
+class Flickr::Photosets < Flickr::Base
+  def initialize(flickr)
+    @flickr = flickr
+  end
+  
+  # Get the authorized user's contact list.
+  # 
+  def get_list(options={})
+    rsp = @flickr.send_request('flickr.photosets.getList', options)
+    collect_photosets(rsp)
+  end
+    
+  protected  
+    def collect_photosets(rsp)
+      photosets = []
+      return photosets unless rsp
+      if rsp.photosets.photoset
+        rsp.photosets.photoset.each do |photoset|
+          attributes = create_attributes(photoset)
+          photosets << Photoset.new(@flickr, attributes)
+        end
+      end
+      return photosets
+    end
+  
+    def create_attributes(photoset)
+      # comment by : smeevil
+      #
+      # for some reason it was needed to call to_s on photoset.title and photoset.description
+      # without this it will not set the value correctly
+      {
+        :id => photoset[:id], 
+        :num_photos => photoset[:photos],
+        :title => photoset.title.to_s,
+        :description => photoset.description.to_s
+       }
+    end
+  
+end

data/lib/flickr/size.rb

@@ -0,0 +1,16 @@
+# wrapping class to hold a flickr size
+# 
+class Flickr::Photos::Size
+  attr_accessor :label, :width, :height, :source, :url
+  
+  # create a new instance of a flickr size.
+  # 
+  # Params
+  # * attributes (Required)
+  #     a hash of attributes used to set the initial values of the size object
+  def initialize(attributes)
+    attributes.each do |k,v|
+      send("#{k}=", v)
+    end
+  end
+end

data/lib/flickr/status.rb

@@ -0,0 +1,19 @@
+# wrapper class to hold a flickr upload status object.
+# 
+class Flickr::Uploader::Status
+  attr_accessor :nsid, :is_pro, :username, :max_bandwidth, :used_bandwidth, :remaining_bandwidth, :max_filesize, :max_videosize, :sets_created, :sets_remaining
+  
+  # create a new instance of a flickr upload status object.
+  # 
+  # Params
+  # * flickr (Required)
+  #     the flickr object
+  # * attributes (Required)
+  #     a hash of attributes used to set the initial values of the status object
+  def initialize(flickr, attributes)
+    @flickr = flickr
+    attributes.each do |k,v|
+      send("#{k}=", v)
+    end
+  end
+end

data/lib/flickr/test.rb

@@ -0,0 +1,31 @@
+class Flickr::Test
+  def initialize(flickr)
+    @flickr = flickr
+  end
+  
+  # A testing method which checks if the caller is logged in then returns their username.
+  # 
+  def login
+    rsp = @flickr.send_request('flickr.test.login')
+    rsp.user.username.to_s
+  end
+  
+  # A testing method which echo's all parameters back in the response.
+  # 
+  # pass any number of options as a hash and it will be returned
+  # 
+  def echo(options = {})
+    rsp = @flickr.send_request('flickr.test.echo', options)
+    
+    options
+  end
+  
+  # Null test
+  # 
+  # Returns true unless there is an error
+  # 
+  def null
+     rsp = @flickr.send_request('flickr.test.null')
+     true
+  end
+end

data/lib/flickr/token.rb

@@ -0,0 +1,22 @@
+# wrapping class to hold a flickr size
+# 
+class Flickr::Auth::Token
+  attr_accessor :token, :permisions, :user_id, :username, :user_real_name
+
+  # create a new instance of a flickr auth token.
+  # 
+  # Params
+  # * attributes (Required)
+  #     a hash of attributes used to set the initial values of the token object
+  def initialize(attributes)
+    attributes.each do |k,v|
+      send("#{k}=", v) if respond_to?("#{k}=")
+    end
+  end
+
+  # overide the default to_s to output the text of the token
+  # 
+  def to_s
+    self.token.to_s
+  end
+end

data/lib/flickr/uploader.rb

@@ -0,0 +1,162 @@
+class Flickr::Uploader < Flickr::Base
+  def initialize(flickr)
+    @flickr = flickr
+  end
+
+  # upload a photo to flickr
+  #
+  # Params
+  # * filename (Required)
+  #     path to the file to upload
+  # * options (Optional)
+  #     options to attach to the photo (See Below)
+  #
+  # Options
+  # * title (Optional)
+  #     The title of the photo.
+  # * description (Optional)
+  #     A description of the photo. May contain some limited HTML.
+  # * tags (Optional)
+  #     A space-seperated list of tags to apply to the photo.
+  # * privacy (Optional)
+  #     Specifies who can view the photo. valid valus are:
+  #       :public
+  #       :private
+  #       :friends
+  #       :family
+  #       :friends_and_family
+  # * safety_level (Optional)
+  #     sets the safety level of the photo. valid values are:
+  #       :safe
+  #       :moderate
+  #       :restricted
+  # * content_type (Optional)
+  #     tells what type of image you are uploading. valid values are:
+  #       :photo
+  #       :screenshot
+  #       :other
+  # * hidden (Optional)
+  #     boolean that determines if the photo shows up in global searches
+  #
+  def upload(filename, options = {})
+    upload_data(File.new(filename, 'rb').read, MIME::Types.of(filename), options.merge(:filename => filename))
+  end
+
+  # upload a photo to flickr
+  #
+  # Params
+  # * photo (Required)
+  #     image stored in a variable
+  # * mimetype (Required)
+  #     mime type of the image  
+  # * options (Optional)
+  #     see upload method
+  #
+  def upload_data(photo, mimetype, options = {})
+    filename = options.delete(:filename) || Time.now.to_s
+    options = upload_options(options)
+    @flickr.sign_request(options)
+
+    form = Flickr::Uploader::MultiPartForm.new
+
+    options.each do |k,v|
+      form.parts << Flickr::Uploader::FormPart.new(k.to_s, v.to_s)
+    end
+
+    form.parts << Flickr::Uploader::FormPart.new('photo', photo, mimetype, filename)
+
+    headers = {"Content-Type" => "multipart/form-data; boundary=" + form.boundary}
+
+    rsp = Net::HTTP.start('api.flickr.com').post("/services/upload/", form.to_s, headers).body
+
+    xm = XmlMagic.new(rsp)
+
+    if xm[:stat] == 'ok'
+      xm
+    else
+      raise "#{xm.err[:code]}: #{xm.err[:msg]}"
+    end
+  end
+
+  # Returns information for the calling user related to photo uploads.
+  #
+  # * Bandwidth and filesize numbers are provided in bytes.
+  # * Bandwidth is specified in bytes per month.
+  # * Pro accounts display 99 for the number of remaining sets, since they have unlimited sets. Free accounts will display either 3, 2, 1, or 0.
+  #
+  def status
+    rsp = @flickr.send_request('flickr.people.getUploadStatus')
+
+    Flickr::Uploader::Status.new(@flickr, :nsid => rsp.user[:id],
+                                          :is_pro => (rsp.user[:ispro] == "1" ? true : false),
+                                          :username => rsp.user.username.to_s,
+                                          :max_bandwidth => rsp.user.bandwidth[:maxbytes],
+                                          :used_bandwidth => rsp.user.bandwidth[:usedbytes],
+                                          :remaining_bandwidth => rsp.user.bandwidth[:remainingbytes],
+                                          :max_filesize => rsp.user.filesize[:maxbytes],
+                                          :max_videosize => rsp.user.videosize[:maxbytes],
+                                          :sets_created => rsp.user.sets[:created].to_i,
+                                          :sets_remaining => (rsp.user[:ispro] == "1" ? 99 : rsp.user.sets[:remaining].to_i))
+  end
+
+  protected
+
+  def upload_options(options)
+    upload_options = { :api_key => @flickr.api_key }
+    upload_options.merge!({:title => options[:title], :description => options[:description], :tags => options[:tags]})
+    [ :is_public, :is_friend, :is_family, :async ].each { |key| upload_options[key] = options[key] ? '1' : '0' }
+
+    upload_options[:safety_level] = case options[:safety_level]
+      when :safe then '1'
+      when :moderate then '2'
+      when :restricted then '3'
+    end if options.has_key?(:safety_level)
+
+    upload_options[:content_type] = case options[:content_type]
+      when :photo then '1'
+      when :screenshot then '2'
+      when :other then '3'
+    end if options.has_key?(:content_type)
+
+    upload_options[:hidden] = options.has_key?(:hidden) ? '2' : '1'
+    upload_options
+  end
+end
+
+
+class Flickr::Uploader::FormPart
+  attr_reader :data, :mime_type, :attributes, :filename
+
+  def initialize(name, data, mime_type = nil, filename = nil)
+    @attributes = {}
+    @attributes['name'] = name
+    @attributes['filename'] = filename if filename
+    @data = data
+    @mime_type = mime_type
+    @filename = filename
+  end
+
+  def to_s
+    ([ "Content-Disposition: form-data" ] +
+    attributes.map{|k,v| "#{k}=\"#{v}\""}).
+    join('; ') + "\r\n"+
+    (@mime_type ? "Content-Type: #{@mime_type}\r\n" : '')+
+    "\r\n#{data}"
+  end
+end
+
+
+class Flickr::Uploader::MultiPartForm
+  attr_accessor :boundary, :parts
+
+  def initialize(boundary=nil)
+    @boundary = boundary || "----------------------------Ruby#{rand(1000000000000)}"
+    @parts = []
+  end
+
+  def to_s
+    "--#@boundary\r\n" + 
+    parts.map{|p| p.to_s}.join("\r\n--#@boundary\r\n")+
+    "\r\n--#@boundary--\r\n"
+  end
+end

data/lib/flickr/urls.rb

@@ -0,0 +1,44 @@
+# Wrapping class that holds methods in the flickr.urls namespace
+class Flickr::Urls < Flickr::Base
+  def initialize(flickr)
+    @flickr = flickr
+  end
+
+  def get_group group_id
+    rsp = @flickr.send_request('flickr.urls.getGroup', {:group_id => group_id})
+    rsp.group[:url]
+  end
+
+  def get_user_photos user_id
+    rsp = @flickr.send_request('flickr.urls.getUserPhotos', {:user_id => user_id})
+    rsp.user[:url]
+  end
+
+  def get_user_profile user_id
+    rsp = @flickr.send_request('flickr.urls.getUserProfile', {:user_id => user_id})
+    rsp.user[:url]
+  end
+
+  def lookup_group url #, options = {}
+    #options.symbolize_keys!
+    #options.reverse_merge!({:include_groupname => false})
+    rsp = @flickr.send_request('flickr.urls.lookupGroup', {:url => url})
+    #if options[:include_groupname]
+    #[rsp.group[:id], {:groupname => rsp.group.groupname}]
+    #else
+    rsp.group[:id]
+    #end
+  end
+
+  def lookup_user url
+    rsp = @flickr.send_request('flickr.urls.lookupUser', {:url => url})
+    user_id = UserLookupResult.new(rsp.user[:id])
+    user_id.username = rsp.user.username
+    user_id
+  end
+
+  class UserLookupResult < String
+    attr_accessor :username
+  end
+  
+end

data/lib/flickr_fu.rb

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'xml_magic'
+require 'net/http'
+require 'cgi'
+require 'uri'
+require 'open-uri'
+require 'mime/types'
+require 'digest/md5'
+require 'yaml'
+require 'time'
+require 'date'
+
+# base must load first
+[ "base",
+  "test",
+  "auth",
+  "token",
+  "photos",
+  "photo",
+  "photo_response",
+  "photosets",
+  "photoset",
+  "comment",
+  "note",
+  "size",
+  "uploader",
+  "status",
+  "people",
+  "person",
+  "license",
+  "errors",
+  "contacts",
+  "contact",
+  "geo",
+  "location",
+  "urls" ].each do |file|
+  require File.join(File.dirname(__FILE__), 'flickr', file)
+end
+
+include CommonThread::XML
+
+class Object
+  # returning allows you to pass an object to a block that you can manipulate returning the manipulated object
+  def returning(value)
+    yield(value)
+    value
+  end
+end

data/spec/fixtures/flickr/contacts/get_list-fail-99.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<rsp stat="fail">
+	<err code="99" msg="Insufficient permissions. Method requires read privileges; none granted."/>
+</rsp>