genki-flickraw 0.8.4.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2006 Mael Clerambault <maelclerambault@yahoo.fr>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,161 @@
+= Flickraw
+
+Flickraw is a library to access flickr[http://flickr.com] api in a simple way.
+It maps exactly the methods described in {the official api documentation}[http://www.flickr.com/services/api].
+It also tries to present the data returned in a simple and intuitive way.
+The methods are fetched from flickr when loading the library by using introspection capabilities. So it is always up-to-date with regards to new methods added by flickr.
+
+The github repository: http://github.com/hanklords/flickraw
+
+= Installation
+Type this in a console (you might need to be superuser)
+ gem install flickraw
+
+This will recreate the documentation by fetching the methods descriptions from flickr and then virtually plugging them in standard rdoc documentation.
+ $ cd flickraw
+ $ rake rdoc
+
+= Features
+
+* Small single file: flickraw.rb is less than 400 lines
+* Minimal dependencies
+* Complete support of flickr API. This doesn't require an update of the library
+* Ruby syntax similar to the flickr api
+* Flickr authentication
+* Photo upload
+* Proxy support
+* Flickr URLs helpers
+
+= Usage
+
+== Simple
+
+ require 'flickraw'
+
+ FlickRaw.api_key="... Your API key ..."
+ FlickRaw.shared_secret="... Your shared secret ..."
+
+ list   = flickr.photos.getRecent
+
+ id     = list[0].id
+ secret = list[0].secret
+ info = flickr.photos.getInfo :photo_id => id, :secret => secret
+
+ puts info.title           # => "PICT986"
+ puts info.dates.taken     # => "2006-07-06 15:16:18"
+
+
+ sizes = flickr.photos.getSizes :photo_id => id
+
+ original = sizes.find {|s| s.label == 'Original' }
+ puts original.width       # => "800" -- may fail if they have no original marked image
+
+== Authentication
+
+  require 'flickraw'
+
+  FlickRaw.api_key="... Your API key ..."
+  FlickRaw.shared_secret="... Your shared secret ..."
+
+  token = flickr.get_request_token(:perms => 'delete')
+  auth_url = token['oauth_authorize_url']
+
+  puts "Open this url in your process to complete the authication process : #{auth_url}"
+  puts "Copy here the number given when you complete the process."
+  verify = gets.strip
+
+  begin
+    flickr.get_access_token(token['oauth_token'], token['oauth_token_secret'], verify)
+    login = flickr.test.login
+    puts "You are now authenticated as #{login.username}"
+  rescue FlickRaw::FailedResponse => e
+    puts "Authentication failed : #{e.msg}"
+  end
+
+If the user has already been authenticated, you can reuse the access token and access secret:
+
+  require 'flickraw'
+
+  FlickRaw.api_key="... Your API key ..."
+  FlickRaw.shared_secret="... Your shared secret ..."
+
+  flickr.access_token = "... Your access token ..."
+  flickr.access_secret = "... Your access secret ..."
+
+  # From here you are logged:
+  login = flickr.test.login
+  puts "You are now authenticated as #{login.username}"
+
+== Upload
+
+  require 'flickraw'
+
+  FlickRaw.api_key="... Your API key ..."
+  FlickRaw.shared_secret="... Your shared secret ..."
+
+  PHOTO_PATH='photo.jpg'
+
+  # You need to be authentified to do that, see the previous examples.
+  flickr.upload_photo PHOTO_PATH, :title => "Title", :description => "This is the description"
+
+== Proxy
+
+  require 'flickraw'
+  FlickRaw.proxy = "http://user:pass@proxy.example.com:3129/"
+
+== Flickr URL Helpers
+
+There are some helpers to build flickr urls :
+
+=== url, url_m, url_s, url_t, url_b, url_z, url_o
+
+  info = flickr.photos.getInfo(:photo_id => "3839885270")
+  FlickRaw.url_b(info) # => "http://farm3.static.flickr.com/2485/3839885270_6fb8b54e06_b.jpg"
+
+=== url_profile
+
+  info = flickr.photos.getInfo(:photo_id => "3839885270")
+  FlickRaw.url_profile(info) # => "http://www.flickr.com/people/41650587@N02/"
+
+=== url_photopage
+
+  info = flickr.photos.getInfo(:photo_id => "3839885270")
+  FlickRaw.url_photopage(info) # => "http://www.flickr.com/photos/41650587@N02/3839885270"
+
+=== url_photoset, url_photosets
+
+  info = flickr.photos.getInfo(:photo_id => "3839885270")
+  FlickRaw.url_photosets(info) # => "http://www.flickr.com/photos/41650587@N02/sets/"
+
+=== url_short, url_short_m, url_short_s, url_short_t
+
+  info = flickr.photos.getInfo(:photo_id => "3839885270")
+  FlickRaw.url_short(info) # => "http://flic.kr/p/6Rjq7s"
+
+=== url_photostream
+
+  info = flickr.photos.getInfo(:photo_id => "3839885270")
+  FlickRaw.url_photostream(info) # => "http://www.flickr.com/photos/41650587@N02/"
+
+
+See the _examples_ directory to find more examples.
+
+== Cached version
+
+You can use
+
+  require 'flickraw-cached'
+
+instead of
+
+   require 'flickraw'
+
+This way it it doesn't fetch available flickr methods each time it is loaded.
+The flickraw-cached gem is on rubygems.org and should be up-to-date with regard to flickr api most of the time.
+
+= Notes
+
+If you want to use the api authenticated with several user at the same time, you must pass the authentication token explicitely each time.
+This is because it is keeping the authentication token internally.
+As an alternative, you can create new Flickr objects besides Kernel.flickr which is created for you. Use Flickr.new to this effect.
+

data/examples/auth.rb

@@ -0,0 +1,24 @@
+require 'flickraw'
+
+# This is how to authenticate on flickr website.
+# You need an API key for that, see http://www.flickr.com/services/api/keys/
+API_KEY=''
+SHARED_SECRET=''
+
+FlickRaw.api_key=API_KEY
+FlickRaw.shared_secret=SHARED_SECRET
+
+token = flickr.get_request_token(:perms => 'delete')
+auth_url = token['oauth_authorize_url']
+
+puts "Open this url in your process to complete the authication process : #{auth_url}"
+puts "Copy here the number given when you complete the process."
+verify = gets.strip
+
+begin
+  flickr.get_access_token(token['oauth_token'], token['oauth_token_secret'], verify)
+  login = flickr.test.login
+  puts "You are now authenticated as #{login.username} with token #{flickr.access_token} and secret #{flickr.access_secret}"
+rescue FlickRaw::FailedResponse => e
+  puts "Authentication failed : #{e.msg}"
+end

data/examples/interestingness.rb

@@ -0,0 +1,6 @@
+require 'flickraw'
+
+# Get the list of the 20 most recent 'interesting photos'
+
+list = flickr.interestingness.getList :per_page => 20
+list.each {|photo| puts "'#{photo.title}' id=#{photo.id} secret=#{photo.secret}" }

data/examples/search.rb

@@ -0,0 +1,22 @@
+require 'flickraw'
+
+# search for pictures taken within 60 miles of new brunswick, between 1890-1920
+
+# FlickRaw.api_key="..."
+# FlickRaw.shared_secret="..."
+
+new_b = flickr.places.find :query => "new brunswick"
+latitude = new_b[0]['latitude'].to_f
+longitude = new_b[0]['longitude'].to_f
+
+# within 60 miles of new brunswick, let's use a bbox
+radius = 1
+args = {}
+args[:bbox] = "#{longitude - radius},#{latitude - radius},#{longitude + radius},#{latitude + radius}"
+
+# requires a limiting factor, so let's give it one
+args[:min_taken_date] = '1890-01-01 00:00:00'
+args[:max_taken_date] = '1920-01-01 00:00:00'
+args[:accuracy] = 1 # the default is street only granularity [16], which most images aren't...
+discovered_pictures = flickr.photos.search args
+discovered_pictures.each{|p| url = FlickRaw.url p; puts url}

data/examples/upload.rb

@@ -0,0 +1,17 @@
+require 'flickraw'
+
+# This is how to upload photos on flickr.
+# You need to be authentified to do that.
+
+API_KEY=''
+SHARED_SECRET=''
+ACCESS_TOKEN=''
+ACCESS _SECRET=''
+PHOTO_PATH='photo.jpg'
+
+FlickRaw.api_key = API_KEY
+FlickRaw.shared_secret = SHARED_SECRET
+flickr.access_token = ACCESS_TOKEN
+flickr.access_secret = ACCESS_SECRET
+
+flickr.upload_photo PHOTO_PATH, :title => 'Title', :description => 'This is the description'

data/flickraw_rdoc.rb

@@ -0,0 +1,131 @@
+require "rdoc"
+require "rdoc/parser/ruby"
+require "cgi"
+
+FLICKR_API_URL='http://www.flickr.com/services/api'
+
+FakedToken = Struct.new :text
+
+module RDoc
+  class FlickrawParser < Parser::Ruby
+    parse_files_matching(/flickraw\.rb$/)
+
+    def scan
+      super
+
+      fr = @top_level.find_module_named 'FlickRaw'
+      k = fr.add_class NormalClass, 'Flickr', 'FlickRaw::Request'
+      k.record_location @top_level
+      @stats.add_class 'Flickr'
+
+      add_flickr_methods(FlickRaw::Flickr, k)
+      @top_level
+    end
+
+    private
+    def add_flickr_methods(obj, doc)
+      flickr # Force loading of methods if lazyloaded
+      obj.constants.each { |const_name|
+        const = obj.const_get const_name
+        if const.is_a?(Class) && const < FlickRaw::Request
+          name = const.name.sub(/.*::/, '')
+          k = doc.add_class NormalClass, name, 'FlickRaw::Request'
+          k.record_location @top_level
+          @stats.add_class name
+
+          m = AnyMethod.new nil, name.downcase
+          m.comment = "Returns a #{name} object."
+          m.params = ''
+          m.singleton = false
+          doc.add_method m
+          @stats.add_method m
+
+          add_flickr_methods(const, k)
+        end
+      }
+
+      obj.flickr_methods.each {|name|
+        flickr_method = obj.request_name + '.' + name
+        info = flickr.reflection.getMethodInfo :method_name => flickr_method
+
+        m = AnyMethod.new nil, name
+        m.comment = flickr_method_comment(info)
+        m.params = flickr_method_args(info)
+        m.singleton = false
+
+        m.start_collecting_tokens
+        m.add_token FakedToken.new( %{
+# Generated automatically from flickr api
+  def #{name}(*args)
+    @flickr.call '#{flickr_method}', *args
+  end
+} )
+        doc.add_method m
+         @stats.add_method m
+      }
+    end
+
+    def flickr_method_comment(info)
+      description = CGI.unescapeHTML(info.method.description.to_s)
+#       description.gsub!( /<\/?(\w+)>/ ) {|b|
+#         return b if ['em', 'b', 'tt'].include? $1
+#         return ''
+#       }
+
+      if info.respond_to? :arguments
+        args = info.arguments.select { |arg| arg.name != 'api_key' }
+
+        arguments = "<b>Arguments</b>\n"
+        if args.size > 0
+          args.each {|arg|
+            arguments << "[#{arg.name} "
+            arguments << "<em>(required)</em> " if arg.optional == '0'
+            arguments << "] "
+            arguments << "#{CGI.unescapeHTML(arg.to_s)}\n"
+          }
+        end
+      end
+
+      if info.respond_to? :errors
+        errors = "<b>Error codes</b>\n"
+        info.errors.each {|e|
+          errors << "* #{e.code}: <em>#{e.message}</em>\n\n"
+          errors << "  #{CGI.unescapeHTML e.to_s}\n"
+        }
+      end
+
+      if info.method.respond_to? :response
+        response = "<b>Returns</b>\n"
+        raw = CGI.unescapeHTML(info.method.response.to_s)
+        response << raw.lines.collect { |line| line.insert(0, ' ') }.join
+      else
+        response = ''
+      end
+
+      str = "{#{info.method.name}}[#{FLICKR_API_URL}/#{info.method.name}.html] request.\n\n"
+      str << description << "\n\n"
+      str << arguments << "\n\n"
+      str << errors << "\n\n"
+      str << response << "\n\n"
+    end
+
+    def flickr_method_args(info)
+      str = ''
+      if info.respond_to? :arguments
+        args = info.arguments.select { |arg| arg.name != 'api_key' }
+
+        if args.size > 0
+          str << '('
+          args.each {|arg|
+            str << ":#{arg.name} => '#{arg.name}'"
+            str << ','
+          }
+          str.chomp! ','
+          str << ')'
+        end
+      end
+      str
+    end
+
+  end
+end

data/lib/flickraw.rb

@@ -0,0 +1,413 @@
+# encoding: ascii-8bit
+# Copyright (c) 2006 Mael Clerambault <maelclerambault@yahoo.fr>
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+require 'net/http'
+require 'json'
+
+module FlickRaw
+  VERSION='0.8.4.1'
+  USER_AGENT = "Flickraw/#{VERSION}"
+
+  FLICKR_OAUTH_REQUEST_TOKEN='http://www.flickr.com/services/oauth/request_token'.freeze
+  FLICKR_OAUTH_AUTHORIZE='http://www.flickr.com/services/oauth/authorize'.freeze
+  FLICKR_OAUTH_ACCESS_TOKEN='http://www.flickr.com/services/oauth/access_token'.freeze
+
+  REST_PATH='http://api.flickr.com/services/rest/'.freeze
+  UPLOAD_PATH='http://api.flickr.com/services/upload/'.freeze
+  REPLACE_PATH='http://api.flickr.com/services/replace/'.freeze
+
+  PHOTO_SOURCE_URL='http://farm%s.static.flickr.com/%s/%s_%s%s.%s'.freeze
+  URL_PROFILE='http://www.flickr.com/people/'.freeze
+  URL_PHOTOSTREAM='http://www.flickr.com/photos/'.freeze
+  URL_SHORT='http://flic.kr/p/'.freeze
+  
+  class OAuth
+    class FailedResponse < StandardError
+      def initialize(str)
+        @response = OAuth.parse_response(str)
+        super(@response['oauth_problem'])
+      end
+    end
+  
+    class << self
+      def escape(v); URI.escape(v.to_s, /[^a-zA-Z0-9\-\.\_\~]/) end
+      def parse_response(text); Hash[text.split("&").map {|s| s.split("=")}] end
+    end
+    
+    attr_accessor :user_agent
+    attr_reader :proxy
+    def proxy=(url)
+      return if url.nil?
+      @proxy = URI.parse(url)
+      @proxy_host, @proxy_port, @proxy_user, @proxy_password = @proxy.host, @proxy.port, @proxy.user, @proxy.password
+      @proxy
+    end
+    
+    def initialize(consumer_key, consumer_secret); @consumer_key, @consumer_secret = consumer_key, consumer_secret end
+
+    def sign(method, url, params, token_secret = nil, consumer_secret = @consumer_secret)
+      params_norm = params.map {|k,v| OAuth.escape(k) + "=" + OAuth.escape(v) }.sort.join("&")
+      text = method.to_s.upcase + "&" + OAuth.escape(url) + "&" + OAuth.escape(params_norm)
+      key = consumer_secret.to_s + "&" + token_secret.to_s
+      digest = OpenSSL::Digest::Digest.new("sha1")
+      [OpenSSL::HMAC.digest(digest, key, text)].pack('m0').gsub(/\n$/,'')
+    end
+    
+    def authorization_header(url, params)
+      params_norm = params.map {|k,v| OAuth.escape(k) + "=\"" + OAuth.escape(v) + "\""}.sort.join(", ")
+      "OAuth realm=\"" + url.to_s + "\", " + params_norm
+    end
+    
+    def gen_timestamp; Time.now.to_i end
+    def gen_nonce; [OpenSSL::Random.random_bytes(32)].pack('m0').gsub(/\n$/,'') end
+    def gen_default_params
+      { :oauth_version => "1.0", :oauth_signature_method => "HMAC-SHA1",
+        :oauth_consumer_key => @consumer_key, :oauth_nonce => gen_nonce,
+        :oauth_timestamp => gen_timestamp }
+    end
+    
+    def request_token(url, oauth_params = {})
+      r = post_form(url, nil, {:oauth_callback => "oob"}.merge(oauth_params))
+      OAuth.parse_response(r.body)
+    end
+    
+    def authorize_url(url, oauth_params = {})
+      params_norm = oauth_params.map {|k,v| OAuth.escape(k) + "=" + OAuth.escape(v)}.sort.join("&")
+      url =  URI.parse(url)
+      url.query = url.query ? url.query + "&" + params_norm : params_norm
+      url
+    end
+    
+    def access_token(url, token_secret, oauth_params = {})
+      r = post_form(url, token_secret, oauth_params)
+      OAuth.parse_response(r.body)
+    end
+        
+    def post_form(url, token_secret, oauth_params = {}, params = {})
+      oauth_params = gen_default_params.merge(oauth_params)
+      oauth_params[:oauth_signature] = sign(:post, url, params.merge(oauth_params), token_secret)
+      url = URI.parse(url)
+      r = Net::HTTP.start(url.host, url.port, @proxy_host, @proxy_port, @proxy_user, @proxy_password) { |http| 
+        request = Net::HTTP::Post.new(url.path)
+        request['User-Agent'] = @user_agent if @user_agent
+        request['Authorization'] = authorization_header(url, oauth_params)
+        request.form_data = params
+        http.request(request)
+      }
+      
+      raise FailedResponse.new(r.body) if r.is_a? Net::HTTPClientError
+      r
+    end
+    
+    def post_multipart(url, token_secret, oauth_params = {}, params = {})
+      oauth_params = gen_default_params.merge(oauth_params)
+      params_signed = params.reject {|k,v| v.is_a? File}.merge(oauth_params)
+      oauth_params[:oauth_signature] = sign(:post, url, params_signed, token_secret)
+      url = URI.parse(url)
+      r = Net::HTTP.start(url.host, url.port, @proxy_host, @proxy_port, @proxy_user, @proxy_password) { |http| 
+        boundary = "FlickRaw#{gen_nonce}"
+        request = Net::HTTP::Post.new(url.path)
+        request['User-Agent'] = @user_agent if @user_agent
+        request['Content-type'] = "multipart/form-data, boundary=#{boundary}"
+        request['Authorization'] = authorization_header(url, oauth_params)
+
+        request.body = ''
+        params.each { |k, v|
+          if v.is_a? File
+            basename = File.basename(v.path).to_s
+            basename = basename.encode("utf-8").force_encoding("ascii-8bit") if RUBY_VERSION >= "1.9"
+            filename = basename
+            request.body << "--#{boundary}\r\n" <<
+              "Content-Disposition: form-data; name=\"#{k}\"; filename=\"#{filename}\"\r\n" <<
+              "Content-Transfer-Encoding: binary\r\n" <<
+              "Content-Type: image/jpeg\r\n\r\n" <<
+              v.read << "\r\n"
+          else
+            request.body << "--#{boundary}\r\n" <<
+              "Content-Disposition: form-data; name=\"#{k}\"\r\n\r\n" <<
+              "#{v}\r\n"
+          end
+        }
+        
+        request.body << "--#{boundary}--"
+        http.request(request)
+      }
+      
+      raise FailedResponse.new(r.body) if r.is_a? Net::HTTPClientError
+      r      
+    end    
+  end
+
+  class Response
+    def self.build(h, type) # :nodoc:
+      if h.is_a? Response
+        h
+      elsif type =~ /s$/ and (a = h[$`]).is_a? Array
+        ResponseList.new(h, type, a.collect {|e| Response.build(e, $`)})
+      elsif h.keys == ["_content"]
+        h["_content"]
+      else
+        Response.new(h, type)
+      end
+    end
+
+    attr_reader :flickr_type
+    def initialize(h, type) # :nodoc:
+      @flickr_type, @h = type, {}
+      methods = "class << self;"
+      h.each {|k,v|
+        @h[k] = case v
+          when Hash  then Response.build(v, k)
+          when Array then v.collect {|e| Response.build(e, k)}
+          else v
+        end
+        methods << "def #{k}; @h['#{k}'] end;"
+      }
+      eval methods << "end"
+    end
+    def [](k); @h[k] end
+    def to_s; @h["_content"] || super end
+    def inspect; @h.inspect end
+    def to_hash; @h end
+    def marshal_dump; [@h, @flickr_type] end
+    def marshal_load(data); initialize(*data) end
+  end
+
+  class ResponseList < Response
+    include Enumerable
+    def initialize(h, t, a); super(h, t); @a = a end
+    def [](k); k.is_a?(Fixnum) ? @a[k] : super(k) end
+    def each; @a.each{|e| yield e} end
+    def to_a; @a end
+    def inspect; @a.inspect end
+    def size; @a.size end
+    def marshal_dump; [@h, @flickr_type, @a] end
+    alias length size
+  end
+
+  class FailedResponse < StandardError
+    attr_reader :code
+    alias :msg :message
+    def initialize(msg, code, req)
+      @code = code
+      super("'#{req}' - #{msg}")
+    end
+  end
+
+  class Request
+    def initialize(flickr = nil) # :nodoc:
+      @flickr = flickr
+
+      self.class.flickr_objects.each {|name|
+        klass = self.class.const_get name.capitalize
+        instance_variable_set "@#{name}", klass.new(@flickr)
+      }
+    end
+
+    def self.build_request(req) # :nodoc:
+      method_nesting = req.split '.'
+      raise "'#{@name}' : Method name mismatch" if method_nesting.shift != request_name.split('.').last
+
+      if method_nesting.size > 1
+        name = method_nesting.first
+        class_name = name.capitalize
+        if flickr_objects.include? name
+          klass = const_get(class_name)
+        else
+          klass = Class.new Request
+          const_set(class_name, klass)
+          attr_reader name
+          flickr_objects << name
+        end
+
+        klass.build_request method_nesting.join('.')
+      else
+        req = method_nesting.first
+        module_eval %{
+          def #{req}(*args, &block)
+            @flickr.call("#{request_name}.#{req}", *args, &block)
+          end
+        }
+        flickr_methods << req
+      end
+    end
+
+    # List of the flickr subobjects of this object
+    def self.flickr_objects; @flickr_objects ||= [] end
+
+    # List of the flickr methods of this object
+    def self.flickr_methods; @flickr_methods ||= [] end
+
+    # Returns the prefix of the request corresponding to this class.
+    def self.request_name; name.downcase.gsub(/::/, '.').sub(/[^\.]+\./, '') end
+  end
+
+  # Root class of the flickr api hierarchy.
+  class Flickr < Request
+    attr_accessor :access_token, :access_secret
+    
+    def self.build(methods); methods.each { |m| build_request m } end
+
+    def initialize # :nodoc:
+      raise "No API key or secret defined !" if FlickRaw.api_key.nil? or FlickRaw.shared_secret.nil?
+      @oauth_consumer = OAuth.new(FlickRaw.api_key, FlickRaw.shared_secret)
+      @oauth_consumer.proxy = FlickRaw.proxy
+      @oauth_consumer.user_agent = USER_AGENT
+      
+      Flickr.build(call('flickr.reflection.getMethods')) if Flickr.flickr_objects.empty?
+      super self
+    end
+    
+    # This is the central method. It does the actual request to the flickr server.
+    #
+    # Raises FailedResponse if the response status is _failed_.
+    def call(req, args={}, &block)
+      http_response = @oauth_consumer.post_form(REST_PATH, @access_secret, {:oauth_token => @access_token}, build_args(args, req))
+      process_response(req, http_response.body)
+    end
+
+    def get_request_token(args = {})
+      request_token = @oauth_consumer.request_token(FLICKR_OAUTH_REQUEST_TOKEN)
+      authorize_url = @oauth_consumer.authorize_url(FLICKR_OAUTH_AUTHORIZE, args.merge(:oauth_token => request_token['oauth_token']))
+      request_token.merge('oauth_authorize_url' => authorize_url)
+    end
+
+    def get_access_token(token, secret, verify)
+      access_token = @oauth_consumer.access_token(FLICKR_OAUTH_ACCESS_TOKEN, secret, :oauth_token => token, :oauth_verifier => verify)
+      @access_token, @access_secret = access_token['oauth_token'], access_token['oauth_token_secret']
+      access_token
+    end
+
+    # Use this to upload the photo in _file_.
+    #
+    #  flickr.upload_photo '/path/to/the/photo', :title => 'Title', :description => 'This is the description'
+    #
+    # See http://www.flickr.com/services/api/upload.api.html for more information on the arguments.
+    def upload_photo(file, args={}); upload_flickr(UPLOAD_PATH, file, args) end
+
+    # Use this to replace the photo with :photo_id with the photo in _file_.
+    #
+    #  flickr.replace_photo '/path/to/the/photo', :photo_id => id
+    #
+    # See http://www.flickr.com/services/api/replace.api.html for more information on the arguments.
+    def replace_photo(file, args={}); upload_flickr(REPLACE_PATH, file, args) end
+
+    private
+    def build_args(args={}, method = nil)
+      full_args = {'format' => 'json', :nojsoncallback => "1"}
+      full_args['method'] = method if method
+      args.each {|k, v|
+        v = v.to_s.encode("utf-8").force_encoding("ascii-8bit") if RUBY_VERSION >= "1.9"
+        full_args[k.to_s] = v
+      }
+      full_args
+    end
+
+    def process_response(req, response)
+      if response =~ /^<\?xml / # upload_photo returns xml data whatever we ask
+        if response[/stat="(\w+)"/, 1] == 'fail'
+          msg = response[/msg="([^"]+)"/, 1]
+          code = response[/code="([^"]+)"/, 1]
+          raise FailedResponse.new(msg, code, req)
+        end
+        
+        type = response[/<(\w+)/, 1]
+        h = {
+          "secret" => response[/secret="([^"]+)"/, 1],
+          "originalsecret" => response[/originalsecret="([^"]+)"/, 1],
+          "_content" => response[/>([^<]+)<\//, 1]
+        }.delete_if {|k,v| v.nil? }
+        
+        Response.build h, type
+      else
+        json = JSON.load(response.empty? ? "{}" : response)
+        raise FailedResponse.new(json['message'], json['code'], req) if json.delete('stat') == 'fail'
+        type, json = json.to_a.first if json.size == 1 and json.all? {|k,v| v.is_a? Hash}
+
+        Response.build json, type
+      end
+    end
+
+    def upload_flickr(method, file, args={})
+      args = build_args(args)
+      args['photo'] = open(file, 'rb')
+      http_response = @oauth_consumer.post_multipart(method, @access_secret, {:oauth_token => @access_token}, args)
+      process_response(method, http_response.body)
+    end
+  end
+
+  class << self
+    # Your flickr API key, see http://www.flickr.com/services/api/keys for more information
+    attr_accessor :api_key
+    
+    # The shared secret of _api_key_, see http://www.flickr.com/services/api/keys for more information
+    attr_accessor :shared_secret
+    
+    # Use a proxy
+    attr_accessor :proxy
+
+    BASE58_ALPHABET="123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ".freeze
+    def base58(id)
+      id = id.to_i
+      alphabet = BASE58_ALPHABET.split(//)
+      base = alphabet.length
+      begin
+        id, m = id.divmod(base)
+        r = alphabet[m] + (r || '')
+      end while id > 0
+      r
+    end
+
+    def url(r);   PHOTO_SOURCE_URL % [r.farm, r.server, r.id, r.secret, "",   "jpg"]   end
+    def url_m(r); PHOTO_SOURCE_URL % [r.farm, r.server, r.id, r.secret, "_m", "jpg"] end
+    def url_s(r); PHOTO_SOURCE_URL % [r.farm, r.server, r.id, r.secret, "_s", "jpg"] end
+    def url_t(r); PHOTO_SOURCE_URL % [r.farm, r.server, r.id, r.secret, "_t", "jpg"] end
+    def url_b(r); PHOTO_SOURCE_URL % [r.farm, r.server, r.id, r.secret, "_b", "jpg"] end
+    def url_z(r); PHOTO_SOURCE_URL % [r.farm, r.server, r.id, r.secret, "_z", "jpg"] end
+    def url_o(r); PHOTO_SOURCE_URL % [r.farm, r.server, r.id, r.originalsecret, "_o", r.originalformat] end
+    def url_profile(r); URL_PROFILE + (r.owner.respond_to?(:nsid) ? r.owner.nsid : r.owner) + "/" end
+    def url_photopage(r); url_photostream(r) + r.id end
+    def url_photosets(r); url_photostream(r) + "sets/" end
+    def url_photoset(r); url_photosets(r) + r.id end
+    def url_short(r); URL_SHORT + base58(r.id) end
+    def url_short_m(r); URL_SHORT + "img/" + base58(r.id) + "_m.jpg" end
+    def url_short_s(r); URL_SHORT + "img/" + base58(r.id) + ".jpg" end
+    def url_short_t(r); URL_SHORT + "img/" + base58(r.id) + "_t.jpg" end
+    def url_photostream(r)
+      URL_PHOTOSTREAM +
+        if r.respond_to?(:pathalias) and r.pathalias
+          r.pathalias
+        elsif r.owner.respond_to?(:nsid)
+          r.owner.nsid
+        else
+          r.owner
+        end + "/"
+    end
+  end
+end
+
+# Use this to access the flickr API easily. You can type directly the flickr requests as they are described on the flickr website.
+#  require 'flickraw'
+#
+#  recent_photos = flickr.photos.getRecent
+#  puts recent_photos[0].title
+#def flickr; $flickraw ||= FlickRaw::Flickr.new end