flickraw 0.9 → 0.9.2

data/README.rdoc

@@ -17,11 +17,11 @@ This will recreate the documentation by fetching the methods descriptions from f
 
 = 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
+* HTTPS Support
 * Photo upload
 * Proxy support
 * Flickr URLs helpers
@@ -57,7 +57,7 @@ This will recreate the documentation by fetching the methods descriptions from f
   FlickRaw.api_key="... Your API key ..."
   FlickRaw.shared_secret="... Your shared secret ..."
 
-  token = flickr.get_request_token(:perms => 'delete')
+  token = flickr.get_request_token
   auth_url = flickr.get_authorize_url(token['oauth_token'], :perms => 'delete')
 
   puts "Open this url in your process to complete the authication process : #{auth_url}"
@@ -86,6 +86,10 @@ If the user has already been authenticated, you can reuse the access token and a
   login = flickr.test.login
   puts "You are now authenticated as #{login.username}"
 
+If you need to have several users authenticated at the same time in your application (ex: a public web application) you need to create separate FlickRaw objects since it keeps the authentication data internally.
+
+  flickr = FlickRaw::Flickr.new
+
 == Upload
 
   require 'flickraw'
@@ -103,6 +107,11 @@ If the user has already been authenticated, you can reuse the access token and a
   require 'flickraw'
   FlickRaw.proxy = "http://user:pass@proxy.example.com:3129/"
 
+== Secure endpoints
+
+  require 'flickraw'
+  FlickRaw.secure = true
+
 == Flickr URL Helpers
 
 There are some helpers to build flickr urls :
@@ -152,10 +161,3 @@ instead of
 
 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

@@ -8,7 +8,7 @@ SHARED_SECRET=''
 FlickRaw.api_key=API_KEY
 FlickRaw.shared_secret=SHARED_SECRET
 
-token = flickr.get_request_token(:perms => 'delete')
+token = flickr.get_request_token
 auth_url = flickr.get_authorize_url(token['oauth_token'], :perms => 'delete')
 
 puts "Open this url in your process to complete the authication process : #{auth_url}"

data/examples/sinatra.rb

@@ -6,17 +6,26 @@ FlickRaw.shared_secret = SHARED_SECRET
 enable :sessions
 
 get '/authenticate' do
-  token = flickr.get_request_token(:oauth_callback => to('authenticated'))
+  token = flickr.get_request_token(:oauth_callback => to('check'))
   session[:token] = token
   redirect flickr.get_authorize_url(token['oauth_token'], :perms => 'delete')
 end
 
+get '/check' do
+  token = session.delete :token
+  session[:auth_flickr] = @auth_flickr = FlickRaw::Flickr.new
+  @auth_flickr.get_access_token(token['oauth_token'], token['oauth_token_secret'], params['oauth_verifier'])
+  
+  redirect to('/authenticated')
+end
+
 get '/authenticated' do
-  token = session[:token]
-  flickr.get_access_token(token['oauth_token'], token['oauth_token_secret'], params['oauth_verifier'])
-  login = flickr.test.login
+  @auth_flickr = session[:auth_flickr]
+  
+  login = @auth_flickr.test.login
   %{
-You are now authenticated as <b>#{login.username}</b>
-with token <b>#{flickr.access_token}</b> and secret <b>#{flickr.access_secret}</b>.
+You are now authenticated as <em>#{login.username}</em>
+with token <strong>#{@auth_flickr.access_token}</strong> and secret <strong>#{@auth_flickr.access_secret}</strong>.
 }
 end
+

data/flickraw_rdoc.rb

@@ -1,7 +1,6 @@
 require "rdoc"
 require "rdoc/parser/ruby"
 require "nokogiri"
-require "cgi"
 
 FLICKR_API_URL='http://www.flickr.com/services/api'
 
@@ -78,7 +77,7 @@ module RDoc
             arguments << "[#{arg.name} "
             arguments << "<em>(required)</em> " if arg.optional == '0'
             arguments << "] "
