flickr 1.0.2 → 2.0.0

data/lib/flickr.rb

@@ -0,0 +1,281 @@
+require 'json'
+require 'yaml'
+require 'flickr/version'
+require 'flickr/util'
+require 'flickr/errors'
+require 'flickr/oauth_client'
+require 'flickr/request'
+require 'flickr/response'
+require 'flickr/response_list'
+
+class Flickr
+
+  USER_AGENT                 = "Flickr/#{VERSION} (+https://github.com/hanklords/flickraw)".freeze
+  END_POINT                  = 'https://api.flickr.com/services'.freeze
+  FLICKR_OAUTH_REQUEST_TOKEN = (END_POINT + '/oauth/request_token').freeze
+  FLICKR_OAUTH_AUTHORIZE     = (END_POINT + '/oauth/authorize').freeze
+  FLICKR_OAUTH_ACCESS_TOKEN  = (END_POINT + '/oauth/access_token').freeze
+  REST_PATH                  = (END_POINT + '/rest/').freeze
+  UPLOAD_PATH                = (END_POINT + '/upload/').freeze
+  REPLACE_PATH               = (END_POINT + '/replace/').freeze
+  PHOTO_SOURCE_URL           = 'https://farm%s.staticflickr.com/%s/%s_%s%s.%s'.freeze
+  URL_PROFILE                = 'https://www.flickr.com/people/'.freeze
+  URL_PHOTOSTREAM            = 'https://www.flickr.com/photos/'.freeze
+  URL_SHORT                  = 'https://flic.kr/p/'.freeze
+
+  # Authenticated access token
+  attr_accessor :access_token
+
+  # Authenticated access token secret
+  attr_accessor :access_secret
+
+  attr_reader :client
+
+  @@initialized = false
+  @@mutex = Mutex.new
+
+  def initialize(api_key = ENV['FLICKR_API_KEY'], shared_secret = ENV['FLICKR_SHARED_SECRET'])
+
+    raise FlickrAppNotConfigured.new("No API key defined!") if api_key.nil?
+    raise FlickrAppNotConfigured.new("No shared secret defined!") if shared_secret.nil?
+
+    @access_token = @access_secret = nil
+    @oauth_consumer = oauth_consumer api_key, shared_secret
+
+    @@mutex.synchronize do
+      unless @@initialized
+        build_classes retrieve_endpoints
+        @@initialized = true
+      end
+    end
+    @client = self # used for propagating the client to sub-classes
+  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)
+    oauth_args = args.delete(:oauth) || {}
+    http_response = @oauth_consumer.post_form(REST_PATH, @access_secret, {:oauth_token => @access_token}.merge(oauth_args), build_args(args, req))
+    process_response(req, http_response.body)
+  end
+
+  # Get an oauth request token.
+  #
+  #    token = flickr.get_request_token(:oauth_callback => "https://example.com")
+  def get_request_token(args = {})
+    @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 https://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 https://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 retrieve_endpoints
+    if Flickr.cache and File.exist?(Flickr.cache)
+      YAML.load_file Flickr.cache
+    else
+      endpoints = call('flickr.reflection.getMethods').to_a
+      File.open(Flickr.cache, 'w') do |file|
+        file.write(YAML.dump endpoints)
+      end if Flickr.cache
+      endpoints
+    end
+  end
+
+  def oauth_consumer(api_key, shared_secret)
+    client = OAuthClient.new api_key, shared_secret
+    client.proxy = Flickr.proxy
+    client.check_certificate = Flickr.check_certificate
+    client.ca_file = Flickr.ca_file
+    client.ca_path = Flickr.ca_path
+    client.user_agent = USER_AGENT
+    client
+  end
+
+  def build_classes(endpoints)
+
+    endpoints.sort.each do |endpoint|
+
+      *breadcrumbs, tail = endpoint.split '.'
+
+      raise "Invalid namespace" unless 'flickr' == breadcrumbs.shift
+
+      base_class = breadcrumbs.reduce(::Flickr) do |memo, klass|
+
+        cklass = klass.capitalize
+
+        if memo.const_defined? cklass, false
+          memo.const_get cklass
+        else
+          new_class = Class.new { include ::Flickr::Request }
+          memo.const_set cklass, new_class
+          memo.send(:define_method, klass) do
+            new_class.new @client
+          end
+          new_class
+        end
+      end
+
+      base_class.send(:define_method, tail) do |*args, &block|
+        @client.call(endpoint, *args, &block)
+      end unless base_class.method_defined? tail
+
+    end
+
+  end
+
+  def build_args(args={}, method_name=nil)
+    args['method'] = method_name if method_name
+    args.merge('format' => 'json', 'nojsoncallback' => '1')
+  end
+
+  def process_response(req, response)
+    puts response.inspect if ENV['FLICKR_DEBUG']
+
+    if /\A<\?xml / === response # 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 { |_, 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.values.all? { |x| Hash === x }
+
+      Response.build json, type
+    end
+  end
+
+  def upload_flickr(method, file, args={})
+    oauth_args = args.delete(:oauth) || {}
+    args = build_args(args)
+    if file.respond_to? :read
+      args['photo'] = file
+    else
+      args['photo'] = open(file, 'rb')
+      close_after = true
+    end
+
+    http_response = @oauth_consumer.post_multipart(method, @access_secret, {:oauth_token => @access_token}.merge(oauth_args), args)
+    args['photo'].close if close_after
+    process_response(method, http_response.body)
+  end
+
+  class << self
+    # Your flickr API key, see https://www.flickr.com/services/api/keys for more information
+    attr_accessor :api_key
+
+    # The shared secret of _api_key_, see https://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
+
+    # Check the server certificate (ssl connection only)
+    attr_accessor :check_certificate
+
+    # Set path of a CA certificate file in PEM format (ssl connection only)
+    attr_accessor :ca_file
+
+    # Set path to a directory of CA certificate files in PEM format (ssl connection only)
+    attr_accessor :ca_path
+
+    # Set path to a file that can be used to store endpoints
+    attr_accessor :cache
+
+    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_q(r); PHOTO_SOURCE_URL % [r.farm, r.server, r.id, r.secret, '_q', 'jpg'] end
+    def url_n(r); PHOTO_SOURCE_URL % [r.farm, r.server, r.id, r.secret, '_n', 'jpg'] end
+    def url_c(r); PHOTO_SOURCE_URL % [r.farm, r.server, r.id, r.secret, '_c', 'jpg'] end
+    def url_h(r); PHOTO_SOURCE_URL % [r.farm, r.server, r.id, r.secret, '_h', 'jpg'] end
+    def url_k(r); PHOTO_SOURCE_URL % [r.farm, r.server, r.id, r.secret, '_k', '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_short_q(r); URL_SHORT + 'img/' + base58(r.id) + '_q.jpg' end
+    def url_short_n(r); URL_SHORT + 'img/' + base58(r.id) + '_n.jpg' end
+    def url_photostream(r)
+      URL_PHOTOSTREAM +
+        if r.respond_to?(:pathalias) && r.pathalias
+          r.pathalias
+        elsif r.owner.respond_to?(:nsid)
+          r.owner.nsid
+        else
+          r.owner
+        end + '/'
+    end
+  end
+
+  self.check_certificate = true
+
+end

data/lib/flickr/errors.rb

@@ -0,0 +1,15 @@
+class Flickr
+  class Error < StandardError; end
+
+  class FlickrAppNotConfigured < Error; end
+
+  class FailedResponse < Error
+    attr_reader :code
+    alias :msg :message
+    def initialize(msg, code, req)
+      @code = code
+      super("'#{req}' - #{msg}")
+    end
+  end
+
+end

data/lib/flickr/oauth_client.rb

@@ -0,0 +1,175 @@
+require 'openssl'
+require 'net/https'
+
+class Flickr
+  class OAuthClient
+
+    class UnknownSignatureMethod < Error; end
+
+    class FailedResponse < Error
+      def initialize(str)
+        @response = OAuthClient.parse_response(str)
+        super(@response['oauth_problem'])
+      end
+    end
+
+    class << self
+      def encode_value(v)
+        v = v.to_s.encode('utf-8').force_encoding('ascii-8bit') if RUBY_VERSION >= '1.9'
+        v.to_s
+      end
+
+      def escape(s)
+        encode_value(s).gsub(/[^a-zA-Z0-9\-\.\_\~]/) do |special|
+          special.unpack("C*").map { |i| sprintf("%%%02X", i) }.join
+        end
+      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::SHA1.new
+        [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::SHA1.new
+        [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
+    attr_accessor :check_certificate
+    attr_accessor :ca_file
+    attr_accessor :ca_path
+    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_form(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 = {})
+      encoded_params = Hash[*params.map { |k, v| [OAuthClient.encode_value(k), OAuthClient.encode_value(v)]}.flatten]
+      post(url, token_secret, oauth_params, params) { |request| request.form_data = encoded_params }
+    end
+
+    def post_multipart(url, token_secret, oauth_params = {}, params = {})
+      post(url, token_secret, oauth_params, params) do |request|
+        boundary = "Flickr#{OAuthClient.gen_nonce}"
+        request['Content-type'] = "multipart/form-data, boundary=#{boundary}"
+
+        request.body = ''
+        params.each do |k, v|
+          if v.respond_to? :read
+            basename = File.basename(v.path.to_s) if v.respond_to? :path
+            basename ||= File.basename(v.base_uri.to_s) if v.respond_to? :base_uri
+            basename ||= "unknown"
+            request.body << "--#{boundary}\r\n" <<
+            "Content-Disposition: form-data; name=\"#{OAuthClient.encode_value(k)}\"; filename=\"#{OAuthClient.encode_value(basename)}\"\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=\"#{OAuthClient.encode_value(k)}\"\r\n\r\n" <<
+            "#{OAuthClient.encode_value(v)}\r\n"
+          end
+        end
+
+        request.body << "--#{boundary}--"
+      end
+    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 { |_, v| v.respond_to? :read }.merge(oauth_params)
+      oauth_params[:oauth_signature] = sign(:post, url, params_signed, token_secret)
+
+      http = Net::HTTP.new(url.host, url.port, @proxy.host, @proxy.port, @proxy.user, @proxy.password)
+      http.use_ssl = (url.scheme == 'https')
+      http.verify_mode = (@check_certificate ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE)
+      http.ca_file = @ca_file
+      http.ca_path = @ca_path
+      r = http.start do |agent|
+        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
+        agent.request(request)
+      end
+
+      raise FailedResponse.new(r.body) if r.is_a? Net::HTTPClientError
+      r
+    end
+  end
+end