oauth 0.5.7 → 0.5.10

data/lib/oauth/client/action_controller_request.rb

@@ -10,12 +10,12 @@ end
 module ActionController
   class Base
     if defined? ActionDispatch
-      def process_with_new_base_test(request, response=nil)
+      def process_with_new_base_test(request, response = nil)
         request.apply_oauth! if request.respond_to?(:apply_oauth!)
         super(request, response)
       end
     else
-      def process_with_oauth(request, response=nil)
+      def process_with_oauth(request, response = nil)
         request.apply_oauth! if request.respond_to?(:apply_oauth!)
         process_without_oauth(request, response)
       end
@@ -24,8 +24,8 @@ module ActionController
   end
 
   class TestRequest
-    def self.use_oauth=(bool)
-      @use_oauth = bool
+    class << self
+      attr_writer :use_oauth
     end
 
     def self.use_oauth?
@@ -33,21 +33,21 @@ module ActionController
     end
 
     def configure_oauth(consumer = nil, token = nil, options = {})
-      @oauth_options = { :consumer  => consumer,
-                         :token     => token,
-                         :scheme    => "header",
-                         :signature_method => nil,
-                         :nonce     => nil,
-                         :timestamp => nil }.merge(options)
+      @oauth_options = { consumer: consumer,
+                         token: token,
+                         scheme: "header",
+                         signature_method: nil,
+                         nonce: nil,
+                         timestamp: nil }.merge(options)
     end
 
     def apply_oauth!
       return unless ActionController::TestRequest.use_oauth? && @oauth_options
 
-      @oauth_helper = OAuth::Client::Helper.new(self, @oauth_options.merge(:request_uri => (respond_to?(:fullpath) ? fullpath : request_uri)))
+      @oauth_helper = OAuth::Client::Helper.new(self, @oauth_options.merge(request_uri: (respond_to?(:fullpath) ? fullpath : request_uri)))
       @oauth_helper.amend_user_agent_header(env)
 
-      self.send("set_oauth_#{@oauth_options[:scheme]}")
+      send("set_oauth_#{@oauth_options[:scheme]}")
     end
 
     def set_oauth_header
@@ -56,10 +56,9 @@ module ActionController
 
     def set_oauth_parameters
       @query_parameters = @oauth_helper.parameters_with_oauth
-      @query_parameters.merge!(:oauth_signature => @oauth_helper.signature)
+      @query_parameters.merge!(oauth_signature: @oauth_helper.signature)
     end
 
-    def set_oauth_query_string
-    end
+    def set_oauth_query_string; end
   end
 end

data/lib/oauth/client/em_http.rb

@@ -23,16 +23,16 @@ module EventMachine
     #
     # See Also: {OAuth core spec version 1.0, section 5.4.1}[http://oauth.net/core/1.0#rfc.section.5.4.1]
     def oauth!(http, consumer = nil, token = nil, options = {})
-      options = { :request_uri      => normalized_oauth_uri(http),
-                  :consumer         => consumer,
-                  :token            => token,
-                  :scheme           => "header",
-                  :signature_method => nil,
-                  :nonce            => nil,
-                  :timestamp        => nil }.merge(options)
+      options = { request_uri: normalized_oauth_uri(http),
+                  consumer: consumer,
+                  token: token,
+                  scheme: "header",
+                  signature_method: nil,
+                  nonce: nil,
+                  timestamp: nil }.merge(options)
 
       @oauth_helper = OAuth::Client::Helper.new(self, options)
-      self.__send__(:"set_oauth_#{options[:scheme]}")
+      __send__(:"set_oauth_#{options[:scheme]}")
     end
 
     # Create a string suitable for signing for an HTTP request. This process involves parameter
@@ -49,13 +49,13 @@ module EventMachine
     #
     # See Also: {OAuth core spec version 1.0, section 9.1.1}[http://oauth.net/core/1.0#rfc.section.9.1.1]
     def signature_base_string(http, consumer = nil, token = nil, options = {})
