oauth 0.5.7.pre.pre1 → 0.5.9

data/lib/oauth/request_proxy/net_http.rb

@@ -1,72 +1,81 @@
+# frozen_string_literal: true
+
 require "oauth/request_proxy/base"
 require "net/http"
 require "uri"
 require "cgi"
 
-module OAuth::RequestProxy::Net
-  module HTTP
-    class HTTPRequest < OAuth::RequestProxy::Base
-      proxies ::Net::HTTPGenericRequest
+module OAuth
+  module RequestProxy
+    module Net
+      module HTTP
+        class HTTPRequest < OAuth::RequestProxy::Base
+          proxies ::Net::HTTPGenericRequest
 
-      def method
-        request.method
-      end
+          def method
+            request.method
+          end
 
-      def uri
-        options[:uri].to_s
-      end
+          def uri
+            options[:uri].to_s
+          end
 
-      def parameters
-        if options[:clobber_request]
-          options[:parameters]
-        else
-          all_parameters
-        end
-      end
+          def parameters
+            if options[:clobber_request]
+              options[:parameters]
+            else
+              all_parameters
+            end
+          end
 
-      def body
-        request.body
-      end
+          def body
+            request.body
+          end
 
-    private
+          private
 
-      def all_parameters
-        request_params = CGI.parse(query_string)
-        # request_params.each{|k,v| request_params[k] = [nil] if v == []}
+          def all_parameters
+            request_params = CGI.parse(query_string)
+            # request_params.each{|k,v| request_params[k] = [nil] if v == []}
 
-        if options[:parameters]
-          options[:parameters].each do |k,v|
-            if request_params.has_key?(k) && v
-              request_params[k] << v
-            else
-              request_params[k] = [v]
+            if options[:parameters]
+              options[:parameters].each do |k, v|
+                if request_params.key?(k) && v
+                  request_params[k] << v
+                else
+                  request_params[k] = [v]
+                end
+              end
             end
+            request_params
           end
-        end
-        request_params
-      end
 
-      def query_string
-        params = [ query_params, auth_header_params ]
-        params << post_params if (method.to_s.upcase == "POST" || method.to_s.upcase == "PUT") && form_url_encoded?
-        params.compact.join("&")
-      end
+          def query_string
+            params = [query_params, auth_header_params]
+            if (method.to_s.casecmp("POST").zero? || method.to_s.casecmp("PUT").zero?) && form_url_encoded?
+              params << post_params
+            end
+            params.compact.join("&")
+          end
 
-      def form_url_encoded?
-        request["Content-Type"] != nil && request["Content-Type"].to_s.downcase.start_with?("application/x-www-form-urlencoded")
-      end
+          def form_url_encoded?
+            !request["Content-Type"].nil? && request["Content-Type"].to_s.downcase.start_with?("application/x-www-form-urlencoded")
+          end
 
-      def query_params
-        URI.parse(request.path).query
-      end
+          def query_params
+            URI.parse(request.path).query
+          end
 
-      def post_params
-        request.body
-      end
+          def post_params
+            request.body
+          end
 
-      def auth_header_params
-        return nil unless request["Authorization"] && request["Authorization"][0,5] == "OAuth"
-        request["Authorization"]
+          def auth_header_params
+            return nil unless request["Authorization"] && request["Authorization"][0, 5] == "OAuth"
+
+            request["Authorization"]
+          end
+        end
       end
     end
   end

data/lib/oauth/request_proxy/rack_request.rb

@@ -1,43 +1,47 @@
+# frozen_string_literal: true
+
 require "oauth/request_proxy/base"
 require "uri"
 require "rack"
 
-module OAuth::RequestProxy
-  class RackRequest < OAuth::RequestProxy::Base
-    proxies Rack::Request
+module OAuth
+  module RequestProxy
+    class RackRequest < OAuth::RequestProxy::Base
+      proxies ::Rack::Request
 
-    def method
-      request.env["rack.methodoverride.original_method"] || request.request_method
-    end
+      def method
+        request.env["rack.methodoverride.original_method"] || request.request_method
+      end
 
-    def uri
-      request.url
-    end
+      def uri
+        request.url
+      end
 
-    def parameters
-      if options[:clobber_request]
-        options[:parameters] || {}
-      else
-        params = request_params.merge(query_params).merge(header_params)
-        params.merge(options[:parameters] || {})
+      def parameters
+        if options[:clobber_request]
+          options[:parameters] || {}
+        else
+          params = request_params.merge(query_params).merge(header_params)
+          params.merge(options[:parameters] || {})
+        end
       end
-    end
 
-    def signature
-      parameters["oauth_signature"]
-    end
+      def signature
+        parameters["oauth_signature"]
+      end
 
-  protected
+      protected
 
-    def query_params
-      request.GET
-    end
+      def query_params
+        request.GET
+      end
 
