rufus-verbs 0.10 → 1.0.0

data/lib/rufus/verbs/digest.rb

@@ -1,6 +1,5 @@
-#
 #--
-# Copyright (c) 2008, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2008-2010, John Mettraux, jmettraux@gmail.com
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -8,10 +7,10 @@
 # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 # copies of the Software, and to permit persons to whom the Software is
 # furnished to do so, subject to the following conditions:
-# 
+#
 # The above copyright notice and this permission notice shall be included in
 # all copies or substantial portions of the Software.
-# 
+#
 # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
@@ -20,17 +19,9 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 #
-# (MIT license)
+# Made in Japan.
 #++
-#
 
-#
-# John Mettraux
-#
-# Made in Japan
-#
-# 2008/01/21
-#
 
 require 'digest/md5'
 
@@ -38,223 +29,223 @@ require 'digest/md5'
 module Rufus
 module Verbs
 
+  #
+  # Specified by http://www.ietf.org/rfc/rfc2617.txt
+  # Inspired by http://segment7.net/projects/ruby/snippets/digest_auth.rb
+  #
+  # The EndPoint classes mixes this in to support digest authentication.
+  #
+  module DigestAuthMixin
+
     #
-    # Specified by http://www.ietf.org/rfc/rfc2617.txt
-    # Inspired by http://segment7.net/projects/ruby/snippets/digest_auth.rb
-    #
-    # The EndPoint classes mixes this in to support digest authentication.
+    # Makes sure digest_auth is on
     #
-    module DigestAuthMixin
+    def digest_auth (req, opts)
 
-        #
-        # Makes sure digest_auth is on
-        #
-        def digest_auth (req, opts)
+      #return if no_digest_auth
+        # already done in add_authentication()
 
-            #return if no_digest_auth
-                # already done in add_authentication()
+      @cnonce ||= generate_cnonce
+      @nonce_count ||= 0
 
-            @cnonce ||= generate_cnonce
-            @nonce_count ||= 0
+      mention_digest_auth(req, opts) \
+        and return
 
-            mention_digest_auth(req, opts) \
-                and return
+      mention_digest_auth(req, opts) \
+        if request_challenge(req, opts)
+    end
 
-            mention_digest_auth(req, opts) \
-                if request_challenge(req, opts)
-        end
+    #
+    # Sets the 'Authorization' header with the appropriate info.
+    #
+    def mention_digest_auth (req, opts)
 
-        #
-        # Sets the 'Authorization' header with the appropriate info.
-        #
-        def mention_digest_auth (req, opts)
+      return false unless @challenge
 
-            return false unless @challenge
+      req['Authorization'] = generate_header req, opts
 
-            req['Authorization'] = generate_header req, opts
+      true
+    end
 
-            true
-        end
+    #
+    # Interprets the information in the response's 'Authorization-Info'
+    # header.
+    #
+    def check_authentication_info (res, opts)
 
-        #
-        # Interprets the information in the response's 'Authorization-Info'
-        # header.
-        #
-        def check_authentication_info (res, opts)
+      return if no_digest_auth
+        # not using digest authentication
 
-            return if no_digest_auth
-                # not using digest authentication
+      return unless @challenge
+        # not yet authenticated
 
-            return unless @challenge
-                # not yet authenticated
+      authinfo = AuthInfo.new res
+      @challenge.nonce = authinfo.nextnonce
+    end
 
-            authinfo = AuthInfo.new res
-            @challenge.nonce = authinfo.nextnonce
-        end
+    protected
 
-        protected
+    #
+    # Returns true if :digest_authentication is set at endpoint
+    # or request level.
+    #
+    def no_digest_auth
 
-            #
-            # Returns true if :digest_authentication is set at endpoint
-            # or request level.
-            #
-            def no_digest_auth
+      (not o(opts, :digest_authentication))
+    end
 
-                (not o(opts, :digest_authentication))
-            end
+    #
+    # To be enhanced.
+    #
+    # (For example http://www.intertwingly.net/blog/1585.html)
+    #
+    def generate_cnonce
 
-            #
-            # To be enhanced.
-            #
-            # (For example http://www.intertwingly.net/blog/1585.html)
-            #
-            def generate_cnonce
+      Digest::MD5.hexdigest("%x" % (Time.now.to_i + rand(65535)))
+    end
 
-                Digest::MD5.hexdigest("%x" % (Time.now.to_i + rand(65535)))
-            end
+    def request_challenge (req, opts)
 
-            def request_challenge (req, opts)
+      op = opts.dup
 
-                op = opts.dup
+      op[:digest_authentication] = false
+        # preventing an infinite loop
 
-                op[:digest_authentication] = false
-                    # preventing an infinite loop
+      method = req.class.const_get(:METHOD).downcase.to_sym
+      #method = :get
 
-                method = req.class.const_get(:METHOD).downcase.to_sym
-                #method = :get
+      res = request(method, op)
 
-                res = request(method, op)
+      return false if res.code.to_i != 401
 
-                return false if res.code.to_i != 401
+      @challenge = Challenge.new res
 