-      options = { :request_uri      => normalized_oauth_uri(http),
-                  :consumer         => consumer,
-                  :token            => token,
-                  :scheme           => "header",
-                  :signature_method => nil,
-                  :nonce            => nil,
-                  :timestamp        => nil }.merge(options)
+      options = { request_uri: normalized_oauth_uri(http),
+                  consumer: consumer,
+                  token: token,
+                  scheme: "header",
+                  signature_method: nil,
+                  nonce: nil,
+                  timestamp: nil }.merge(options)
 
       OAuth::Client::Helper.new(self, options).signature_base_string
     end
@@ -77,13 +77,13 @@ module EventMachine
     protected
 
     def combine_query(path, query, uri_query)
-      combined_query = if query.kind_of?(Hash)
-        query.map { |k, v| encode_param(k, v) }.join("&")
-      else
-        query.to_s
+      combined_query = if query.is_a?(Hash)
+                         query.map { |k, v| encode_param(k, v) }.join("&")
+                       else
+                         query.to_s
       end
-      if !uri_query.to_s.empty?
-        combined_query = [combined_query, uri_query].reject {|part| part.empty?}.join("&")
+      unless uri_query.to_s.empty?
+        combined_query = [combined_query, uri_query].reject(&:empty?).join("&")
       end
       combined_query.to_s.empty? ? path : "#{path}?#{combined_query}"
     end
@@ -95,17 +95,17 @@ module EventMachine
       uri.host = http.address
       uri.port = http.port
 
-      if http.respond_to?(:use_ssl?) && http.use_ssl?
-        uri.scheme = "https"
-      else
-        uri.scheme = "http"
-      end
+      uri.scheme = if http.respond_to?(:use_ssl?) && http.use_ssl?
+                     "https"
+                   else
+                     "http"
+                   end
       uri.to_s
     end
 
     def set_oauth_header
-      self.req[:head] ||= {}
-      self.req[:head].merge!("Authorization" => @oauth_helper.header)
+      req[:head] ||= {}
+      req[:head].merge!("Authorization" => @oauth_helper.header)
     end
 
     def set_oauth_body

data/lib/oauth/client/helper.rb

@@ -14,9 +14,7 @@ module OAuth::Client
       @options[:signature_method] ||= "HMAC-SHA1"
     end
 
-    def options
-      @options
-    end
+    attr_reader :options
 
     def nonce
       options[:nonce] ||= generate_key
@@ -40,26 +38,25 @@ module OAuth::Client
         "oauth_session_handle"   => options[:oauth_session_handle]
       }
       allowed_empty_params = options[:allow_empty_params]
-      if allowed_empty_params != true && !allowed_empty_params.kind_of?(Array)
+      if allowed_empty_params != true && !allowed_empty_params.is_a?(Array)
         allowed_empty_params = allowed_empty_params == false ? [] : [allowed_empty_params]
       end
-      out.select! { |k,v| v.to_s != "" || allowed_empty_params == true || allowed_empty_params.include?(k) }
+      out.select! { |k, v| v.to_s != "" || allowed_empty_params == true || allowed_empty_params.include?(k) }
       out
     end
 
     def signature(extra_options = {})
-      OAuth::Signature.sign(@request, { :uri      => options[:request_uri],
-                                        :consumer => options[:consumer],
-                                        :token    => options[:token],
-                                        :unsigned_parameters => options[:unsigned_parameters]
-      }.merge(extra_options) )
+      OAuth::Signature.sign(@request, { uri: options[:request_uri],
+                                        consumer: options[:consumer],
+                                        token: options[:token],
+                                        unsigned_parameters: options[:unsigned_parameters] }.merge(extra_options))
     end
 
     def signature_base_string(extra_options = {})
-      OAuth::Signature.signature_base_string(@request, { :uri        => options[:request_uri],
-                                                         :consumer   => options[:consumer],
-                                                         :token      => options[:token],
-                                                         :parameters => oauth_parameters}.merge(extra_options) )
+      OAuth::Signature.signature_base_string(@request, { uri: options[:request_uri],
+                                                         consumer: options[:consumer],
+                                                         token: options[:token],
+                                                         parameters: oauth_parameters }.merge(extra_options))
     end
 
     def token_request?
@@ -67,7 +64,7 @@ module OAuth::Client
     end
 
     def hash_body