-    def request_params
-      if request.content_type and request.content_type.to_s.downcase.start_with?("application/x-www-form-urlencoded")
-        request.POST
-      else
-        {}
+      def request_params
+        if request.content_type && request.content_type.to_s.downcase.start_with?("application/x-www-form-urlencoded")
+          request.POST
+        else
+          {}
+        end
       end
     end
   end

data/lib/oauth/request_proxy/rest_client_request.rb

@@ -1,62 +1,65 @@
+# frozen_string_literal: true
+
 require "oauth/request_proxy/base"
 require "rest-client"
 require "uri"
 require "cgi"
 
-module OAuth::RequestProxy::RestClient
-  class Request < OAuth::RequestProxy::Base
-    proxies RestClient::Request
-    
-      def method
-        request.method.to_s.upcase
-      end
+module OAuth
+  module RequestProxy
+    module RestClient
+      class Request < OAuth::RequestProxy::Base
+        proxies ::RestClient::Request
 
-      def uri
-        request.url
-      end
+        def method
+          request.method.to_s.upcase
+        end
 
-      def parameters
-        if options[:clobber_request]
-          options[:parameters] || {}
-        else
-          post_parameters.merge(query_params).merge(options[:parameters] || {})
+        def uri
+          request.url
         end
-      end
 
-    protected
+        def parameters
+          if options[:clobber_request]
+            options[:parameters] || {}
+          else
+            post_parameters.merge(query_params).merge(options[:parameters] || {})
+          end
+        end
 
-      def query_params
-        query = URI.parse(request.url).query
-        query ? CGI.parse(query) : {}
-      end
+        protected
 
-      def request_params
-      end
-      
-      def post_parameters
-        # Post params are only used if posting form data
-        if method == "POST" || method == "PUT"
-          OAuth::Helper.stringify_keys(query_string_to_hash(request.payload.to_s) || {})
-        else
-          {}
+        def query_params
+          query = URI.parse(request.url).query
+          query ? CGI.parse(query) : {}
         end
-      end
-      
-   private
-      
-      def query_string_to_hash(query)
-        keyvals = query.split("&").inject({}) do |result, q| 
-          k,v = q.split("=")
-          if !v.nil?
-             result.merge({k => v})
-          elsif !result.key?(k)
-            result.merge({k => true})
+
+        def request_params; end
+
+        def post_parameters
+          # Post params are only used if posting form data
+          if method == "POST" || method == "PUT"
+            OAuth::Helper.stringify_keys(query_string_to_hash(request.payload.to_s) || {})
           else
-            result
+            {}
+          end
+        end
+
+        private
+
+        def query_string_to_hash(query)
+          query.split("&").inject({}) do |result, q|
+            k, v = q.split("=")
+            if !v.nil?
+              result.merge(k => v)
+            elsif !result.key?(k)
+              result.merge(k => true)
+            else
+              result
+            end
           end
         end
-        keyvals
       end
-      
+    end
   end
-end
+end

data/lib/oauth/request_proxy/typhoeus_request.rb

@@ -1,53 +1,59 @@
+# frozen_string_literal: true
+
 require "oauth/request_proxy/base"
 require "typhoeus"
 require "typhoeus/request"
 require "uri"
 require "cgi"
 
-module OAuth::RequestProxy::Typhoeus
-  class Request < OAuth::RequestProxy::Base
-    # Proxy for signing Typhoeus::Request requests
-    # Usage example:
-    # oauth_params = {:consumer => oauth_consumer, :token => access_token}
-    # req = Typhoeus::Request.new(uri, options)
-    # oauth_helper = OAuth::Client::Helper.new(req, oauth_params.merge(:request_uri => uri))
-    # req.options[:headers].merge!({"Authorization" => oauth_helper.header})
-    # hydra = Typhoeus::Hydra.new()
-    # hydra.queue(req)
-    # hydra.run
-    # response = req.response
-    proxies Typhoeus::Request
-
-    def method
-      request_method = request.options[:method].to_s.upcase
-      request_method.empty? ? "GET" : request_method
-    end
+module OAuth
+  module RequestProxy
+    module Typhoeus
+      class Request < OAuth::RequestProxy::Base
+        # Proxy for signing Typhoeus::Request requests
+        # Usage example:
+        # oauth_params = {:consumer => oauth_consumer, :token => access_token}
+        # req = Typhoeus::Request.new(uri, options)
+        # oauth_helper = OAuth::Client::Helper.new(req, oauth_params.merge(:request_uri => uri))
+        # req.options[:headers].merge!({"Authorization" => oauth_helper.header})
+        # hydra = Typhoeus::Hydra.new()
+        # hydra.queue(req)
+        # hydra.run
+        # response = req.response
+        proxies ::Typhoeus::Request
 