-                @challenge = Challenge.new res
+      true
+    end
 
-                true
-            end
+    #
+    # Generates an MD5 digest of the arguments (joined by ":").
+    #
+    def h (*args)
 
-            #
-            # Generates an MD5 digest of the arguments (joined by ":").
-            #
-            def h (*args)
+      Digest::MD5.hexdigest(args.join(":"))
+    end
 
-                Digest::MD5.hexdigest(args.join(":"))
-            end
+    #
+    # Generates the Authentication header that will be returned
+    # to the server.
+    #
+    def generate_header (req, opts)
+
+      @nonce_count += 1
+
+      user, pass = o(opts, :digest_authentication)
+      realm = @challenge.realm || ""
+      method = req.class.const_get(:METHOD)
+      path = opts[:path]
+
+      a1 = if @challenge.algorithm == 'MD5-sess'
+        h(h(user, realm, pass), @challenge.nonce, @cnonce)
+      else
+        h(user, realm, pass)
+      end
+
+      a2, qop = if @challenge.qop.include?("auth-int")
+        [ h(method, path, h(req.body)), "auth-int" ]
+      else
+        [ h(method, path), "auth" ]
+      end
+
+      nc = ('%08x' % @nonce_count)
+
+      digest = h(
+        #a1, @challenge.nonce, nc, @cnonce, @challenge.qop, a2)
+        a1, @challenge.nonce, nc, @cnonce, "auth", a2)
+
+      header = ""
+      header << "Digest username=\"#{user}\", "
+      header << "realm=\"#{realm}\", "
+      header << "qop=\"#{qop}\", "
+      header << "uri=\"#{path}\", "
+      header << "nonce=\"#{@challenge.nonce}\", "
+      #header << "nc=##{nc}, "
+      header << "nc=#{nc}, "
+      header << "cnonce=\"#{@cnonce}\", "
+      header << "algorithm=\"#{@challenge.algorithm}\", "
+      #header << "algorithm=\"MD5-sess\", "
+      header << "response=\"#{digest}\", "
+      header << "opaque=\"#{@challenge.opaque}\""
+
+      header
+    end
 
-            #
-            # Generates the Authentication header that will be returned
-            # to the server.
-            #
-            def generate_header (req, opts)
+    #
+    # A common parent class for Challenge and AuthInfo.
+    # Their header parsing code is here.
+    #
+    class ServerReply
 
-                @nonce_count += 1
+      def initialize (res)
 
-                user, pass = o(opts, :digest_authentication)
-                realm = @challenge.realm || ""
-                method = req.class.const_get(:METHOD)
-                path = opts[:path]
+        s = res[header_name]
+        return nil unless s
 
-                a1 = if @challenge.algorithm == 'MD5-sess'
-                    h(h(user, realm, pass), @challenge.nonce, @cnonce)
-                else
-                    h(user, realm, pass)
-                end
+        s = s[7..-1] if s[0, 6] == "Digest"
 
-                a2, qop = if @challenge.qop.include?("auth-int")
-                    [ h(method, path, h(req.body)), "auth-int" ]
-                else
-                    [ h(method, path), "auth" ]
-                end
+        s = s.split ","
 
-                nc = ('%08x' % @nonce_count)
+        s.each do |e|
 
-                digest = h(
-                    #a1, @challenge.nonce, nc, @cnonce, @challenge.qop, a2)
-                    a1, @challenge.nonce, nc, @cnonce, "auth", a2)
+          k, v = parse_entry e
 
-                header = ""
-                header << "Digest username=\"#{user}\", "
-                header << "realm=\"#{realm}\", "
-                header << "qop=\"#{qop}\", "
-                header << "uri=\"#{path}\", "
-                header << "nonce=\"#{@challenge.nonce}\", "
-                #header << "nc=##{nc}, "
-                header << "nc=#{nc}, "
-                header << "cnonce=\"#{@cnonce}\", "
-                header << "algorithm=\"#{@challenge.algorithm}\", "
-                #header << "algorithm=\"MD5-sess\", "
-                header << "response=\"#{digest}\", "
-                header << "opaque=\"#{@challenge.opaque}\""
+          if k == 'stale'
+            @stale = (v.downcase == 'true')
+          elsif k == 'nc'
+            @nc = v.to_i
+          elsif k == 'qop'
+            @qop = v.split ","
+          else
+            instance_variable_set "@#{k}".to_sym, v
+          end
+        end
+      end
 
-                header
-            end
+      protected
 
-            #
-            # A common parent class for Challenge and AuthInfo.
-            # Their header parsing code is here.
-            #
-            class ServerReply
+      def parse_entry (e)
 
-                def initialize (res)
+        k, v = e.split '=', 2
+        v = v[1..-2] if v[0, 1] == '"'
+        [ k.strip, v.strip ]
+      end
+    end
 
-                    s = res[header_name]
-                    return nil unless s
+    #
+    # Used when parsing a 'www-authenticate' header challenge.
+    #
+    class Challenge < ServerReply
 
-                    s = s[7..-1] if s[0, 6] == "Digest"
+      attr_accessor \
+        :opaque, :algorithm, :qop, :stale, :nonce, :realm, :charset
 
