Merge branch 'mendab1e-improved-formatting'

lib/flickraw.rb

@@ -9,7 +9,7 @@
 module FlickRaw
   VERSION='0.9.9'
   USER_AGENT = "FlickRaw/#{VERSION}"
-  
+
   self.secure = true
   self.check_certificate = true
 end

lib/flickraw/api.rb

@@ -2,19 +2,19 @@ module FlickRaw
   END_POINT='http://api.flickr.com/services'.freeze
   END_POINT2='http://www.flickr.com/services'.freeze
   END_POINT_SECURE='https://api.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
@@ -30,10 +30,10 @@ class FlickrAppNotConfigured < Error; end
   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(api_key: FlickRaw.api_key,
@@ -51,17 +51,17 @@ def initialize(api_key: FlickRaw.api_key,
       @oauth_consumer.ca_path = FlickRaw.ca_path
       @oauth_consumer.user_agent = USER_AGENT
       @access_token = @access_secret = nil
-      
+
       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)
       oauth_args = args.delete(:oauth) || {}
-      rest_path = FlickRaw.secure ? REST_PATH_SECURE :  REST_PATH
+      rest_path = FlickRaw.secure ? REST_PATH_SECURE : REST_PATH
       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
@@ -73,7 +73,7 @@ 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')
@@ -125,19 +125,19 @@ def process_response(req, response)
           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]
+          '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)
+        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}
+        type, json = json.to_a.first if json.size == 1 and json.all? { |k,v| v.is_a? Hash }
 
         Response.build json, type
       end
@@ -152,7 +152,7 @@ def upload_flickr(method, file, args={})
         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)
@@ -162,26 +162,26 @@ def upload_flickr(method, file, args={})
   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
 
     # 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
 
-    BASE58_ALPHABET="123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ".freeze
+    BASE58_ALPHABET='123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'.freeze
     def base58(id)
       id = id.to_i
       alphabet = BASE58_ALPHABET.split(//)
@@ -193,37 +193,37 @@ def base58(id)
       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(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_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_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) and r.pathalias
+        if r.respond_to?(:pathalias) && r.pathalias
           r.pathalias
         elsif r.owner.respond_to?(:nsid)
           r.owner.nsid
         else
           r.owner
-        end + "/"
+        end + '/'
     end
   end
 end

lib/flickraw/oauth.rb

@@ -13,123 +13,123 @@ def initialize(str)
 
     class << self
       def encode_value(v)
-        v = v.to_s.encode("utf-8").force_encoding("ascii-8bit") if RUBY_VERSION >= "1.9"
+        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\-\.\_\~]/) { |special|
-          special.unpack("C*").map{|i| sprintf("%%%02X", i) }.join
-        }
+        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 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)
+        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)
+        "#{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)
+        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_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(", ")
+        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))
+      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
+      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}
+      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) {|request|
         boundary = "FlickRaw#{OAuthClient.gen_nonce}"
         request['Content-type'] = "multipart/form-data, boundary=#{boundary}"
 
         request.body = ''
-        params.each { |k, v|
+        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"
+            "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"
+            "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
 
     private
     def sign(method, url, params, token_secret = nil)
       case params[:oauth_signature_method]
-      when "HMAC-SHA1"
+      when 'HMAC-SHA1'
         OAuthClient.sign_hmac_sha1(method, url, params, token_secret, @consumer_secret)
-      when "RSA-SHA1"
+      when 'RSA-SHA1'
         OAuthClient.sign_rsa_sha1(method, url, params, token_secret, @consumer_secret)
-      when "PLAINTEXT"
+      when 'PLAINTEXT'
         OAuthClient.sign_plaintext(method, url, params, token_secret, @consumer_secret)
       else
         raise UnknownSignatureMethod, params[:oauth_signature_method]
@@ -140,28 +140,27 @@ 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'
+      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.respond_to? :read}.merge(oauth_params)
+      params_signed = params.reject { |k,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 {|agent|
+      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