-    def uri
-      options[:uri].to_s
-    end
+        def method
+          request_method = request.options[:method].to_s.upcase
+          request_method.empty? ? "GET" : request_method
+        end
 
-    def parameters
-      if options[:clobber_request]
-        options[:parameters]
-      else
-        post_parameters.merge(query_parameters).merge(options[:parameters] || {})
-      end
-    end
+        def uri
+          options[:uri].to_s
+        end
 
-    private
+        def parameters
+          if options[:clobber_request]
+            options[:parameters]
+          else
+            post_parameters.merge(query_parameters).merge(options[:parameters] || {})
+          end
+        end
 
-    def query_parameters
-      query = URI.parse(request.url).query
-      query ? CGI.parse(query) : {}
-    end
+        private
+
+        def query_parameters
+          query = URI.parse(request.url).query
+          query ? CGI.parse(query) : {}
+        end
 
-    def post_parameters
-      # Post params are only used if posting form data
-      if method == "POST"
-        OAuth::Helper.stringify_keys(request.options[:params] || {})
-      else
-        {}
+        def post_parameters
+          # Post params are only used if posting form data
+          if method == "POST"
+            OAuth::Helper.stringify_keys(request.options[:params] || {})
+          else
+            {}
+          end
+        end
       end
     end
   end

data/lib/oauth/request_proxy.rb

@@ -5,13 +5,13 @@ module OAuth
     end
 
     def self.proxy(request, options = {})
-      return request if request.kind_of?(OAuth::RequestProxy::Base)
+      return request if request.is_a?(OAuth::RequestProxy::Base)
 
       klass = available_proxies[request.class]
 
       # Search for possible superclass matches.
       if klass.nil?
-        request_parent = available_proxies.keys.find { |rc| request.kind_of?(rc) }
+        request_parent = available_proxies.keys.find { |rc| request.is_a?(rc) }
         klass = available_proxies[request_parent]
       end
 
@@ -19,6 +19,6 @@ module OAuth
       klass.new(request, options)
     end
 
-    class UnknownRequestType < Exception; end
+    class UnknownRequestType < RuntimeError; end
   end
 end

data/lib/oauth/server.rb

@@ -8,9 +8,9 @@ module OAuth
     attr_accessor :base_url
 
     @@server_paths = {
-      :request_token_path => "/oauth/request_token",
-      :authorize_path     => "/oauth/authorize",
-      :access_token_path  => "/oauth/access_token"
+      request_token_path: "/oauth/request_token",
+      authorize_path: "/oauth/authorize",
+      access_token_path: "/oauth/access_token"
     }
 
     # Create a new server instance
@@ -23,7 +23,7 @@ module OAuth
       [generate_key(16), generate_key]
     end
 
-    def generate_consumer_credentials(params = {})
+    def generate_consumer_credentials(_params = {})
       Consumer.new(*generate_credentials)
     end
 
@@ -31,12 +31,10 @@ module OAuth
     def create_consumer
       creds = generate_credentials
       Consumer.new(creds[0], creds[1],
-        {
-          :site               => base_url,
-          :request_token_path => request_token_path,
-          :authorize_path     => authorize_path,
-          :access_token_path  => access_token_path
-        })
+                   site: base_url,
+                   request_token_path: request_token_path,
+                   authorize_path: authorize_path,
+                   access_token_path: access_token_path)
     end
 
     def request_token_path

data/lib/oauth/signature/base.rb

@@ -17,7 +17,7 @@ module OAuth::Signature
     end
 
     def initialize(request, options = {}, &block)
-      raise TypeError unless request.kind_of?(OAuth::RequestProxy::Base)
+      raise TypeError unless request.is_a?(OAuth::RequestProxy::Base)
       @request = request
       @options = options
 
@@ -47,7 +47,7 @@ module OAuth::Signature
     end
 
     def signature
-      Base64.encode64(digest).chomp.gsub(/\n/,"")
+      Base64.encode64(digest).chomp.delete("\n")
     end
 
     def ==(cmp_signature)
@@ -57,7 +57,7 @@ module OAuth::Signature
     end
 
     def verify
-      self == self.request.signature
+      self == request.signature
     end
 
     def signature_base_string
@@ -93,6 +93,5 @@ module OAuth::Signature
     def raise_instantiation_error
       raise NotImplementedError, "Cannot instantiate #{self.class.name} class directly."
     end
-
   end
 end

data/lib/oauth/signature/hmac/sha1.rb

@@ -5,7 +5,7 @@ module OAuth::Signature::HMAC
     implements "hmac-sha1"
 
     def body_hash
-      Base64.encode64(OpenSSL::Digest::SHA1.digest(request.body || "")).chomp.gsub(/\n/,"")
+      Base64.encode64(OpenSSL::Digest::SHA1.digest(request.body || "")).chomp.delete("\n")
     end
 
     private