-                    s = s.split ","
+      def header_name
+        'www-authenticate'
+      end
+    end
 
-                    s.each do |e|
+    #
+    # Used when parsing a 'authentication-info' header info.
+    #
+    class AuthInfo < ServerReply
 
-                        k, v = parse_entry e
+      attr_accessor \
+        :cnonce, :rspauth, :nextnonce, :qop, :nc
 
-                        if k == 'stale'
-                            @stale = (v.downcase == 'true') 
-                        elsif k == 'nc'
-                            @nc = v.to_i
-                        elsif k == 'qop'
-                            @qop = v.split ","
-                        else
-                            instance_variable_set "@#{k}".to_sym, v
-                        end
-                    end
-                end
-
-                protected
-
-                    def parse_entry (e)
-
-                        k, v = e.split "=", 2
-                        v = v[1..-2] if v[0, 1] == '"'
-                        [ k.strip, v.strip ]
-                    end
-            end
-
-            #
-            # Used when parsing a 'www-authenticate' header challenge.
-            #
-            class Challenge < ServerReply
-
-                attr_accessor \
-                    :opaque, :algorithm, :qop, :stale, :nonce, :realm, :charset
-
-                def header_name
-                    'www-authenticate'
-                end
-            end
-
-            #
-            # Used when parsing a 'authentication-info' header info.
-            #
-            class AuthInfo < ServerReply
-
-                attr_accessor \
-                    :cnonce, :rspauth, :nextnonce, :qop, :nc
-
-                def header_name
-                    'authentication-info'
-                end
-            end
+      def header_name
+        'authentication-info'
+      end
     end
+  end
 
 end
 end

data/lib/rufus/verbs/endpoint.rb

@@ -1,6 +1,5 @@
-#
 #--
-# Copyright (c) 2008, John Mettraux, jmettraux@gmail.com
+# Copyright (c) 2008-2010, John Mettraux, jmettraux@gmail.com
 #
 # Permission is hereby granted, free of charge, to any person obtaining a copy
 # of this software and associated documentation files (the "Software"), to deal
@@ -20,18 +19,11 @@
 # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 # THE SOFTWARE.
 #
-# (MIT license)
+# Made in Japan.
 #++
-#
 
-#
-# John Mettraux
-#
-# Made in Japan
-#
-# 2008/01/11
-#
 
+require 'cgi'
 require 'uri'
 require 'yaml' # for StringIO (at least for now)
 require 'net/http'
@@ -46,602 +38,604 @@ require 'rufus/verbs/verbose'
 module Rufus
 module Verbs
 
-    USER_AGENT = "Ruby rufus-verbs #{VERSION}"
+  USER_AGENT = "Ruby rufus-verbs #{VERSION}"
+
+  #
+  # An EndPoint can be used to share common options among a set of
+  # requests.
+  #
+  #   ep = EndPoint.new(
+  #     :host => "restful.server",
+  #     :port => 7080,
+  #     :resource => "inventory/tools")
+  #
+  #   res = ep.get :id => 1
+  #     # still a silver bullet ?
+  #
+  #   res = ep.get :id => 0
+  #     # where did the hammer go ?
+  #
+  # When a request gets prepared, the option values will be looked up
+  # in (1) its local (request) options, then (2) in the EndPoint options.
+  #
+  class EndPoint
+
+    include CookieMixin
+    include DigestAuthMixin
+    include VerboseMixin
 
     #
-    # An EndPoint can be used to share common options among a set of
-    # requests.
+    # The endpoint initialization opts (Hash instance)
+    #
+    attr_reader :opts
+
+    def initialize (opts)
+
+      @opts = opts
+
+      compute_target @opts
+
+      @opts[:http_basic_authentication] =
+        opts[:http_basic_authentication] || opts[:hba]
+
+      @opts[:user_agent] ||= USER_AGENT
+
+      @opts[:proxy] ||= ENV['HTTP_PROXY']
+
+      prepare_cookie_jar
+    end
+
+    def get (*args)
+
+      request :get, args
+    end
+
+    def post (*args, &block)
+
+      request :post, args, &block
+    end
+
+    def put (*args, &block)
+
+      request :put, args, &block
+    end
+
+    def delete (*args)
+
+      request :delete, args
+    end
+
+    def head (*args)
+
+      request :head, args
+    end
+
+    def options (*args)
+
+      request :options, args
+    end
+
     #
-    #     ep = EndPoint.new(
-    #         :host => "restful.server",
-    #         :port => 7080,
-    #         :resource => "inventory/tools")
+    # This is the method called by the module methods verbs.
     #
-    #     res = ep.get :id => 1
-    #         # still a silver bullet ?
+    # For example,
     #
-    #     res = ep.get :id => 0
-    #         # where did the hammer go ?
+    #   RufusVerbs.get(args)
     #
-    # When a request gets prepared, the option values will be looked up
-    # in (1) its local (request) options, then (2) in the EndPoint options.
+    # calls
     #
-    class EndPoint
+    #   RufusVerbs::EndPoint.request(:get, args)
+    #
+    def self.request (method, args, &block)
 