-      @options[:body_hash] = OAuth::Signature.body_hash(@request, :parameters => oauth_parameters)
+      @options[:body_hash] = OAuth::Signature.body_hash(@request, parameters: oauth_parameters)
     end
 
     def amend_user_agent_header(headers)
@@ -82,9 +79,9 @@ module OAuth::Client
 
     def header
       parameters = oauth_parameters
-      parameters.merge!("oauth_signature" => signature(options.merge(:parameters => parameters)))
+      parameters["oauth_signature"] = signature(options.merge(parameters: parameters))
 
-      header_params_str = parameters.sort.map { |k,v| "#{k}=\"#{escape(v)}\"" }.join(", ")
+      header_params_str = parameters.sort.map { |k, v| "#{k}=\"#{escape(v)}\"" }.join(", ")
 
       realm = "realm=\"#{options[:realm]}\", " if options[:realm]
       "OAuth #{realm}#{header_params_str}"

data/lib/oauth/client/net_http.rb

@@ -27,7 +27,7 @@ class Net::HTTPGenericRequest
     @oauth_helper = OAuth::Client::Helper.new(self, helper_options)
     @oauth_helper.amend_user_agent_header(self)
     @oauth_helper.hash_body if oauth_body_hash_required?
-    self.send("set_oauth_#{helper_options[:scheme]}")
+    send("set_oauth_#{helper_options[:scheme]}")
   end
 
   # Create a string suitable for signing for an HTTP request. This process involves parameter
@@ -52,34 +52,34 @@ class Net::HTTPGenericRequest
     @oauth_helper.signature_base_string
   end
 
-private
+  private
 
   def oauth_helper_options(http, consumer, token, options)
-    { :request_uri      => oauth_full_request_uri(http,options),
-      :consumer         => consumer,
-      :token            => token,
-      :scheme           => "header",
-      :signature_method => nil,
-      :nonce            => nil,
-      :timestamp        => nil }.merge(options)
+    { request_uri: oauth_full_request_uri(http, options),
+      consumer: consumer,
+      token: token,
+      scheme: "header",
+      signature_method: nil,
+      nonce: nil,
+      timestamp: nil }.merge(options)
   end
 
-  def oauth_full_request_uri(http,options)
-    uri = URI.parse(self.path)
+  def oauth_full_request_uri(http, options)
+    uri = URI.parse(path)
     uri.host = http.address
     uri.port = http.port
 
     if options[:request_endpoint] && options[:site]
-      is_https = options[:site].match(%r(^https://))
-      uri.host = options[:site].gsub(%r(^https?://), "")
+      is_https = options[:site].match(%r{^https://})
+      uri.host = options[:site].gsub(%r{^https?://}, "")
       uri.port ||= is_https ? 443 : 80
     end
 
-    if http.respond_to?(:use_ssl?) && http.use_ssl?
-      uri.scheme = "https"
-    else
-      uri.scheme = "http"
-    end
+    uri.scheme = if http.respond_to?(:use_ssl?) && http.use_ssl?
+                   "https"
+                 else
+                   "http"
+                 end
 
     uri.to_s
   end
@@ -100,19 +100,19 @@ private
   # base string.
 
   def set_oauth_body
-    self.set_form_data(@oauth_helper.stringify_keys(@oauth_helper.parameters_with_oauth))
-    params_with_sig = @oauth_helper.parameters.merge(:oauth_signature => @oauth_helper.signature)
-    self.set_form_data(@oauth_helper.stringify_keys(params_with_sig))
+    set_form_data(@oauth_helper.stringify_keys(@oauth_helper.parameters_with_oauth))
+    params_with_sig = @oauth_helper.parameters.merge(oauth_signature: @oauth_helper.signature)
+    set_form_data(@oauth_helper.stringify_keys(params_with_sig))
   end
 
   def set_oauth_query_string
-    oauth_params_str = @oauth_helper.oauth_parameters.map { |k,v| [escape(k), escape(v)] * "=" }.join("&")
+    oauth_params_str = @oauth_helper.oauth_parameters.map { |k, v| [escape(k), escape(v)].join("=") }.join("&")
     uri = URI.parse(path)
-    if uri.query.to_s == ""
-      uri.query = oauth_params_str
-    else
-      uri.query = uri.query + "&" + oauth_params_str
-    end
+    uri.query = if uri.query.to_s == ""
+                  oauth_params_str
+                else
+                  uri.query + "&" + oauth_params_str
+                end
 
     @path = uri.to_s
 

data/lib/oauth/consumer.rb

@@ -16,8 +16,8 @@ module OAuth
       end
     end
 
-    if !defined?(CA_FILE)
-      CA_FILES = %W(/etc/ssl/certs/ca-certificates.crt /etc/pki/tls/certs/ca-bundle.crt /usr/share/curl/curl-ca-bundle.crt)
+    unless defined?(CA_FILE)
+      CA_FILES = %w[/etc/ssl/certs/ca-certificates.crt /etc/pki/tls/certs/ca-bundle.crt /usr/share/curl/curl-ca-bundle.crt].freeze
       CA_FILES.each do |ca_file|
         if File.exist?(ca_file)
           CA_FILE = ca_file
@@ -29,15 +29,15 @@ module OAuth
 
     @@default_options = {
       # Signature method used by server. Defaults to HMAC-SHA1
-      :signature_method   => "HMAC-SHA1",
+      signature_method: "HMAC-SHA1",
 
       # default paths on site. These are the same as the defaults set up by the generators
-      :request_token_path => "/oauth/request_token",
-      :authenticate_path  => "/oauth/authenticate",
-      :authorize_path     => "/oauth/authorize",
-      :access_token_path  => "/oauth/access_token",
+      request_token_path: "/oauth/request_token",
+      authenticate_path: "/oauth/authenticate",
+      authorize_path: "/oauth/authorize",
+      access_token_path: "/oauth/access_token",
 
-      :proxy              => nil,
+      proxy: nil,
       # How do we send the oauth values to the server see
       # https://oauth.net/core/1.0/#consumer_req_param for more info
       #
@@ -46,10 +46,10 @@ module OAuth
       #   :header - via the Authorize header (Default) ( option 1. in spec)
       #   :body - url form encoded in body of POST request ( option 2. in spec)
       #   :query_string - via the query part of the url ( option 3. in spec)
-      :scheme        => :header,
+      scheme: :header,
 
       # Default http method used for OAuth Token Requests (defaults to :post)
-      :http_method   => :post,
+      http_method: :post,
 
       # Add a custom ca_file for consumer
       # :ca_file       => '/etc/certs.pem'
@@ -59,9 +59,9 @@ module OAuth
       # nil, false - no debug output
       # true - uses $stdout
       # some_value - uses some_value
-      :debug_output => nil,
+      debug_output: nil,
 
-      :oauth_version => "1.0"
+      oauth_version: "1.0"
     }
 
     attr_accessor :options, :key, :secret
@@ -94,9 +94,8 @@ module OAuth
       @secret = consumer_secret
 
       # ensure that keys are symbols
-      @options = @@default_options.merge(options.inject({}) do |opts, (key, value)|
+      @options = @@default_options.merge(options.each_with_object({}) do |(key, value), opts|
         opts[key.to_sym] = value
-        opts
       end)
     end
 
@@ -127,7 +126,7 @@ module OAuth
       if custom_uri
         @uri  = custom_uri
         @http = create_http # yike, oh well. less intrusive this way
-      else  # if no custom passed, we use existing, which, if unset, is set to site uri
+      else # if no custom passed, we use existing, which, if unset, is set to site uri
         @uri ||= URI.parse(site)
       end
     end
@@ -156,18 +155,18 @@ module OAuth
       # will be exchanged out of band
       request_options[:oauth_callback] ||= OAuth::OUT_OF_BAND unless request_options[:exclude_callback]
 
-      if block_given?
-        response = token_request(
-          http_method,
-          (request_token_url? ? request_token_url : request_token_path),
-          nil,
-          request_options,
-          *arguments,
-          &block
-        )
-      else
-        response = token_request(http_method, (request_token_url? ? request_token_url : request_token_path), nil, request_options, *arguments)
-      end
+      response = if block_given?
+                   token_request(
+                     http_method,
+                     (request_token_url? ? request_token_url : request_token_path),
+                     nil,
+                     request_options,
+                     *arguments,
+                     &block
+                   )
+                 else
+                   token_request(http_method, (request_token_url? ? request_token_url : request_token_path), nil, request_options, *arguments)
+                 end
       OAuth::RequestToken.from_hash(self, response)
     end
 
@@ -190,18 +189,18 @@ module OAuth
 
       # override the request with your own, this is useful for file uploads which Net::HTTP does not do
       req = create_signed_request(http_method, path, token, request_options, *arguments)
-      return nil if block_given? and yield(req) == :done
+      return nil if block_given? && (yield(req) == :done)
       rsp = http.request(req)
       # check for an error reported by the Problem Reporting extension
       # (https://wiki.oauth.net/ProblemReporting)
       # note: a 200 may actually be an error; check for an oauth_problem key to be sure
       if !(headers = rsp.to_hash["www-authenticate"]).nil? &&
-        (h = headers.select { |hdr| hdr =~ /^OAuth / }).any? &&
-        h.first =~ /oauth_problem/
+         (h = headers.select { |hdr| hdr =~ /^OAuth / }).any? &&
+         h.first =~ /oauth_problem/
 
         # puts "Header: #{h.first}"
 
-        # TODO doesn't handle broken responses from api.login.yahoo.com
+        # TODO: doesn't handle broken responses from api.login.yahoo.com
         # remove debug code when done
         params = OAuth::Helper.parse_header(h.first)
 
@@ -235,10 +234,9 @@ module OAuth
           # symbolize keys
           # TODO this could be considered unexpected behavior; symbols or not?
           # TODO this also drops subsequent values from multi-valued keys
-          CGI.parse(response.body).inject({}) do |h,(k,v)|
+          CGI.parse(response.body).each_with_object({}) do |(k, v), h|
             h[k.strip.to_sym] = v.first
             h[k.strip]        = v.first
-            h
           end
         end
       when (300..399)
@@ -250,11 +248,11 @@ module OAuth
         response.error! if uri.path == path && our_uri.host == uri.host
 
         if uri.path == path && our_uri.host != uri.host
-            options[:site] = "#{uri.scheme}://#{uri.host}"
-            @http = create_http
+          options[:site] = "#{uri.scheme}://#{uri.host}"
+          @http = create_http
         end
 
-        self.token_request(http_method, uri.path, token, request_options, arguments)
+        token_request(http_method, uri.path, token, request_options, arguments)
       when (400..499)
         raise OAuth::Unauthorized, response
       else
@@ -301,13 +299,13 @@ module OAuth
       @options[:access_token_path]
     end
 
-    # TODO this is ugly, rewrite
+    # TODO: this is ugly, rewrite
     def request_token_url
       @options[:request_token_url] || site + request_token_path
     end
 
     def request_token_url?
-      @options.has_key?(:request_token_url)
+      @options.key?(:request_token_url)
     end
 
     def authenticate_url
@@ -315,7 +313,7 @@ module OAuth
     end
 
     def authenticate_url?
-      @options.has_key?(:authenticate_url)
+      @options.key?(:authenticate_url)
     end
 
     def authorize_url
@@ -323,7 +321,7 @@ module OAuth
     end
 
     def authorize_url?
-      @options.has_key?(:authorize_url)
+      @options.key?(:authorize_url)
     end
 
     def access_token_url
@@ -331,7 +329,7 @@ module OAuth
     end
 
     def access_token_url?
-      @options.has_key?(:access_token_url)
+      @options.key?(:access_token_url)
     end
 
     def proxy
@@ -342,10 +340,7 @@ module OAuth
 
     # Instantiates the http object
     def create_http(_url = nil)
-
-      if !request_endpoint.nil?
-       _url = request_endpoint
-      end
+      _url = request_endpoint unless request_endpoint.nil?
 
       our_uri = if _url.nil? || _url[0] =~ /^\//
                   URI.parse(site)
@@ -372,10 +367,8 @@ module OAuth
       if @options[:no_verify]
         http_object.verify_mode = OpenSSL::SSL::VERIFY_NONE
       else
-        ca_file =  @options[:ca_file] || CA_FILE
-        if ca_file
-          http_object.ca_file = ca_file
-        end
+        ca_file = @options[:ca_file] || CA_FILE
+        http_object.ca_file = ca_file if ca_file
         http_object.verify_mode = OpenSSL::SSL::VERIFY_PEER
         http_object.verify_depth = 5
       end
@@ -394,9 +387,7 @@ module OAuth
     def create_http_request(http_method, path, *arguments)
       http_method = http_method.to_sym
 
-      if [:post, :put, :patch].include?(http_method)
-        data = arguments.shift
-      end
+      data = arguments.shift if %i[post put patch].include?(http_method)
 
       # if the base site contains a path, add it now
       # only add if the site host matches the current http object's host
@@ -408,22 +399,22 @@ module OAuth
 
       case http_method
       when :post
-        request = Net::HTTP::Post.new(path,headers)
+        request = Net::HTTP::Post.new(path, headers)
         request["Content-Length"] = "0" # Default to 0
       when :put
-        request = Net::HTTP::Put.new(path,headers)
+        request = Net::HTTP::Put.new(path, headers)
         request["Content-Length"] = "0" # Default to 0
       when :patch
-        request = Net::HTTP::Patch.new(path,headers)
+        request = Net::HTTP::Patch.new(path, headers)
         request["Content-Length"] = "0" # Default to 0
       when :get
-        request = Net::HTTP::Get.new(path,headers)
+        request = Net::HTTP::Get.new(path, headers)
       when :delete
-        request =  Net::HTTP::Delete.new(path,headers)
+        request = Net::HTTP::Delete.new(path, headers)
       when :head
-        request = Net::HTTP::Head.new(path,headers)
+        request = Net::HTTP::Head.new(path, headers)
       else
-        raise ArgumentError, "Don't know how to handle http_method: :#{http_method.to_s}"
+        raise ArgumentError, "Don't know how to handle http_method: :#{http_method}"
       end
 
       if data.is_a?(Hash)
@@ -448,13 +439,12 @@ module OAuth
       request
     end
 
-    def marshal_dump(*args)
-      {:key => @key, :secret => @secret, :options => @options}
+    def marshal_dump(*_args)
+      { key: @key, secret: @secret, options: @options }
     end
 
     def marshal_load(data)
       initialize(data[:key], data[:secret], data[:options])
     end
-
   end
 end

data/lib/oauth/helper.rb

@@ -24,11 +24,11 @@ module OAuth
 
     # Generate a random key of up to +size+ bytes. The value returned is Base64 encoded with non-word
     # characters removed.
-    def generate_key(size=32)
+    def generate_key(size = 32)
       Base64.encode64(OpenSSL::Random.random_bytes(size)).gsub(/\W/, "")
     end
 
-    alias_method :generate_nonce, :generate_key
+    alias generate_nonce generate_key
 
     def generate_timestamp #:nodoc:
       Time.now.to_i.to_s
@@ -51,13 +51,13 @@ module OAuth
             normalize_nested_query(values, k)
           else
             values.sort.collect do |v|
-              [escape(k),escape(v)] * "="
+              [escape(k), escape(v)].join("=")
             end
           end
         elsif values.is_a?(Hash)
           normalize_nested_query(values, k)
         else
-          [escape(k),escape(values)] * "="
+          [escape(k), escape(values)].join("=")
         end
       end * "&"
     end
@@ -76,7 +76,7 @@ module OAuth
           normalize_nested_query(v, prefix ? "#{prefix}[#{k}]" : k)
         end.flatten.sort
       else
-        [escape(prefix), escape(value)] * "="
+        [escape(prefix), escape(value)].join("=")
       end
     end
 
@@ -90,10 +90,10 @@ module OAuth
     #
     def parse_header(header)
       # decompose
-      params = header[6,header.length].split(/[,=&]/)
+      params = header[6, header.length].split(/[,=&]/)
 
       # odd number of arguments - must be a malformed header.
-      raise OAuth::Problem.new("Invalid authorization header") if params.size % 2 != 0
+      raise OAuth::Problem, "Invalid authorization header" if params.size.odd?
 
       params.map! do |v|
         # strip and unescape