data/lib/oauth/signature/hmac/sha256.rb

@@ -5,7 +5,7 @@ module OAuth::Signature::HMAC
     implements "hmac-sha256"
 
     def body_hash
-      Base64.encode64(OpenSSL::Digest::SHA256.digest(request.body || "")).chomp.gsub(/\n/,"")
+      Base64.encode64(OpenSSL::Digest::SHA256.digest(request.body || "")).chomp.delete("\n")
     end
 
     private

data/lib/oauth/signature/rsa/sha1.rb

@@ -19,7 +19,7 @@ module OAuth::Signature::RSA
     end
 
     def body_hash
-      Base64.encode64(OpenSSL::Digest::SHA1.digest(request.body || "")).chomp.gsub(/\n/,"")
+      Base64.encode64(OpenSSL::Digest::SHA1.digest(request.body || "")).chomp.delete("\n")
     end
 
     private
@@ -27,9 +27,9 @@ module OAuth::Signature::RSA
     def decode_public_key
       case consumer_secret
       when /-----BEGIN CERTIFICATE-----/
-        OpenSSL::X509::Certificate.new( consumer_secret).public_key
+        OpenSSL::X509::Certificate.new(consumer_secret).public_key
       else
-        OpenSSL::PKey::RSA.new( consumer_secret)
+        OpenSSL::PKey::RSA.new(consumer_secret)
       end
     end
 

data/lib/oauth/signature.rb

@@ -20,26 +20,26 @@ module OAuth
 
     # Sign a +request+
     def self.sign(request, options = {}, &block)
-      self.build(request, options, &block).signature
+      build(request, options, &block).signature
     end
 
     # Verify the signature of +request+
     def self.verify(request, options = {}, &block)
-      self.build(request, options, &block).verify
+      build(request, options, &block).verify
     end
 
     # Create the signature base string for +request+. This string is the normalized parameter information.
     #
     # See Also: {OAuth core spec version 1.0, section 9.1.1}[http://oauth.net/core/1.0#rfc.section.9.1.1]
     def self.signature_base_string(request, options = {}, &block)
-      self.build(request, options, &block).signature_base_string
+      build(request, options, &block).signature_base_string
     end
 
     # Create the body hash for a request
     def self.body_hash(request, options = {}, &block)
-      self.build(request, options, &block).body_hash
+      build(request, options, &block).body_hash
     end
 
-    class UnknownSignatureMethod < Exception; end
+    class UnknownSignatureMethod < RuntimeError; end
   end
 end

data/lib/oauth/tokens/consumer_token.rb

@@ -5,12 +5,12 @@ module OAuth
     attr_reader   :response
 
     def self.from_hash(consumer, hash)
-      token = self.new(consumer, hash[:oauth_token], hash[:oauth_token_secret])
+      token = new(consumer, hash[:oauth_token], hash[:oauth_token_secret])
       token.params = hash
       token
     end
 
-    def initialize(consumer, token="", secret="")
+    def initialize(consumer, token = "", secret = "")
       super(token, secret)
       @consumer = consumer
       @params   = {}

data/lib/oauth/tokens/request_token.rb

@@ -2,19 +2,18 @@ module OAuth
   # The RequestToken is used for the initial Request.
   # This is normally created by the Consumer object.
   class RequestToken < ConsumerToken
-
     # Generate an authorization URL for user authorization
     def authorize_url(params = nil)
-      return nil if self.token.nil?
+      return nil if token.nil?
 
-      params = (params || {}).merge(:oauth_token => self.token)
+      params = (params || {}).merge(oauth_token: token)
       build_url(consumer.authorize_url, params)
     end
 
     def authenticate_url(params = nil)
-      return nil if self.token.nil?
+      return nil if token.nil?
 
-      params = (params || {}).merge(:oauth_token => self.token)
+      params = (params || {}).merge(oauth_token: token)
       build_url(consumer.authenticate_url, params)
     end
 
@@ -28,16 +27,16 @@ module OAuth
       OAuth::AccessToken.from_hash(consumer, response)
     end
 
-  protected
+    protected
 
     # construct an authorization or authentication url
     def build_url(base_url, params)
       uri = URI.parse(base_url.to_s)
       queries = {}
       queries = Hash[URI.decode_www_form(uri.query)] if uri.query
-      # TODO doesn't handle array values correctly
+      # TODO: doesn't handle array values correctly
       queries.merge!(params) if params
-      uri.query = URI.encode_www_form(queries) if !queries.empty?
+      uri.query = URI.encode_www_form(queries) unless queries.empty?
       uri.to_s
     end
   end

data/lib/oauth/tokens/server_token.rb

@@ -1,7 +1,6 @@
 module OAuth
   # Used on the server for generating tokens
   class ServerToken < Token
-
     def initialize
       super(generate_key(16), generate_key)
     end