module RestClient

def self.add_before_execution_proc &proc

The proc parameters will be the http request and the request params.
Add a Proc to be called before each request in executed. 
def self.add_before_execution_proc &proc
  @@before_execution_procs << proc
end

def self.before_execution_procs # :nodoc:

:nodoc: 
def self.before_execution_procs # :nodoc:
  @@before_execution_procs
end

def self.create_log param

param can be 'stdout', 'stderr', a string (then we will log to that file) or a logger (then we return it)
Create a log that respond to << like a logger 
def self.create_log param
  if param
    if param.is_a? String
      if param == 'stdout'
        stdout_logger = Class.new do
          def << obj
            STDOUT.puts obj
          end
        end
        stdout_logger.new
      elsif param == 'stderr'
        stderr_logger = Class.new do
          def << obj
            STDERR.puts obj
          end
        end
        stderr_logger.new
      else
        file_logger = Class.new do
          attr_writer :target_file
          def << obj
            File.open(@target_file, 'a') { |f| f.puts obj }
          end
        end
        logger = file_logger.new
        logger.target_file = param
        logger
      end
    else
      param
    end
  end
end

def self.delete(url, headers={}, &block) 

def self.delete(url, headers={}, &block)
  Request.execute(:method => :delete, :url => url, :headers => headers, &block)
end

def self.get(url, headers={}, &block) 

def self.get(url, headers={}, &block)
  Request.execute(:method => :get, :url => url, :headers => headers, &block)
end

def self.head(url, headers={}, &block) 

def self.head(url, headers={}, &block)
  Request.execute(:method => :head, :url => url, :headers => headers, &block)
end

def self.log # :nodoc:

:nodoc: 
def self.log # :nodoc:
  @@env_log || @@log
end

def self.log= log

You can also configure logging by the environment variable RESTCLIENT_LOG.
Value should be a logger but can can be stdout, stderr, or a filename.
Setup the log for RestClient calls. 
def self.log= log
  @@log = create_log log
end

def self.options(url, headers={}, &block) 

def self.options(url, headers={}, &block)
  Request.execute(:method => :options, :url => url, :headers => headers, &block)
end

def self.patch(url, payload, headers={}, &block) 

def self.patch(url, payload, headers={}, &block)
  Request.execute(:method => :patch, :url => url, :payload => payload, :headers => headers, &block)
end

def self.post(url, payload, headers={}, &block) 

def self.post(url, payload, headers={}, &block)
  Request.execute(:method => :post, :url => url, :payload => payload, :headers => headers, &block)
end

def self.put(url, payload, headers={}, &block) 

def self.put(url, payload, headers={}, &block)
  Request.execute(:method => :put, :url => url, :payload => payload, :headers => headers, &block)
end

def self.reset_before_execution_procs

Reset the procs to be called before each request is executed. 
def self.reset_before_execution_procs
  @@before_execution_procs = []
end

def self.version 

def self.version
  VERSION
end

def << obj 

def << obj
  STDOUT.puts obj
end

def << obj 

def << obj
  STDERR.puts obj
end

def << obj 

def << obj
  File.open(@target_file, 'a') { |f| f.puts obj }
end