oauth 0.5.7.pre.pre1 → 0.5.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a88cb9c5d6705a3a9af88054d4b67bd2fdf2686057bedb2022d1998f4e94d12f
-  data.tar.gz: d37b3d22e48c4258f1ce25f154a9c1a0ab4252fb7cb804e79808dd36c0ddcc5f
+  metadata.gz: 0c08e223971fca8aa5c3d76ed37e5576c61519b505498104d585436088ce6629
+  data.tar.gz: 0ccc2c1e6a5da2173358c5d9ffd7c69d7e54f91a3c67606d8ae523e7d81f36f3
 SHA512:
-  metadata.gz: 9c074fe3a9f43349f37deddbd1405f2d6eb53585d5188c81db30699b4d05b5ab546263d8e8471cad6742a861dcf23b14a94d54f3cede5f8891eeedd3a0e4b21c
-  data.tar.gz: 2ad01843b191714dcc05e9aaed252d5d1edc59e224c3d46e9e0b361c92403a97bf52288c4d84fd530e22b44a7d112aa36adb3f4d62fa3a4a1561681a5e353f93
+  metadata.gz: 69762d403a1e19c3f4f89278e46115b70e86661b8db64916b00cb8cb7297f7c25e2bf84031965856783874306f3b1b57642aa5145fbbf71dcde618ef6470dc16
+  data.tar.gz: 9c4cd4916e04a79f8e969089c817e2d2942705a13159124442587d96ea6e812c92fed6388adc723b12d0f638cad4f947a797b933992a87d14bf82e98cbd204ad

data/CHANGELOG.md