-        include CookieMixin
-        include DigestAuthMixin
-        include VerboseMixin
+      opts = extract_opts args
 
-        #
-        # The endpoint initialization opts (Hash instance)
-        #
-        attr_reader :opts
+      EndPoint.new(opts).request(method, opts, &block)
+    end
 
-        def initialize (opts)
+    #
+    # The instance methods get, post, put and delete ultimately calls
+    # this request() method. All the work is done here.
+    #
+    def request (method, args, &block)
 
-            @opts = opts
+      # prepare request
 
-            compute_target @opts
+      opts = EndPoint.extract_opts args
 
-            @opts[:http_basic_authentication] =
-                opts[:http_basic_authentication] || opts[:hba]
+      compute_target opts
 
-            @opts[:user_agent] ||= USER_AGENT
+      req = create_request method, opts
 
-            @opts[:proxy] ||= ENV['HTTP_PROXY']
+      add_payload(req, opts, &block) if method == :post or method == :put
 
-            prepare_cookie_jar
-        end
+      add_authentication(req, opts)
 
-        def get (*args)
+      add_conditional_headers(req, opts) if method == :get
 
-            request :get, args
-        end
+      mention_cookies(req, opts)
+        # if the :cookies option is disabled (the default)
+        # will have no effect
 
-        def post (*args, &block)
+      vlog_request opts, req
 
-            request :post, args, &block
-        end
+      return req if o(opts, :dry_run) == true
 
-        def put (*args, &block)
+      # trigger request
 
-            request :put, args, &block
-        end
+      http = prepare_http opts
 
-        def delete (*args)
+      vlog_http opts, http
 
-            request :delete, args
-        end
+      res = nil
 
-        def head (*args)
+      http.start do
+        res = http.request req
+      end
 
-            request :head, args
-        end
+      # handle response
 
-        def options (*args)
+      class << res
+        attr_accessor :request
+      end
+      res.request = req
 
-            request :options, args
-        end
+      vlog_response opts, res
 
-        #
-        # This is the method called by the module methods verbs.
-        #
-        # For example,
-        #
-        #     RufusVerbs.get(args)
-        #
-        # calls
-        #
-        #     RufusVerbs::EndPoint.request(:get, args)
-        #
-        def self.request (method, args, &block)
-
-            opts = extract_opts args
-
-            EndPoint.new(opts).request(method, opts, &block)
-        end
+      register_cookies res, opts
+        # if the :cookies option is disabled (the default)
+        # will have no effect
 
-        #
-        # The instance methods get, post, put and delete ultimately calls
-        # this request() method. All the work is done here.
-        #
-        def request (method, args, &block)
+      return res if o(opts, :raw_response)
 
-            # prepare request
+      check_authentication_info res, opts
+        # used in case of :digest_authentication
+        # will have no effect else
 
-            opts = EndPoint.extract_opts args
+      res = handle_response method, res, opts
 
-            compute_target opts
+      return parse_options(res) if method == :options
 
-            req = create_request method, opts
+      return res.body if o(opts, :body)
 
-            add_payload(req, opts, &block) if method == :post or method == :put
+      res
+    end
 
-            add_authentication(req, opts)
+    private
 
-            add_conditional_headers(req, opts) if method == :get
+    #
+    # Manages various args formats :
+    #
+    #   uri
+    #   [ uri ]
+    #   [ uri, opts ]
+    #   opts
+    #
+    def self.extract_opts (args)
 
-            mention_cookies(req, opts)
-                # if the :cookies option is disabled (the default)
-                # will have no effect
+      opts = {}
 
-            vlog_request opts, req
+      args = [ args ] unless args.is_a?(Array)
 
-            return req if o(opts, :dry_run) == true
+      opts = args.last \
+        if args.last.is_a?(Hash)
 
-            # trigger request
+      opts[:uri] = args.first \
+        if args.first.is_a?(String) or args.first.is_a?(URI)
 
-            http = prepare_http opts
+      opts
+    end
 
-            vlog_http opts, http
+    #
+    # Returns the value from the [request] opts or from the
+    # [endpoint] @opts.
+    #
+    def o (opts, key)
+
+      keys = Array key
+      keys.each { |k| (v = opts[k]; return v if v != nil) }
+      keys.each { |k| (v = @opts[k]; return v if v != nil) }
+      nil
+    end
 
-            res = nil
+    #
+    # Returns scheme, host, port, path, query
+    #
+    def compute_target (opts)
+
+      u = opts[:uri] || opts[:u]
+
+      r = if opts[:host]
+
+        [ opts[:scheme] || 'http',
+          opts[:host],
+          opts[:port]  || 80,
+          opts[:path] || '/',
+          opts[:query] || opts[:params] ]
+
+      elsif u
+
+        u = URI.parse u.to_s unless u.is_a?(URI)
+        [ u.scheme,
+          u.host,
+          u.port,
+          u.path,
+          query_to_h(u.query) ]
+      else
+
+        []
+      end
+
+      opts[:scheme] = r[0] || @opts[:scheme]
+      opts[:host] = r[1] || @opts[:host]
+      opts[:port] = r[2] || @opts[:port]
+      opts[:path] = r[3] || @opts[:path]
+
+      opts[:query] =
+        r[4] ||
+        opts[:params] || opts[:query] ||
+        @opts[:query] || @opts[:params] ||
+        {}
+
+      opts.delete :path if opts[:path] == ''
+
+      opts[:c_uri] = [
+        opts[:scheme],
+        opts[:host],
+        opts[:port],
+        opts[:path],
+        opts[:query] ].inspect
+          #
+          # can be used for conditional gets
+
+      r
+    end
 
-            http.start do
-                res = http.request req
-            end
+    #
+    # Creates the Net::HTTP request instance.
+    #
+    # If :fake_put is set, will use Net::HTTP::Post
+    # and make sure the query string contains '_method=put' (or
+    # '_method=delete').
+    #
+    # This call will also advertise this rufus-verbs as
+    # 'accepting the gzip encoding' (in case of GET).
+    #
+    def create_request (method, opts)
 
-            # handle response
+      if (o(opts, :fake_put) and
+        (method == :put or method == :delete))
 
-            class << res
-                attr_accessor :request
-            end
-            res.request = req
+        opts[:query][:_method] = method.to_s
+        method = :post
+      end
 
-            vlog_response opts, res
+      path = compute_path opts
 
-            register_cookies res, opts
-                # if the :cookies option is disabled (the default)
-                # will have no effect
+      r = eval("Net::HTTP::#{method.to_s.capitalize}").new path
 
-            return res if o(opts, :raw_response)
+      r['User-Agent'] = o(opts, :user_agent)
+        # potentially overriden by opts[:headers]
 
-            check_authentication_info res, opts
-                # used in case of :digest_authentication
-                # will have no effect else
+      h = opts[:headers] || opts[:h]
+      h.each { |k, v| r[k] = v } if h
 
-            res = handle_response method, res, opts
+      r['Accept-Encoding'] = 'gzip' \
+        if method == :get and not o(opts, :nozip)
 
-            return parse_options(res) if method == :options
+      r
+    end
 
-            return res.body if o(opts, :body)
+    #
+    # If @user and @pass are set, will activate basic authentication.
+    # Else if the @auth option is set, will assume it contains a Proc
+    # and will call it (with the request as a parameter).
+    #
+    # This comment is too much... Just read the code...
+    #
+    def add_authentication (req, opts)
 
-            res
-        end
+      b = o(opts, :http_basic_authentication)
+      d = o(opts, :digest_authentication)
+      o = o(opts, :auth)
 
-        private
-
-            #
-            # Manages various args formats :
-            #
-            #     uri
-            #     [ uri ]
-            #     [ uri, opts ]
-            #     opts
-            #
-            def self.extract_opts (args)
-
-                opts = {}
-
-                args = [ args ] unless args.is_a?(Array)
-
-                opts = args.last \
-                    if args.last.is_a?(Hash)
-
-                opts[:uri] = args.first \
-                    if args.first.is_a?(String) or args.first.is_a?(URI)
+      if b and b != false
 
-                opts
-            end
+        req.basic_auth b[0], b[1]
 
-            #
-            # Returns the value from the [request] opts or from the
-            # [endpoint] @opts.
-            #
-            def o (opts, key)
-
-                keys = Array key
-                keys.each { |k| (v = opts[k]; return v if v != nil) }
-                keys.each { |k| (v = @opts[k]; return v if v != nil) }
-                nil
-            end
-
-            #
-            # Returns scheme, host, port, path, query
-            #
-            def compute_target (opts)
+      elsif d and d != false
 
-                u = opts[:uri] || opts[:u]
+        digest_auth req, opts
 
-                r = if opts[:host]
+      elsif o and o != false
 
-                    [ opts[:scheme] || 'http',
-                      opts[:host],
-                      opts[:port]  || 80,
-                      opts[:path] || '/',
-                      opts[:query] || opts[:params] ]
+        o.call req
+      end
+    end
 
-                elsif u
+    #
+    # In that base class, it's empty.
+    # It's implemented in ConditionalEndPoint.
+    #
+    # Only called for a GET.
+    #
+    def add_conditional_headers (req, opts)
 
-                    u = URI.parse u.to_s unless u.is_a?(URI)
-                    [ u.scheme,
-                      u.host,
-                      u.port,
-                      u.path,
-                      query_to_h(u.query) ]
-                else
+      # nada
+    end
 
-                    []
-                end
+    #
+    # Prepares a Net::HTTP instance, with potentially some
+    # https settings.
+    #
+    def prepare_http (opts)
 
-                opts[:scheme] = r[0] || @opts[:scheme]
-                opts[:host] = r[1] || @opts[:host]
-                opts[:port] = r[2] || @opts[:port]
-                opts[:path] = r[3] || @opts[:path]
+      compute_proxy opts
 
-                opts[:query] =
-                    r[4] ||
-                    opts[:params] || opts[:query] ||
-                    @opts[:query] || @opts[:params] ||
-                    {}
+      http = Net::HTTP.new(
+        opts[:host], opts[:port],
+        opts[:proxy_host], opts[:proxy_port],
+        opts[:proxy_user], opts[:proxy_pass])
 
-                opts.delete :path if opts[:path] == ""
+      set_timeout http, opts
 
-                opts[:c_uri] = [
-                    opts[:scheme],
-                    opts[:host],
-                    opts[:port],
-                    opts[:path],
-                    opts[:query] ].inspect
-                        #
-                        # can be used for conditional gets
+      return http unless opts[:scheme].to_s == 'https'
 
-                r
-            end
+      require 'net/https'
 
-            #
-            # Creates the Net::HTTP request instance.
-            #
-            # If :fake_put is set, will use Net::HTTP::Post
-            # and make sure the query string contains '_method=put' (or
-            # '_method=delete').
-            #
-            # This call will also advertise this rufus-verbs as
-            # 'accepting the gzip encoding' (in case of GET).
-            #
-            def create_request (method, opts)
+      http.use_ssl = true
+      http.enable_post_connection_check = true \
+        if http.respond_to?(:enable_post_connection_check=)
 
-                if (o(opts, :fake_put) and
-                    (method == :put or method == :delete))
+      http.verify_mode = if o(opts, :ssl_verify_peer)
+        OpenSSL::SSL::VERIFY_PEER
+      else
+        OpenSSL::SSL::VERIFY_NONE
+      end
 
-                    opts[:query][:_method] = method.to_s
-                    method = :post
-                end
+      store = OpenSSL::X509::Store.new
+      store.set_default_paths
+      http.cert_store = store
 
-                path = compute_path opts
+      http
+    end
 
-                r = eval("Net::HTTP::#{method.to_s.capitalize}").new path
+    #
+    # Sets both the open_timeout and the read_timeout for the http
+    # instance
+    #
+    def set_timeout (http, opts)
 
-                r['User-Agent'] = o(opts, :user_agent)
-                    # potentially overriden by opts[:headers]
+      to = o(opts, :timeout) || o(opts, :to)
+      to = to.to_i
 
-                h = opts[:headers] || opts[:h]
-                h.each { |k, v| r[k] = v } if h
+      return if to == 0
 
-                r['Accept-Encoding'] = 'gzip' \
-                    if method == :get and not o(opts, :nozip)
+      http.open_timeout = to
+      http.read_timeout = to
+    end
 
-                r
-            end
+    #
+    # Makes sure the request opts hold the proxy information.
+    #
+    # If the option :proxy is set to false, no proxy will be used.
+    #
+    def compute_proxy (opts)
 
-            #
-            # If @user and @pass are set, will activate basic authentication.
-            # Else if the @auth option is set, will assume it contains a Proc
-            # and will call it (with the request as a parameter).
-            #
-            # This comment is too much... Just read the code...
-            #
-            def add_authentication (req, opts)
+      p = o(opts, :proxy)
 
-                b = o(opts, :http_basic_authentication)
-                d = o(opts, :digest_authentication)
-                o = o(opts, :auth)
+      return unless p
 
-                if b and b != false
+      u = URI.parse p.to_s
 
-                    req.basic_auth b[0], b[1]
+      raise "not an HTTP[S] proxy '#{u.host}'" \
+        unless u.scheme.match(/^http/)
 
-                elsif d and d != false
+      opts[:proxy_host] = u.host
+      opts[:proxy_port] = u.port
+      opts[:proxy_user] = u.user
+      opts[:proxy_pass] = u.password
+    end
 
-                    digest_auth req, opts
+    #
+    # Determines the full path of the request (path_info and
+    # query_string).
+    #
+    # For example :
+    #
+    #   /items/4?style=whatever&maxcount=12
+    #
+    def compute_path (opts)
 
-                elsif o and o != false
-
-                    o.call req
-                end
-            end
+      b = o(opts, :base)
+      r = o(opts, [ :res, :resource ])
+      i = o(opts, :id)
 
-            #
-            # In that base class, it's empty.
-            # It's implemented in ConditionalEndPoint.
-            #
-            # Only called for a GET.
-            #
-            def add_conditional_headers (req, opts)
+      path = o(opts, :path)
 
-                # nada
-            end
+      if b or r or i
+        path = b ? "/#{b}" : ''
+        path += "/#{r}" if r
+        path += "/#{i}" if i
+      end
 
-            #
-            # Prepares a Net::HTTP instance, with potentially some
-            # https settings.
-            #
-            def prepare_http (opts)
+      path = path[1..-1] if path[0..1] == '//'
 
-                compute_proxy opts
+      query = opts[:query] || opts[:params]
 
-                http = Net::HTTP.new(
-                    opts[:host], opts[:port],
-                    opts[:proxy_host], opts[:proxy_port],
-                    opts[:proxy_user], opts[:proxy_pass])
+      return path if not query or query.size < 1
 
-                set_timeout http, opts
+      path + '?' + h_to_query(query, opts)
+    end
 
-                return http unless opts[:scheme] == 'https'
+    #
+    #   "a=A&b=B" -> { "a" => "A", "b" => "B" }
+    #
+    def query_to_h (q)
 
-                require 'net/https'
+      return nil unless q
 
-                http.use_ssl = true
-                http.enable_post_connection_check = true
+      q.split('&').inject({}) do |r, e|
+        s = e.split('=')
+        r[s[0]] = s[1]
+        r
+      end
+    end
 
-                http.verify_mode = if o(opts, :ssl_verify_peer)
-                    OpenSSL::SSL::VERIFY_PEER
-                else
-                    OpenSSL::SSL::VERIFY_NONE
-                end
+    #
+    #   { "a" => "A", "b" => "B" } -> "a=A&b=B"
+    #
+    def h_to_query (h, opts)
+
+      h.entries.collect { |k, v|
+        unless o(opts, :no_escape)
+          #k = URI.escape k.to_s
+          #v = URI.escape v.to_s
+          k = CGI.escape(k.to_s)
+          v = CGI.escape(v.to_s)
+        end
+        "#{k}=#{v}"
+      }.join('&')
+    end
 
-                store = OpenSSL::X509::Store.new
-                store.set_default_paths
-                http.cert_store = store
+    #
+    # Fills the request body (with the content of :d or :fd).
+    #
+    def add_payload (req, opts, &block)
+
+      d = opts[:d] || opts[:data]
+      fd = opts[:fd] || opts[:form_data]
+
+      if d
+        req.body = d
+      elsif fd
+        sep = opts[:fd_sep] #|| nil
+        req.set_form_data fd, sep
+      elsif block
+        req.body = block.call req
+      else
+        req.body = ''
+      end
+    end
 
-                http
-            end
+    #
+    # Handles the server response.
+    # Eventually follows redirections.
+    #
+    # Once the final response has been hit, will make sure
+    # it's decompressed.
+    #
+    def handle_response (method, res, opts)
 
-            #
-            # Sets both the open_timeout and the read_timeout for the http
-            # instance
-            #
-            def set_timeout (http, opts)
+      nored = o(opts, [ :no_redirections, :noredir ])
 
-                to = o(opts, :timeout) || o(opts, :to)
-                to = to.to_i
+      #if res.is_a?(Net::HTTPRedirection)
+      if [ 301, 302, 303, 307 ].include?(res.code.to_i) and (nored != true)
 
-                return if to == 0
+        maxr = o(opts, :max_redirections)
 
-                http.open_timeout = to
-                http.read_timeout = to
-            end
+        if maxr
+          maxr = maxr - 1
+          raise 'too many redirections' if maxr == -1
+          opts[:max_redirections] = maxr
+        end
 
-            #
-            # Makes sure the request opts hold the proxy information.
-            #
-            # If the option :proxy is set to false, no proxy will be used.
-            #
-            def compute_proxy (opts)
-
-                p = o(opts, :proxy)
-
-                return unless p
-
-                u = URI.parse p.to_s
-
-                raise "not an HTTP[S] proxy '#{u.host}'" \
-                    unless u.scheme.match(/^http/)
-
-                opts[:proxy_host] = u.host
-                opts[:proxy_port] = u.port
-                opts[:proxy_user] = u.user
-                opts[:proxy_pass] = u.password
-            end
-
-            #
-            # Determines the full path of the request (path_info and
-            # query_string).
-            #
-            # For example :
-            #
-            #     /items/4?style=whatever&maxcount=12
-            #
-            def compute_path (opts)
-
-                b = o(opts, :base)
-                r = o(opts, [ :res, :resource ])
-                i = o(opts, :id)
-
-                path = o(opts, :path)
-
-                if b or r or i
-                    path = ""
-                    path = "/#{b}" if b
-                    path += "/#{r}" if r
-                    path += "/#{i}" if i
-                end
-
-                path = path[1..-1] if path[0..1] == '//'
-
-                query = opts[:query] || opts[:params]
-
-                return path if not query or query.size < 1
-
-                path + '?' + h_to_query(query, opts)
-            end
-
-            #
-            #     "a=A&b=B" -> { "a" => "A", "b" => "B" }
-            #
-            def query_to_h (q)
-
-                return nil unless q
-
-                q.split("&").inject({}) do |r, e|
-                    s = e.split("=")
-                    r[s[0]] = s[1]
-                    r
-                end
-            end
-
-            #
-            #     { "a" => "A", "b" => "B" } -> "a=A&b=B"
-            #
-            def h_to_query (h, opts)
-
-                h.entries.collect { |k, v|
-                    unless o(opts, :no_escape)
-                        k = URI.escape k.to_s
-                        v = URI.escape v.to_s
-                    end
-                    "#{k}=#{v}"
-                }.join("&")
-            end
-
-            #
-            # Fills the request body (with the content of :d or :fd).
-            #
-            def add_payload (req, opts, &block)
-
-                d = opts[:d] || opts[:data]
-                fd = opts[:fd] || opts[:form_data]
-
-                if d
-                    req.body = d
-                elsif fd
-                    sep = opts[:fd_sep] #|| nil
-                    req.set_form_data fd, sep
-                elsif block
-                    req.body = block.call req
-                else
-                    req.body = ""
-                end
-            end
-
-            #
-            # Handles the server response.
-            # Eventually follows redirections.
-            #
-            # Once the final response has been hit, will make sure
-            # it's decompressed.
-            #
-            def handle_response (method, res, opts)
-
-                nored = o(opts, [ :no_redirections, :noredir ])
-
-                #if res.is_a?(Net::HTTPRedirection)
-                if [ 301, 303, 307 ].include?(res.code.to_i) and (nored != true)
-
-                    maxr = o(opts, :max_redirections)
-
-                    if maxr
-                        maxr = maxr - 1
-                        raise "too many redirections" if maxr == -1
-                        opts[:max_redirections] = maxr
-                    end
-
-                    location = res['Location']
-
-                    prev_host = [ opts[:scheme], opts[:host] ]
-
-                    if location.match /^http/
-                        u = URI::parse location
-                        opts[:scheme] = u.scheme
-                        opts[:host] = u.host
-                        opts[:port] = u.port
-                        opts[:path] = u.path
-                        opts[:query] = u.query
-                    else
-                        opts[:path], opts[:query] = location.split "?"
-                    end
-
-                    if (authentication_is_on?(opts) and
-                        [ opts[:scheme], opts[:host] ] != prev_host)
-
-                        raise(
-                            "getting redirected to #{location} while " +
-                            "authentication is on. Stopping.")
-                    end
-
-                    opts[:query] = query_to_h opts[:query]
-
-                    return request(method, opts)
-                        #
-                        # following the redirection
-                end
-
-                decompress res
-
-                res
-            end
-
-            #
-            # Returns an array of symbols, like for example
-            #
-            #     [ :get, :post ]
-            #
-            # obtained by parsing the 'Allow' response header.
-            #
-            # This method is used to provide the result of an OPTIONS
-            # HTTP method.
-            #
-            def parse_options (res)
-
-                s = res['Allow']
-
-                return [] unless s
-
-                s.split(",").collect do |m|
-                    m.strip.downcase.to_sym
-                end
-            end
-
-            #
-            # Returns true if the current request has authentication
-            # going on.
-            #
-            def authentication_is_on? (opts)
-
-                (o(opts, [ :http_basic_authentication, :hba, :auth ]) != nil)
-            end
-
-            #
-            # Inflates the response body if necessary.
-            #
-            def decompress (res)
-
-                if res['content-encoding'] == 'gzip'
-
-                    class << res
-
-                        attr_accessor :deflated_body
-
-                        alias :old_body :body
-
-                        def body
-                            @deflated_body || old_body
-                        end
-                    end
-                        #
-                        # reopened the response to add
-                        # a 'deflated_body' attr and let the the body
-                        # method point to it
+        location = res['Location']
 
-                    # now deflate...
+        prev_host = [ opts[:scheme], opts[:host] ]
 
-                    io = StringIO.new res.body
-                    gz = Zlib::GzipReader.new io
-                    res.deflated_body = gz.read
-                    gz.close
-                end
-            end
+        if location.match /^http/
+          u = URI::parse location
+          opts[:scheme] = u.scheme
+          opts[:host] = u.host
+          opts[:port] = u.port
+          opts[:path] = u.path
+          opts[:query] = u.query
+        else
+          opts[:path], opts[:query] = location.split "?"
+        end
+
+        if (authentication_is_on?(opts) and
+          [ opts[:scheme], opts[:host] ] != prev_host)
+
+          raise(
+            "getting redirected to #{location} while " +
+            "authentication is on. Stopping.")
+        end
+
+        opts[:query] = query_to_h opts[:query]
+
+        return request(method, opts)
+          #
+          # following the redirection
+      end
+
+      decompress res
+
+      res
+    end
+
+    #
+    # Returns an array of symbols, like for example
+    #
+    #   [ :get, :post ]
+    #
+    # obtained by parsing the 'Allow' response header.
+    #
+    # This method is used to provide the result of an OPTIONS
+    # HTTP method.
+    #
+    def parse_options (res)
+
+      s = res['Allow']
+
+      return [] unless s
+
+      s.split(',').collect do |m|
+        m.strip.downcase.to_sym
+      end
+    end
+
+    #
+    # Returns true if the current request has authentication
+    # going on.
+    #
+    def authentication_is_on? (opts)
+
+      (o(opts, [ :http_basic_authentication, :hba, :auth ]) != nil)
+    end
+
+    #
+    # Inflates the response body if necessary.
+    #
+    def decompress (res)
+
+      if res['content-encoding'] == 'gzip'
+
+        class << res
+
+          attr_accessor :deflated_body
+
+          alias :old_body :body
+
+          def body
+            @deflated_body || old_body
+          end
+        end
+          #
+          # reopened the response to add
+          # a 'deflated_body' attr and let the the body
+          # method point to it
+
+        # now deflate...
+
+        io = StringIO.new res.body
+        gz = Zlib::GzipReader.new io
+        res.deflated_body = gz.read
+        gz.close
+      end
     end
+  end
 end
 end