-            arguments << "#{CGI.unescapeHTML(arg.to_s)}\n"
+            arguments << "#{Nokogiri::HTML(arg.to_s).text}\n"
           }
         end
       end
@@ -87,13 +86,13 @@ module RDoc
         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"
+          errors << "  #{Nokogiri::HTML(e.to_s).text}\n"
         }
       end
 
       if info.method.respond_to? :response
         response = "<b>Returns</b>\n"
-        raw = CGI.unescapeHTML(info.method.response.to_s)
+        raw = Nokogiri::HTML(info.method.response.to_s).text
         response << raw.lines.collect { |line| line.insert(0, ' ') }.join
       else
         response = ''

data/lib/flickraw.rb

@@ -1,421 +1,12 @@
-# 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'
+require 'flickraw/oauth'
+require 'flickraw/request'
+require 'flickraw/response'
+require 'flickraw/api'
 
 module FlickRaw
-  VERSION='0.9'
-  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 # :nodoc: all
-    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); @proxy = URI.parse(url || '') end
-    
-    def initialize(consumer_key, consumer_secret)
-      @consumer_key, @consumer_secret = consumer_key, consumer_secret
-      self.proxy = nil
-    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.to_s
-    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
-    # Authenticated access token
-    attr_accessor :access_token
-    
-    # Authenticated access token secret
-    attr_accessor :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
-
-    # Get an oauth request token.
-    #
-    #    token = flickr.get_request_token(:oauth_callback => "http://example.com")
-    def get_request_token(args = {})
-      request_token = @oauth_consumer.request_token(FLICKR_OAUTH_REQUEST_TOKEN, args)
-    end
-    
-    # Get the oauth authorize url.
-    #
-    #  auth_url = flickr.get_authorize_url(token['oauth_token'], :perms => 'delete')
-    def get_authorize_url(token, args = {})
-      @oauth_consumer.authorize_url(FLICKR_OAUTH_AUTHORIZE, args.merge(:oauth_token => token))
-    end
-
-    # Get an oauth access token.
-    #
-    #  flickr.get_access_token(token['oauth_token'], token['oauth_token_secret'], oauth_verifier)
-    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
+  VERSION='0.9.2'
+  USER_AGENT = "FlickRaw/#{VERSION}"
 end
 
 # Use this to access the flickr API easily. You can type directly the flickr requests as they are described on the flickr website.

data/lib/flickraw/api.rb

@@ -0,0 +1,198 @@
+module FlickRaw
+  END_POINT='http://api.flickr.com/services'.freeze
+  END_POINT2='http://www.flickr.com/services'.freeze
+  END_POINT_SECURE='https://secure.flickr.com/services'.freeze
+  
+  FLICKR_OAUTH_REQUEST_TOKEN=(END_POINT2 + '/oauth/request_token').freeze
+  FLICKR_OAUTH_AUTHORIZE=(END_POINT2 + '/oauth/authorize').freeze
+  FLICKR_OAUTH_ACCESS_TOKEN=(END_POINT2 + '/oauth/access_token').freeze
+  
+  FLICKR_OAUTH_REQUEST_TOKEN_SECURE=(END_POINT_SECURE + '/oauth/request_token').freeze
+  FLICKR_OAUTH_AUTHORIZE_SECURE=(END_POINT_SECURE + '/oauth/authorize').freeze
+  FLICKR_OAUTH_ACCESS_TOKEN_SECURE=(END_POINT_SECURE + '/oauth/access_token').freeze
+
+  REST_PATH=(END_POINT + '/rest/').freeze
+  UPLOAD_PATH=(END_POINT + '/upload/').freeze
+  REPLACE_PATH=(END_POINT + '/replace/').freeze
+  
+  REST_PATH_SECURE=(END_POINT_SECURE + '/rest/').freeze
+  UPLOAD_PATH_SECURE=(END_POINT_SECURE + '/upload/').freeze
+  REPLACE_PATH_SECURE=(END_POINT_SECURE + '/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
+
+  # Root class of the flickr api hierarchy.
+  class Flickr < Request
+    # Authenticated access token
+    attr_accessor :access_token
+    
+    # Authenticated access token secret
+    attr_accessor :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 = OAuthClient.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)
+      rest_path = FlickRaw.secure ? REST_PATH_SECURE :  REST_PATH
+      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
+
+    # Get an oauth request token.
+    #
+    #    token = flickr.get_request_token(:oauth_callback => "http://example.com")
+    def get_request_token(args = {})
+      flickr_oauth_request_token = FlickRaw.secure ? FLICKR_OAUTH_REQUEST_TOKEN_SECURE : FLICKR_OAUTH_REQUEST_TOKEN
+      @oauth_consumer.request_token(flickr_oauth_request_token, args)
+    end
+    
+    # Get the oauth authorize url.
+    #
+    #  auth_url = flickr.get_authorize_url(token['oauth_token'], :perms => 'delete')
+    def get_authorize_url(token, args = {})
+      flickr_oauth_authorize = FlickRaw.secure ? FLICKR_OAUTH_AUTHORIZE_SECURE : FLICKR_OAUTH_AUTHORIZE
+      @oauth_consumer.authorize_url(flickr_oauth_authorize, args.merge(:oauth_token => token))
+    end
+
+    # Get an oauth access token.
+    #
+    #  flickr.get_access_token(token['oauth_token'], token['oauth_token_secret'], oauth_verifier)
+    def get_access_token(token, secret, verify)
+      flickr_oauth_access_token = FlickRaw.secure ? FLICKR_OAUTH_ACCESS_TOKEN_SECURE : FLICKR_OAUTH_ACCESS_TOKEN
+      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_path = FlickRaw.secure ? UPLOAD_PATH_SECURE : UPLOAD_PATH
+      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={})
+      replace_path = FlickRaw.secure ? REPLACE_PATH_SECURE : REPLACE_PATH
+      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
+    
+    # Use ssl connection
+    attr_accessor :secure
+    
+    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

data/lib/flickraw/oauth.rb

@@ -0,0 +1,150 @@
+require 'openssl'
+require 'net/http'
+
+module FlickRaw
+  class OAuthClient
+    class UnknownSignatureMethod < StandardError; end
+    class FailedResponse < StandardError
+      def initialize(str)
+        @response = OAuthClient.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
+      
+      def signature_base_string(method, url, params)
+        params_norm = params.map {|k,v| escape(k) + "=" + escape(v)}.sort.join("&")
+        method.to_s.upcase + "&" + escape(url) + "&" + escape(params_norm)
+      end
+      
+      def sign_plaintext(method, url, params, token_secret, consumer_secret)
+        escape(consumer_secret) + "&" + escape(token_secret)
+      end
+        
+      def sign_rsa_sha1(method, url, params, token_secret, consumer_secret)
+        text = signature_base_string(method, url, params)
+        key = OpenSSL::PKey::RSA.new(consumer_secret)
+        digest = OpenSSL::Digest::Digest.new("sha1")
+        [key.sign(digest, text)].pack('m0').gsub(/\n$/,'')
+      end
+            
+      def sign_hmac_sha1(method, url, params, token_secret, consumer_secret)
+        text = signature_base_string(method, url, params)
+        key = escape(consumer_secret) + "&" + escape(token_secret)
+        digest = OpenSSL::Digest::Digest.new("sha1")
+        [OpenSSL::HMAC.digest(digest, key, text)].pack('m0').gsub(/\n$/,'')
+      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_nonce => gen_nonce, :oauth_timestamp => gen_timestamp }
+      end
+    
+      def authorization_header(url, params)
+        params_norm = params.map {|k,v| %(#{escape(k)}="#{escape(v)}")}.sort.join(", ")
+        %(OAuth realm="#{url.to_s}", #{params_norm})
+      end
+    end
+    
+    attr_accessor :user_agent
+    attr_reader :proxy
+    def proxy=(url); @proxy = URI.parse(url || '') end
+    
+    def initialize(consumer_key, consumer_secret)
+      @consumer_key, @consumer_secret = consumer_key, consumer_secret
+      self.proxy = nil
+    end
+
+    def request_token(url, oauth_params = {})
+      r = post(url, nil, {:oauth_callback => "oob"}.merge(oauth_params))
+      OAuthClient.parse_response(r.body)
+    end
+    
+    def authorize_url(url, oauth_params = {})
+      params_norm = oauth_params.map {|k,v| OAuthClient.escape(k) + "=" + OAuthClient.escape(v)}.sort.join("&")
+      url =  URI.parse(url)
+      url.query = url.query ? url.query + "&" + params_norm : params_norm
+      url.to_s
+    end
+    
+    def access_token(url, token_secret, oauth_params = {})
+      r = post_form(url, token_secret, oauth_params)
+      OAuthClient.parse_response(r.body)
+    end
+
+    def post_form(url, token_secret, oauth_params = {}, params = {})
+      post(url, token_secret, oauth_params, params) {|request| request.form_data = params}
+    end
+    
+    def post_multipart(url, token_secret, oauth_params = {}, params = {})
+      post(url, token_secret, oauth_params, params) {|request|
+        boundary = "FlickRaw#{OAuthClient.gen_nonce}"
+        request['Content-type'] = "multipart/form-data, boundary=#{boundary}"
+
+        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}--"
+      }
+    end
+
+    private
+    def sign(method, url, params, token_secret = nil)
+      case params[:oauth_signature_method]
+      when "HMAC-SHA1"
+        OAuthClient.sign_hmac_sha1(method, url, params, token_secret, @consumer_secret)
+      when "RSA-SHA1"
+        OAuthClient.sign_rsa_sha1(method, url, params, token_secret, @consumer_secret)
+      when "PLAINTEXT"
+        OAuthClient.sign_plaintext(method, url, params, token_secret, @consumer_secret)
+      else
+        raise UnknownSignatureMethod, params[:oauth_signature_method]
+      end
+    end
+
+    def post(url, token_secret, oauth_params, params)
+      url = URI.parse(url)
+      default_oauth_params = OAuthClient.gen_default_params
+      default_oauth_params[:oauth_consumer_key] = @consumer_key
+      default_oauth_params[:oauth_signature_method] = "PLAINTEXT" if url.scheme == 'https'
+      oauth_params = default_oauth_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)
+
+      r = Net::HTTP.start(url.host, url.port,
+          @proxy.host, @proxy.port, @proxy.user, @proxy.password,
+          :use_ssl => url.scheme == 'https') { |http| 
+        request = Net::HTTP::Post.new(url.path)
+        request['User-Agent'] = @user_agent if @user_agent
+        request['Authorization'] = OAuthClient.authorization_header(url, oauth_params)
+
+        yield request
+        http.request(request)
+      }
+      
+      raise FailedResponse.new(r.body) if r.is_a? Net::HTTPClientError
+      r
+    end
+  end
+
+end

data/lib/flickraw/request.rb

@@ -0,0 +1,50 @@
+module FlickRaw
+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 the flickr subobjects of this object
+  def self.flickr_objects; @flickr_objects ||= [] end
+
+  # List 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
+
+end

data/lib/flickraw/response.rb

@@ -0,0 +1,58 @@
+module FlickRaw
+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
+
+end

data/rakefile

@@ -1,12 +1,15 @@
 require 'rake/clean'
-require 'rake/rdoctask'
+require 'rdoc/task'
 require 'rake/testtask'
 
-lib = File.dirname(__FILE__)
+lib = File.expand_path('../lib/', __FILE__)
 $:.unshift lib unless $:.include?(lib)
 
-require 'lib/flickraw'
-require 'flickraw_rdoc' if RUBY_VERSION >= "1.9"
+require 'flickraw'
+require './flickraw_rdoc' if RUBY_VERSION >= "1.9"
+
+FlickRaw.api_key = ENV['FLICKRAW_API_KEY']
+FlickRaw.shared_secret = ENV['FLICKRAW_SHARED_SECRET']
 
 Rake::RDocTask.new do |rd|
   rd.main = "README.rdoc"

data/test/helper.rb

@@ -0,0 +1,10 @@
+lib = File.expand_path('../../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'flickraw'
+
+FlickRaw.api_key = ENV['FLICKRAW_API_KEY']
+FlickRaw.shared_secret = ENV['FLICKRAW_SHARED_SECRET']
+
+flickr.access_token = ENV['FLICKRAW_ACCESS_TOKEN']
+flickr.access_secret = ENV['FLICKRAW_ACCESS_SECRET']

data/test/test.rb

@@ -1,13 +1,10 @@
 # -*- coding: utf-8 -*-
 
-lib = File.expand_path('../../lib/', __FILE__)
+lib = File.dirname(__FILE__)
 $:.unshift lib unless $:.include?(lib)
 
 require 'test/unit'
-require 'flickraw'
-
-# FlickRaw.shared_secret = # Shared secret
-# flickr.auth.checkToken :auth_token => # Auth token
+require 'helper'
 
 class Basic < Test::Unit::TestCase
   def test_request
@@ -335,7 +332,13 @@ class Basic < Test::Unit::TestCase
   def test_photos_getSizes
     info = flickr.photos.getSizes :photo_id => "3839885270"
     assert_equal "http://www.flickr.com/photos/41650587@N02/3839885270/sizes/l/", info.find {|f| f.label == "Large"}.url
-    assert_equal "http://farm3.static.flickr.com/2485/3839885270_6fb8b54e06_b.jpg", info.find {|f| f.label == "Large"}.source
+    if FlickRaw.secure
+      source = "https://farm3.static.flickr.com/2485/3839885270_6fb8b54e06_b.jpg"
+    else
+      source = "http://farm3.static.flickr.com/2485/3839885270_6fb8b54e06_b.jpg"
+    end
+    
+    assert_equal source, info.find {|f| f.label == "Large"}.source
   end
   
   def test_photos_search

data/test/test_upload.rb

@@ -1,19 +1,13 @@
 # -*- coding: utf-8 -*-
 
-lib = File.expand_path('../../lib/', __FILE__)
+lib = File.dirname(__FILE__)
 $:.unshift lib unless $:.include?(lib)
 
 require 'test/unit'
-require 'flickraw'
-
-# FlickRaw.api_key = # API key
-# FlickRaw.shared_secret = # Shared secret
-# flickr.access_token = # Auth token
-# flickr.access_secret = # Auth token secret
+require 'helper'
 
 class Upload < Test::Unit::TestCase
   def test_upload
-
     path = File.dirname(__FILE__) + '/image testée.jpg'
     u = info = nil
     title = "Titre de l'image testée"

metadata

@@ -1,11 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: flickraw
 version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 0
-  - 9
-  version: "0.9"
+  prerelease: 
+  version: 0.9.2
 platform: ruby
 authors: 
 - Mael Clerambault
@@ -13,8 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-20 00:00:00 +02:00
-default_executable: 
+date: 2011-10-09 00:00:00 Z
 dependencies: []
 
 description: 
@@ -33,12 +29,16 @@ files:
 - examples/upload.rb
 - test/test_upload.rb
 - test/test.rb
+- test/helper.rb
 - lib/flickraw.rb
+- lib/flickraw/oauth.rb
+- lib/flickraw/response.rb
+- lib/flickraw/request.rb
+- lib/flickraw/api.rb
 - flickraw_rdoc.rb
 - LICENSE
 - README.rdoc
 - rakefile
-has_rdoc: true
 homepage: http://hanklords.github.com/flickraw/
 licenses: []
 
@@ -52,21 +52,17 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      segments: 
-      - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Flickr library with a syntax close to the syntax described on http://www.flickr.com/services/api