@@ -32,6 +32,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 * Fixed Unsafe String Comparison (#156, #209 by @pboling and @drosseau)
 * Fixed typos in Gemspec (#204, #203, #208 by @pboling)
 * Copyright Notice in LICENSE - added correct years (#217, #218 by @pboling)
+* Fixed request proxy Class constant reference scopes - was missing `::` in many places (#225, #226 by @pboling)
 
 ### Removed
 

data/README.md

@@ -1,5 +1,9 @@
 # Ruby OAuth
 
+**NOTE**
+
+This README, on branch `v0.5-maintenance`, targets 0.5.x series releases.  For later releases please see the `msater` branch README.
+
 ## Status
 
 | Project                    |  Ruby Oauth                |
@@ -41,7 +45,15 @@ Or install it yourself as:
 
 Targeted ruby compatibility is non-EOL versions of Ruby, currently 2.6, 2.7, and
 3.0. Ruby is limited to 2.0+ in the gemspec, and this may change while the gem is
-still at version 0.x.
+still at version 0.x.  The `master` branch currently targets 0.6.x releases.
+
+| Ruby OAuth Version   | Maintenance Branch | Officially Supported Rubies                 | Unofficially Supported Rubies |
+|--------------------- | ------------------ | ------------------------------------------- | ----------------------------- |
+| 0.7.x (hypothetical) | N/A                | 2.7, 3.0, 3.1                               | 2.6                           |
+| 0.6.x                | `master`           | 2.6, 2.7, 3.0                               | 2.3, 2.4, 2.5                 |
+| 0.5.x                | `v0.5-maintenance` | 2.0, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 3.0 |                               |
+
+NOTE: 0.5.7 is anticipated as last release of the 0.5.x series.
 
 ## Basics
 

data/lib/oauth/request_proxy/action_controller_request.rb

@@ -1,11 +1,12 @@
+# frozen_string_literal: true
+
 require "active_support"
 require "active_support/version"
 require "action_controller"
 require "uri"
 
-if
-  Gem::Version.new(ActiveSupport::VERSION::STRING) < Gem::Version.new("3")
-then # rails 2.x
+if Gem::Version.new(ActiveSupport::VERSION::STRING) < Gem::Version.new("3")
+  # rails 2.x
   require "action_controller/request"
   unless ActionController::Request::HTTP_METHODS.include?("patch")
     ActionController::Request::HTTP_METHODS << "patch"
@@ -13,9 +14,8 @@ then # rails 2.x
     ActionController::Request::HTTP_METHOD_LOOKUP["patch"] = :patch
   end
 
-elsif
-  Gem::Version.new(ActiveSupport::VERSION::STRING) < Gem::Version.new("4")
-then # rails 3.x
+elsif Gem::Version.new(ActiveSupport::VERSION::STRING) < Gem::Version.new("4")
+  # rails 3.x
   require "action_dispatch/http/request"
   unless ActionDispatch::Request::HTTP_METHODS.include?("patch")
     ActionDispatch::Request::HTTP_METHODS << "patch"
@@ -27,64 +27,63 @@ else # rails 4.x and later - already has patch
   require "action_dispatch/http/request"
 end
 
-module OAuth::RequestProxy
-  class ActionControllerRequest < OAuth::RequestProxy::Base
-    proxies(defined?(ActionDispatch::AbstractRequest) ? ActionDispatch::AbstractRequest : ActionDispatch::Request)
+module OAuth
+  module RequestProxy
+    class ActionControllerRequest < OAuth::RequestProxy::Base
+      proxies(defined?(::ActionDispatch::AbstractRequest) ? ::ActionDispatch::AbstractRequest : ::ActionDispatch::Request)
 
-    def method
-      request.method.to_s.upcase
-    end
+      def method
+        request.method.to_s.upcase
+      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.stringify_keys! if params.respond_to?(:stringify_keys!)
-        params.merge(options[:parameters] || {})
+      def parameters
+        if options[:clobber_request]
+          options[:parameters] || {}
+        else
+          params = request_params.merge(query_params).merge(header_params)
+          params.stringify_keys! if params.respond_to?(:stringify_keys!)
+          params.merge(options[:parameters] || {})
+        end
       end
-    end
 
-    # Override from OAuth::RequestProxy::Base to avoid roundtrip
-    # conversion to Hash or Array and thus preserve the original
-    # parameter names
-    def parameters_for_signature
-      params = []
-      params << options[:parameters].to_query if options[:parameters]
+      # Override from OAuth::RequestProxy::Base to avoid roundtrip
+      # conversion to Hash or Array and thus preserve the original
+      # parameter names
+      def parameters_for_signature
+        params = []
+        params << options[:parameters].to_query if options[:parameters]
 
-      unless options[:clobber_request]
-        params << header_params.to_query
-        params << request.query_string unless query_string_blank?
+        unless options[:clobber_request]
+          params << header_params.to_query
+          params << request.query_string unless query_string_blank?
 
-        if raw_post_signature?
-          params << request.raw_post
+          params << request.raw_post if raw_post_signature?
         end
-      end
 
-      params.
-        join("&").split("&").
-        reject { |s| s.match(/\A\s*\z/) }.
-        map { |p| p.split("=").map{|esc| CGI.unescape(esc)} }.
-        reject { |kv| kv[0] == "oauth_signature"}
-    end
+        params.
+          join("&").split("&").
+          reject { |s| s.match(/\A\s*\z/) }.
+          map { |p| p.split("=").map { |esc| CGI.unescape(esc) } }.
+          reject { |kv| kv[0] == "oauth_signature" }
+      end
 
-    def raw_post_signature?
-      (request.post? || request.put?) && request.content_type.to_s.downcase.start_with?("application/x-www-form-urlencoded")
-    end
+      def raw_post_signature?
+        (request.post? || request.put?) && request.content_type.to_s.downcase.start_with?("application/x-www-form-urlencoded")
+      end
 
-  protected
+      protected
 
-    def query_params
-      request.query_parameters
-    end
+      def query_params
+        request.query_parameters
+      end
 
-    def request_params
-      request.request_parameters
+      def request_params
+        request.request_parameters
+      end
     end
-
   end
 end

data/lib/oauth/request_proxy/action_dispatch_request.rb

@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+
 require "oauth/request_proxy/rack_request"
 
-module OAuth::RequestProxy
-  class ActionDispatchRequest < OAuth::RequestProxy::RackRequest
-    proxies ActionDispatch::Request
+module OAuth
+  module RequestProxy
+    class ActionDispatchRequest < OAuth::RequestProxy::RackRequest
+      proxies ::ActionDispatch::Request
+    end
   end
 end

data/lib/oauth/request_proxy/base.rb

@@ -1,178 +1,182 @@
+# frozen_string_literal: true
+
 require "oauth/request_proxy"
 require "oauth/helper"
 
-module OAuth::RequestProxy
-  class Base
-    include OAuth::Helper
+module OAuth
+  module RequestProxy
+    class Base
+      include OAuth::Helper
 
-    def self.proxies(klass)
-      OAuth::RequestProxy.available_proxies[klass] = self
-    end
+      def self.proxies(klass)
+        OAuth::RequestProxy.available_proxies[klass] = self
+      end
 
-    attr_accessor :request, :options, :unsigned_parameters
+      attr_accessor :request, :options, :unsigned_parameters
 
-    def initialize(request, options = {})
-      @request = request
-      @unsigned_parameters = (options[:unsigned_parameters] || []).map {|param| param.to_s}
-      @options = options
-    end
+      def initialize(request, options = {})
+        @request = request
+        @unsigned_parameters = (options[:unsigned_parameters] || []).map(&:to_s)
+        @options = options
+      end
 
-    ## OAuth parameters
+      ## OAuth parameters
 
-    def oauth_callback
-      parameters["oauth_callback"]
-    end
+      def oauth_callback
+        parameters["oauth_callback"]
+      end
 
-    def oauth_consumer_key
-      parameters["oauth_consumer_key"]
-    end
+      def oauth_consumer_key
+        parameters["oauth_consumer_key"]
+      end
 
-    def oauth_nonce
-      parameters["oauth_nonce"]
-    end
+      def oauth_nonce
+        parameters["oauth_nonce"]
+      end
 
-    def oauth_signature
-      # TODO can this be nil?
-      [parameters["oauth_signature"]].flatten.first || ""
-    end
+      def oauth_signature
+        # TODO: can this be nil?
+        [parameters["oauth_signature"]].flatten.first || ""
+      end
 
-    def oauth_signature_method
-      case parameters["oauth_signature_method"]
-      when Array
-        parameters["oauth_signature_method"].first
-      else
-        parameters["oauth_signature_method"]
+      def oauth_signature_method
+        case parameters["oauth_signature_method"]
+        when Array
+          parameters["oauth_signature_method"].first
+        else
+          parameters["oauth_signature_method"]
+        end
       end
-    end
 
-    def oauth_timestamp
-      parameters["oauth_timestamp"]
-    end
+      def oauth_timestamp
+        parameters["oauth_timestamp"]
+      end
 
-    def oauth_token
-      parameters["oauth_token"]
-    end
+      def oauth_token
+        parameters["oauth_token"]
+      end
 
-    def oauth_verifier
-      parameters["oauth_verifier"]
-    end
+      def oauth_verifier
+        parameters["oauth_verifier"]
+      end
 
-    def oauth_version
-      parameters["oauth_version"]
-    end
+      def oauth_version
+        parameters["oauth_version"]
+      end
 
-    # TODO deprecate these
-    alias_method :consumer_key,     :oauth_consumer_key
-    alias_method :token,            :oauth_token
-    alias_method :nonce,            :oauth_nonce
-    alias_method :timestamp,        :oauth_timestamp
-    alias_method :signature,        :oauth_signature
-    alias_method :signature_method, :oauth_signature_method
+      # TODO: deprecate these
+      alias consumer_key oauth_consumer_key
+      alias token oauth_token
+      alias nonce oauth_nonce
+      alias timestamp oauth_timestamp
+      alias signature oauth_signature
+      alias signature_method oauth_signature_method
 
-    ## Parameter accessors
+      ## Parameter accessors
 
-    def parameters
-      raise NotImplementedError, "Must be implemented by subclasses"
-    end
+      def parameters
+        raise NotImplementedError, "Must be implemented by subclasses"
+      end
 
-    def parameters_for_signature
-      parameters.select { |k,v| not signature_and_unsigned_parameters.include?(k) }
-    end
+      def parameters_for_signature
+        parameters.select { |k, _v| !signature_and_unsigned_parameters.include?(k) }
+      end
 
-    def oauth_parameters
-      parameters.select { |k,v| OAuth::PARAMETERS.include?(k) }.reject { |k,v| v == "" }
-    end
+      def oauth_parameters
+        parameters.select { |k, _v| OAuth::PARAMETERS.include?(k) }.select { |_k, v| v != "" }
+      end
 
-    def non_oauth_parameters
-      parameters.reject { |k,v| OAuth::PARAMETERS.include?(k) }
-    end
+      def non_oauth_parameters
+        parameters.select { |k, _v| !OAuth::PARAMETERS.include?(k) }
+      end
 
-    def signature_and_unsigned_parameters
-      unsigned_parameters+["oauth_signature"]
-    end
+      def signature_and_unsigned_parameters
+        unsigned_parameters + ["oauth_signature"]
+      end
 
-    # See 9.1.2 in specs
-    def normalized_uri
-      u = URI.parse(uri)
-      "#{u.scheme.downcase}://#{u.host.downcase}#{(u.scheme.downcase == 'http' && u.port != 80) || (u.scheme.downcase == 'https' && u.port != 443) ? ":#{u.port}" : ""}#{(u.path && u.path != '') ? u.path : '/'}"
-    end
+      # See 9.1.2 in specs
+      def normalized_uri
+        u = URI.parse(uri)
+        "#{u.scheme.downcase}://#{u.host.downcase}#{(u.scheme.casecmp("http").zero? && u.port != 80) || (u.scheme.casecmp("https").zero? && u.port != 443) ? ":#{u.port}" : ""}#{u.path && u.path != "" ? u.path : "/"}"
+      end
 
-    # See 9.1.1. in specs Normalize Request Parameters
-    def normalized_parameters
-      normalize(parameters_for_signature)
-    end
+      # See 9.1.1. in specs Normalize Request Parameters
+      def normalized_parameters
+        normalize(parameters_for_signature)
+      end
 
-    def sign(options = {})
-      OAuth::Signature.sign(self, options)
-    end
+      def sign(options = {})
+        OAuth::Signature.sign(self, options)
+      end
 
-    def sign!(options = {})
-      parameters["oauth_signature"] = sign(options)
-      @signed = true
-      signature
-    end
+      def sign!(options = {})
+        parameters["oauth_signature"] = sign(options)
+        @signed = true
+        signature
+      end
 
-    # See 9.1 in specs
-    def signature_base_string
-      base = [method, normalized_uri, normalized_parameters]
-      base.map { |v| escape(v) }.join("&")
-    end
+      # See 9.1 in specs
+      def signature_base_string
+        base = [method, normalized_uri, normalized_parameters]
+        base.map { |v| escape(v) }.join("&")
+      end
 
-    # Has this request been signed yet?
-    def signed?
-      @signed
-    end
+      # Has this request been signed yet?
+      def signed?
+        @signed
+      end
+
+      # URI, including OAuth parameters
+      def signed_uri(with_oauth = true)
+        if signed?
+          params = if with_oauth
+                     parameters
+                   else
+                     non_oauth_parameters
+                   end
 
-    # URI, including OAuth parameters
-    def signed_uri(with_oauth = true)
-      if signed?
-        if with_oauth
-          params = parameters
+          [uri, normalize(params)].join("?")
         else
-          params = non_oauth_parameters
+          warn "This request has not yet been signed!"
         end
-
-        [uri, normalize(params)] * "?"
-      else
-        STDERR.puts "This request has not yet been signed!"
       end
-    end
 
-    # Authorization header for OAuth
-    def oauth_header(options = {})
-      header_params_str = oauth_parameters.map { |k,v| "#{k}=\"#{escape(v)}\"" }.join(", ")
+      # Authorization header for OAuth
+      def oauth_header(options = {})
+        header_params_str = oauth_parameters.map { |k, v| "#{k}=\"#{escape(v)}\"" }.join(", ")
 
-      realm = "realm=\"#{options[:realm]}\", " if options[:realm]
-      "OAuth #{realm}#{header_params_str}"
-    end
+        realm = "realm=\"#{options[:realm]}\", " if options[:realm]
+        "OAuth #{realm}#{header_params_str}"
+      end
 
-    def query_string_blank?
-      if uri = request.env["REQUEST_URI"]
-        uri.split("?", 2)[1].nil?
-      else
-        request.query_string.match(/\A\s*\z/)
+      def query_string_blank?
+        if (uri = request.env["REQUEST_URI"])
+          uri.split("?", 2)[1].nil?
+        else
+          request.query_string.match(/\A\s*\z/)
+        end
       end
-    end
 
-  protected
+      protected
 
-    def header_params
-      %w( X-HTTP_AUTHORIZATION Authorization HTTP_AUTHORIZATION ).each do |header|
-        next unless request.env.include?(header)
+      def header_params
+        %w[X-HTTP_AUTHORIZATION Authorization HTTP_AUTHORIZATION].each do |header|
+          next unless request.env.include?(header)
 
-        header = request.env[header]
-        next unless header[0,6] == "OAuth "
+          header = request.env[header]
+          next unless header[0, 6] == "OAuth "
 
-        # parse the header into a Hash
-        oauth_params = OAuth::Helper.parse_header(header)
+          # parse the header into a Hash
+          oauth_params = OAuth::Helper.parse_header(header)
 
-        # remove non-OAuth parameters
-        oauth_params.reject! { |k,v| k !~ /^oauth_/ }
+          # remove non-OAuth parameters
+          oauth_params.select! { |k, _v| k =~ /^oauth_/ }
 
-        return oauth_params
-      end
+          return oauth_params
+        end
 
-      return {}
+        {}
+      end
     end
   end
 end

data/lib/oauth/request_proxy/curb_request.rb

@@ -1,55 +1,61 @@
-  require "oauth/request_proxy/base"
+# frozen_string_literal: true
+
+require "oauth/request_proxy/base"
 require "curb"
 require "uri"
 require "cgi"
 
-module OAuth::RequestProxy::Curl
-  class Easy < OAuth::RequestProxy::Base
-    # Proxy for signing Curl::Easy requests
-    # Usage example:
-    # oauth_params = {:consumer => oauth_consumer, :token => access_token}
-    # req = Curl::Easy.new(uri)
-    # oauth_helper = OAuth::Client::Helper.new(req, oauth_params.merge(:request_uri => uri))
-    # req.headers.merge!({"Authorization" => oauth_helper.header})
-    # req.http_get
-    # response = req.body_str
-    proxies ::Curl::Easy
-
-    def method
-      nil
-    end
+module OAuth
+  module RequestProxy
+    module Curl
+      class Easy < OAuth::RequestProxy::Base
+        # Proxy for signing Curl::Easy requests
+        # Usage example:
+        # oauth_params = {:consumer => oauth_consumer, :token => access_token}
+        # req = Curl::Easy.new(uri)
+        # oauth_helper = OAuth::Client::Helper.new(req, oauth_params.merge(:request_uri => uri))
+        # req.headers.merge!({"Authorization" => oauth_helper.header})
+        # req.http_get
+        # response = req.body_str
+        proxies ::Curl::Easy
+
+        def method
+          nil
+        end
 
-    def uri
-      options[:uri].to_s
-    end
+        def uri
+          options[:uri].to_s
+        end
 
-    def parameters
-      if options[:clobber_request]
-        options[:parameters]
-      else
-        post_parameters.merge(query_parameters).merge(options[:parameters] || {})
-      end
-    end
+        def parameters
+          if options[:clobber_request]
+            options[:parameters]
+          else
+            post_parameters.merge(query_parameters).merge(options[:parameters] || {})
+          end
+        end
 
-    private
+        private
 
-    def query_parameters
-      query = URI.parse(request.url).query
-      return(query ? CGI.parse(query) : {})
-    end
+        def query_parameters
+          query = URI.parse(request.url).query
+          (query ? CGI.parse(query) : {})
+        end
 
-    def post_parameters
-      post_body = {}
+        def post_parameters
+          post_body = {}
 
-      # Post params are only used if posting form data
-      if (request.headers["Content-Type"] && request.headers["Content-Type"].to_s.downcase.start_with?("application/x-www-form-urlencoded"))
+          # Post params are only used if posting form data
+          if request.headers["Content-Type"] && request.headers["Content-Type"].to_s.downcase.start_with?("application/x-www-form-urlencoded")
 
-        request.post_body.split("&").each do |str|
-          param = str.split("=")
-          post_body[param[0]] = param[1]
+            request.post_body.split("&").each do |str|
+              param = str.split("=")
+              post_body[param[0]] = param[1]
+            end
+          end
+          post_body
         end
       end
-      post_body
     end
   end
 end

data/lib/oauth/request_proxy/em_http_request.rb

@@ -1,72 +1,76 @@
+# frozen_string_literal: true
+
 require "oauth/request_proxy/base"
 # em-http also uses adddressable so there is no need to require uri.
 require "em-http"
 require "cgi"
 
-module OAuth::RequestProxy::EventMachine
-  class HttpRequest < OAuth::RequestProxy::Base
-
-    # A Proxy for use when you need to sign EventMachine::HttpClient instances.
-    # It needs to be called once the client is construct but before data is sent.
-    # Also see oauth/client/em-http
-    proxies ::EventMachine::HttpClient
-
-    # Request in this con
+module OAuth
+  module RequestProxy
+    module EventMachine
+      class HttpRequest < OAuth::RequestProxy::Base
+        # A Proxy for use when you need to sign EventMachine::HttpClient instances.
+        # It needs to be called once the client is construct but before data is sent.
+        # Also see oauth/client/em-http
+        proxies ::EventMachine::HttpClient
 
-    def method
-      request.req[:method]
-    end
+        # Request in this con
 
-    def uri
-      request.conn.normalize.to_s
-    end
+        def method
+          request.req[:method]
+        end
 
-    def parameters
-      if options[:clobber_request]
-        options[:parameters]
-      else
-        all_parameters
-      end
-    end
+        def uri
+          request.conn.normalize.to_s
+        end
 
-    protected
+        def parameters
+          if options[:clobber_request]
+            options[:parameters]
+          else
+            all_parameters
+          end
+        end
 
-    def all_parameters
-      merged_parameters({}, post_parameters, query_parameters, options[:parameters])
-    end
+        protected
 
-    def query_parameters
-      quer = request.req[:query]
-      hash_quer = if quer.respond_to?(:merge)
-                    quer
-                  else
-                    CGI.parse(quer.to_s)
-                  end
-      CGI.parse(request.conn.query.to_s).merge(hash_quer)
-    end
+        def all_parameters
+          merged_parameters({}, post_parameters, query_parameters, options[:parameters])
+        end
 
-    def post_parameters
-      headers = request.req[:head] || {}
-      form_encoded = headers["Content-Type"].to_s.downcase.start_with?("application/x-www-form-urlencoded")
-      if ["POST", "PUT"].include?(method) && form_encoded
-        CGI.parse(request.normalize_body(request.req[:body]).to_s)
-      else
-        {}
-      end
-    end
+        def query_parameters
+          quer = request.req[:query]
+          hash_quer = if quer.respond_to?(:merge)
+                        quer
+                      else
+                        CGI.parse(quer.to_s)
+                      end
+          CGI.parse(request.conn.query.to_s).merge(hash_quer)
+        end
 
-    def merged_parameters(params, *extra_params)
-      extra_params.compact.each do |params_pairs|
-        params_pairs.each_pair do |key, value|
-          if params.has_key?(key)
-            params[key.to_s] += value
+        def post_parameters
+          headers = request.req[:head] || {}
+          form_encoded = headers["Content-Type"].to_s.downcase.start_with?("application/x-www-form-urlencoded")
+          if %w[POST PUT].include?(method) && form_encoded
+            CGI.parse(request.normalize_body(request.req[:body]).to_s)
           else
-            params[key.to_s] = [value].flatten
+            {}
           end
         end
+
+        def merged_parameters(params, *extra_params)
+          extra_params.compact.each do |params_pairs|
+            params_pairs.each_pair do |key, value|
+              if params.key?(key)
+                params[key.to_s] += value
+              else
+                params[key.to_s] = [value].flatten
+              end
+            end
+          end
+          params
+        end
       end
-      params
     end
-
   end
 end

data/lib/oauth/request_proxy/jabber_request.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 require "xmpp4r"
 require "oauth/request_proxy/base"
 
 module OAuth
   module RequestProxy
     class JabberRequest < OAuth::RequestProxy::Base
-      proxies Jabber::Iq
-      proxies Jabber::Presence
-      proxies Jabber::Message
+      proxies ::Jabber::Iq
+      proxies ::Jabber::Presence
+      proxies ::Jabber::Message
 
       def parameters
         return @params if @params
@@ -16,9 +18,10 @@ module OAuth
         oauth = @request.get_elements("//oauth").first
         return @params unless oauth
 
-        %w( oauth_token oauth_consumer_key oauth_signature_method oauth_signature
-            oauth_timestamp oauth_nonce oauth_version ).each do |param|
-          next unless element = oauth.first_element(param)
+        %w[ oauth_token oauth_consumer_key oauth_signature_method oauth_signature
+            oauth_timestamp oauth_nonce oauth_version ].each do |param|
+          next unless (element = oauth.first_element(param))
+
           @params[param] = element.text
         end
 

data/lib/oauth/request_proxy/mock_request.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "oauth/request_proxy/base"
 
 module OAuth
@@ -18,7 +20,7 @@ module OAuth
     #     :consumer_secret => oauth_consumer_secret,
     #     :token_secret    => oauth_token_secret,
     class MockRequest < OAuth::RequestProxy::Base
-      proxies Hash
+      proxies ::Hash
 
       def parameters
         @request["parameters"]

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.has_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/version.rb

@@ -1,3 +1,3 @@
 module OAuth
-  VERSION = "0.5.7-pre1"
+  VERSION = "0.5.7"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: oauth
 version: !ruby/object:Gem::Version
-  version: 0.5.7.pre.pre1
+  version: 0.5.7
 platform: ruby
 authors:
 - Pelle Braendgaard
@@ -16,7 +16,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-01 00:00:00.000000000 Z
+date: 2021-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -421,9 +421,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.0.3.1
 signing_key: