kronk 1.4.0 → 1.5.0

data/lib/kronk/plist_parser.rb

@@ -11,6 +11,10 @@ class Kronk
     def self.parse plist
       require 'plist'
       Plist.parse_xml plist
+
+    rescue LoadError => e
+      raise unless e.message =~ /-- plist/
+      raise MissingDependency, "Please install the plist gem and try again"
     end
   end
 end

data/lib/kronk/request.rb

@@ -1,387 +1,411 @@
 class Kronk
 
   ##
-  # Request wrapper class for net/http.
+  # Performs HTTP requests or retrieves HTTP responses.
 
   class Request
 
-    # Generic Request exception.
-    class Exception < ::Exception; end
+    # Raised by Request.parse when parsing invalid http request string.
+    class ParseError < Kronk::Exception; end
 
-    # Raised when the URI was not resolvable.
-    class NotFoundError < Exception; end
-
-    # Raised when HTTP times out.
-    class TimeoutError < Exception; end
+    # Matches the first line of an http request string.
+    REQUEST_LINE_MATCHER = %r{([A-Za-z]+)?(^|[\s'"])(/[^\s'";]+)[\s"']*}
 
     ##
-    # Follows the redirect from a 30X response object and decrease the
-    # number of redirects left if it's an Integer.
-
-    def self.follow_redirect resp, options={}
-      Kronk::Cmd.verbose "Following redirect..."
+    # Creates a query string from data.
 
-      rdir = options[:follow_redirects]
-      rdir = rdir - 1 if Integer === rdir && rdir > 0
+    def self.build_query data, param=nil
+      return data.to_s unless param || Hash === data
 
-      options = options.merge :follow_redirects => rdir,
-                              :http_method      => :get
+      case data
+      when Array
+        out = data.map do |value|
+          key = "#{param}[]"
+          build_query value, key
+        end
 
-      retrieve_uri resp['Location'], options
-    end
+        out.join "&"
 
+      when Hash
+        out = data.map do |key, value|
+          key = param.nil? ? key : "#{param}[#{key}]"
+          build_query value, key
+        end
 
-    ##
-    # Check the rdir value to figure out if redirect should be followed.
+        out.join "&"
 
-    def self.follow_redirect? resp, rdir
-      resp.code.to_s =~ /^30\d$/ &&
-      (rdir == true || Integer === rdir && rdir > 0)
+      else
+        "#{param}=#{data}"
+      end
     end
 
 
     ##
-    # Returns the value from a url, file, or IO as a String.
-    # Options supported are:
-    # :data:: Hash/String - the data to pass to the http request
-    # :query:: Hash/String - the data to append to the http request path
-    # :follow_redirects:: Integer/Bool - number of times to follow redirects
-    # :user_agent:: String - user agent string or alias; defaults to 'kronk'
-    # :auth:: Hash - must contain :username and :password; defaults to nil
-    # :headers:: Hash - extra headers to pass to the request
-    # :http_method:: Symbol - the http method to use; defaults to :get
-    # :proxy:: Hash/String - http proxy to use; defaults to nil
+    # Build the URI to use for the request from the given uri or
+    # path and options.
 
-    def self.retrieve uri, options={}
-      if IO === uri || StringIO === uri
-        resp = retrieve_io uri, options
-      elsif File.file? uri
-        resp = retrieve_file uri, options
-      else
-        resp = retrieve_uri uri, options
-        Kronk.history << uri
-      end
+    def self.build_uri uri, options={}
+      uri  ||= Kronk.config[:default_host]
+      suffix = options[:uri_suffix]
 
-      begin
-        File.open(options[:cache_response], "wb+") do |file|
-          file.write resp.raw
-        end if options[:cache_response]
-      rescue => e
-        $stderr << "#{e.class}: #{e.message}"
+      uri = "http://#{uri}"   unless uri.to_s =~ %r{^(\w+://|/)}
+      uri = "#{uri}#{suffix}" if suffix
+      uri = URI.parse uri     unless URI === uri
+      uri = URI.parse(Kronk.config[:default_host]) + uri unless uri.host
+
+      if options[:query]
+        query = build_query options[:query]
+        uri.query = [uri.query, query].compact.join "&"
       end
 
-      resp
+      uri
+    end
+
+
+    ##
+    # Parses a raw HTTP request-like string into a Kronk::Request instance.
 
-    rescue SocketError, Errno::ENOENT, Errno::ECONNREFUSED
-      raise NotFoundError, "#{uri} could not be found"
+    def self.parse str, opts={}
+      opts = parse_to_hash str, opts
+      raise ParseError unless opts
 
-    rescue Timeout::Error
-      raise TimeoutError, "#{uri} took too long to respond"
+      new opts.delete(:host), opts
     end
 
 
     ##
-    # Read http response from a file and return a HTTPResponse instance.
+    # Parses a raw HTTP request-like string into a Kronk::Request options hash.
+    # Also parses most single access log entries.
+
+    def self.parse_to_hash str, opts={}
+      lines = str.split("\n")
+      return if lines.empty?
 
-    def self.retrieve_file path, options={}
-      Kronk::Cmd.verbose "Reading file:  #{path}\n"
+      body_start = nil
 
-      options = options.dup
-      resp    = nil
+      opts[:headers] ||= {}
 
-      File.open(path, "rb") do |file|
+      lines.shift.strip =~ REQUEST_LINE_MATCHER
+      opts[:http_method], opts[:uri_suffix] = $1, $3
 
-        # On windows, read the full file and insert contents into
-        # a StringIO to avoid failures with IO#read_nonblock
-        file = StringIO.new file.read if Kronk::Cmd.windows?
+      lines.each_with_index do |line, i|
+        case line
+        when /^Host: /
+          opts[:host] = line.split(": ", 2)[1].strip
 
-        begin
-          resp = Response.read_new file
+        when "", "\r"
+          body_start = i+1
+          break
 
-        rescue Net::HTTPBadResponse
-          file.rewind
-          resp = HeadlessResponse.new file.read, File.extname(path)
+        else
+          name, value = line.split(": ", 2)
+          opts[:headers][name] = value.strip if value
         end
       end
 
-      resp = follow_redirect resp, options if
-        follow_redirect? resp, options[:follow_redirects]
+      opts[:data] = lines[body_start..-1].join("\n") if body_start
+
+      opts.delete(:uri_suffix)  if !opts[:uri_suffix]
+      opts.delete(:headers)     if opts[:headers].empty?
+      opts.delete(:http_method) if !opts[:http_method]
+      opts.delete(:data)        if opts[:data] && opts[:data].strip.empty?
 
-      resp
+      return if opts.empty?
+      opts
     end
 
 
     ##
-    # Read the http response from an IO instance and return a HTTPResponse.
+    # Parses a nested query. Stolen from Rack.
 
-    def self.retrieve_io io, options={}
-      Kronk::Cmd.verbose "Reading IO..."
+    def self.parse_nested_query qs, d=nil
+      params = {}
+      d ||= "&;"
 
-      options = options.dup
+      (qs || '').split(%r{[#{d}] *}n).each do |p|
+        k, v = CGI.unescape(p).split('=', 2)
+        normalize_params(params, k, v)
+      end
 
-      resp = nil
+      params
+    end
 
-      begin
-        resp = Response.read_new io
 
-      rescue Net::HTTPBadResponse
-        io.rewind
-        resp = HeadlessResponse.new io.read
-      end
+    ##
+    # Stolen from Rack.
 
-      resp = follow_redirect resp, options if
-        follow_redirect? resp, options[:follow_redirects]
+    def self.normalize_params params, name, v=nil
+      name =~ %r(\A[\[\]]*([^\[\]]+)\]*)
+      k = $1 || ''
+      after = $' || ''
 
-      resp
-    end
+      return if k.empty?
 
+      if after == ""
+        params[k] = v
 
-    ##
-    # Make an http request to the given uri and return a HTTPResponse instance.
-    # Supports the following options:
-    # :data:: Hash/String - the data to pass to the http request
-    # :query:: Hash/String - the data to append to the http request path
-    # :follow_redirects:: Integer/Bool - number of times to follow redirects
-    # :user_agent:: String - user agent string or alias; defaults to 'kronk'
-    # :auth:: Hash - must contain :username and :password; defaults to nil
-    # :headers:: Hash - extra headers to pass to the request
-    # :http_method:: Symbol - the http method to use; defaults to :get
-    # :proxy:: Hash/String - http proxy to use; defaults to nil
-    #
-    # Note: if no http method is specified and data is given, will default
-    # to using a post request.
+      elsif after == "[]"
+        params[k] ||= []
+        raise TypeError,
+          "expected Array (got #{params[k].class.name}) for param `#{k}'" unless
+            params[k].is_a?(Array)
 
-    def self.retrieve_uri uri, options={}
-      options     = options.dup
-      http_method = options.delete(:http_method)
-      http_method ||= options[:data] ? :post : :get
+        params[k] << v
 
-      resp = self.call http_method, uri, options
+      elsif after =~ %r(^\[\]\[([^\[\]]+)\]$) || after =~ %r(^\[\](.+)$)
+        child_key = $1
+        params[k] ||= []
+        raise TypeError,
+          "expected Array (got #{params[k].class.name}) for param `#{k}'" unless
+            params[k].is_a?(Array)
 
-      resp = follow_redirect resp, options if
-        follow_redirect? resp, options[:follow_redirects]
+        if params[k].last.is_a?(Hash) && !params[k].last.key?(child_key)
+          normalize_params(params[k].last, child_key, v)
+        else
+          params[k] << normalize_params({}, child_key, v)
+        end
 
-      resp
+      else
+        params[k] ||= {}
+        raise TypeError,
+          "expected Hash (got #{params[k].class.name}) for param `#{k}'" unless
+            params[k].is_a?(Hash)
+
+        params[k] = normalize_params(params[k], after, v)
+      end
+
+      return params
     end
 
 
+    attr_accessor :body, :headers, :response, :timeout
+
+    attr_reader :http_method, :uri, :use_cookies
+
     ##
-    # Make an http request to the given uri and return a HTTPResponse instance.
+    # Build an http request to the given uri and return a Response instance.
     # Supports the following options:
-    # :data:: Hash/String - the data to pass to the http request body
+    # :data:: Hash/String - the data to pass to the http request
     # :query:: Hash/String - the data to append to the http request path
+    # :follow_redirects:: Integer/Bool - number of times to follow redirects
     # :user_agent:: String - user agent string or alias; defaults to 'kronk'
     # :auth:: Hash - must contain :username and :password; defaults to nil
     # :headers:: Hash - extra headers to pass to the request
     # :http_method:: Symbol - the http method to use; defaults to :get
     # :proxy:: Hash/String - http proxy to use; defaults to nil
+    #
+    # Note: if no http method is specified and data is given, will default
+    # to using a post request.
 
-    def self.call http_method, uri, options={}
-      uri = build_uri uri, options
-
-      data   = options[:data]
-      data &&= build_query data
+    def initialize uri, options={}
+      @HTTP = Net::HTTP
+      @auth = options[:auth]
 
-      options[:headers] ||= Hash.new
-      options[:headers]['User-Agent'] ||= get_user_agent options[:user_agent]
+      @body = nil
+      @body = self.class.build_query options[:data] if options[:data]
 
-      unless options[:headers]['Cookie'] || !use_cookies?(options)
-        cookie = Kronk.cookie_jar.get_cookie_header uri.to_s
-        options[:headers]['Cookie'] = cookie unless cookie.empty?
-      end
+      @response = nil
+      @_req     = nil
+      @_res     = nil
 
-      socket = socket_io = nil
+      @headers = options[:headers] || {}
+      @timeout = options[:timeout] || Kronk.config[:timeout]
 
-      proxy_addr, proxy_opts =
-        if Hash === options[:proxy]
-          [options[:proxy][:address], options[:proxy]]
-        else
-          [options[:proxy], {}]
-        end
+      @uri = self.class.build_uri uri, options
 
-      http_class = proxy proxy_addr, proxy_opts
+      self.user_agent ||= options[:user_agent]
 
-      req = http_class.new uri.host, uri.port
-      req.use_ssl = true if uri.scheme =~ /^https$/
+      self.http_method = options[:http_method] || (@body ? "POST" : "GET")
 
-      options[:timeout] ||= Kronk.config[:timeout]
-      req.read_timeout = options[:timeout] if options[:timeout]
+      self.use_cookies = options.has_key?(:no_cookies) ?
+                          !options[:no_cookies] : Kronk.config[:use_cookies]
 
-      resp = req.start do |http|
-        socket = http.instance_variable_get "@socket"
-        socket.debug_output = socket_io = StringIO.new
+      if Hash === options[:proxy]
+        self.use_proxy options[:proxy][:address], options[:proxy]
+      else
+        self.use_proxy options[:proxy]
+      end
+    end
 
-        req = VanillaRequest.new http_method.to_s.upcase,
-                uri.request_uri, options[:headers]
 
-        if options[:auth] && options[:auth][:username]
-          req.basic_auth options[:auth][:username],
-                         options[:auth][:password]
-        end
+    ##
+    # Returns the basic auth credentials if available.
 
-        Kronk::Cmd.verbose "Retrieving URL:  #{uri}\n"
+    def auth
+      @auth ||= Hash.new
 
-        http.request req, data
+      if !@auth[:username] && @headers['Authorization']
+        str = Base64.decode64 @headers['Authorization'].split[1]
+        username, password = str.split(":", 2)
+        @auth = {:username => username, :password => password}.merge @auth
       end
 
-      Kronk.cookie_jar.set_cookies_from_headers uri.to_s, resp.to_hash if
-        use_cookies? options
-
-      resp.extend Response::Helpers
-      resp.set_helper_attribs socket_io
-
-      resp
+      @auth
     end
 
 
     ##
-    # Build the URI to use for the request from the given uri or
-    # path and options.
+    # Assigns the cookie string.
 
-    def self.build_uri uri, options={}
-      suffix = options[:uri_suffix]
-
-      uri = "http://#{uri}"   unless uri =~ %r{^(\w+://|/)}
-      uri = "#{uri}#{suffix}" if suffix
-      uri = URI.parse uri unless URI === uri
-      uri = URI.parse(Kronk.config[:default_host]) + uri unless uri.host
-
-      if options[:query]
-        query = build_query options[:query]
-        uri.query = [uri.query, query].compact.join "&"
-      end
-
-      uri
+    def cookie= cookie_str
+      @headers['Cookie'] = cookie_str if @use_cookies
     end
 
 
     ##
-    # Checks if cookies should be used and set.
+    # Assigns the http method.
 
-    def self.use_cookies? options
-      return !options[:no_cookies] if options.has_key? :no_cookies
-      Kronk.config[:use_cookies]
+    def http_method= new_verb
+      @http_method = new_verb.to_s.upcase
     end
 
 
     ##
-    # Gets the user agent to use for the request.
+    # Returns the HTTP request object.
 
-    def self.get_user_agent agent
-      agent && Kronk.config[:user_agents][agent.to_s] || agent ||
-        Kronk.config[:user_agents]['kronk']
+    def http_request
+      req = VanillaRequest.new @http_method, @uri.request_uri, @headers
+
+      req.basic_auth @auth[:username], @auth[:password] if
+        @auth && @auth[:username]
+
+      req
     end
 
 
     ##
-    # Return proxy http class.
+    # Assign the use of a proxy.
     # The proxy_opts arg can be a uri String or a Hash with the :address key
     # and optional :username and :password keys.
 
-    def self.proxy addr, proxy_opts={}
-      return Net::HTTP unless addr
+    def use_proxy addr, opts={}
+      return @HTTP = Net::HTTP unless addr
 
       host, port = addr.split ":"
-      port ||= proxy_opts[:port] || 8080
+      port ||= opts[:port] || 8080
 
-      user = proxy_opts[:username]
-      pass = proxy_opts[:password]
+      user = opts[:username]
+      pass = opts[:password]
 
       Kronk::Cmd.verbose "Using proxy #{addr}\n" if host
 
-      Net::HTTP::Proxy host, port, user, pass
+      @HTTP = Net::HTTP::Proxy host, port, user, pass
     end
 
 
     ##
-    # Creates a query string from data.
+    # Assign the uri and io based on if the uri is a file, io, or url.
 
-    def self.build_query data, param=nil
-      return data.to_s unless param || Hash === data
-
-      case data
-      when Array
-        out = data.map do |value|
-          key = "#{param}[]"
-          build_query value, key
-        end
+    def uri= new_uri
+      @uri = self.class.build_uri new_uri
+    end
 
-        out.join "&"
 
-      when Hash
-        out = data.map do |key, value|
-          key = param.nil? ? key : "#{param}[#{key}]"
-          build_query value, key
-        end
+    ##
+    # Decide whether to use cookies or not.
 
-        out.join "&"
+    def use_cookies= bool
+      if bool && (!@headers['Cookie'] || @headers['Cookie'].empty?)
+        cookie = Kronk.cookie_jar.get_cookie_header @uri.to_s
+        @headers['Cookie'] = cookie unless cookie.empty?
 
       else
-        "#{param}=#{data}"
+        @headers.delete 'Cookie'
       end
+
+      @use_cookies = bool
     end
 
 
     ##
-    # Parses a nested query. Stolen from Rack.
+    # Assign a User Agent header.
 
-    def self.parse_nested_query qs, d=nil
-      params = {}
-      d ||= "&;"
+    def user_agent= new_ua
+      @headers['User-Agent'] =
+        new_ua && Kronk.config[:user_agents][new_ua.to_s] ||
+        new_ua || Kronk.config[:user_agents]['kronk']
+    end
 
-      (qs || '').split(%r{[#{d}] *}n).each do |p|
-        k, v = CGI.unescape(p).split('=', 2)
-        normalize_params(params, k, v)
-      end
 
-      params
+    ##
+    # Read the User Agent header.
+
+    def user_agent
+      @headers['User-Agent']
     end
 
 
     ##
-    # Stolen from Rack.
+    # Check if this is an SSL request.
 
-    def self.normalize_params params, name, v=nil
-      name =~ %r(\A[\[\]]*([^\[\]]+)\]*)
-      k = $1 || ''
-      after = $' || ''
+    def ssl?
+      @uri.scheme == "https"
+    end
 
-      return if k.empty?
 
-      if after == ""
-        params[k] = v
+    ##
+    # Assign whether to use ssl or not.
 
-      elsif after == "[]"
-        params[k] ||= []
-        raise TypeError,
-          "expected Array (got #{params[k].class.name}) for param `#{k}'" unless
-            params[k].is_a?(Array)
+    def ssl= bool
+      @uri.scheme = bool ? "https" : "http"
+    end
 
-        params[k] << v
 
-      elsif after =~ %r(^\[\]\[([^\[\]]+)\]$) || after =~ %r(^\[\](.+)$)
-        child_key = $1
-        params[k] ||= []
-        raise TypeError,
-          "expected Array (got #{params[k].class.name}) for param `#{k}'" unless
-            params[k].is_a?(Array)
+    ##
+    # Retrieve this requests' response.
 
-        if params[k].last.is_a?(Hash) && !params[k].last.key?(child_key)
-          normalize_params(params[k].last, child_key, v)
-        else
-          params[k] << normalize_params({}, child_key, v)
-        end
+    def retrieve
+      @_req = @HTTP.new @uri.host, @uri.port
 
-      else
-        params[k] ||= {}
-        raise TypeError,
-          "expected Hash (got #{params[k].class.name}) for param `#{k}'" unless
-            params[k].is_a?(Hash)
+      @_req.read_timeout = @timeout if @timeout
+      @_req.use_ssl      = true     if @uri.scheme =~ /^https$/
 
-        params[k] = normalize_params(params[k], after, v)
+      elapsed_time = nil
+      socket       = nil
+      socket_io    = nil
+
+      @_res = @_req.start do |http|
+        socket = http.instance_variable_get "@socket"
+        socket.debug_output = socket_io = StringIO.new
+
+        start_time = Time.now
+        res = http.request self.http_request, @body
+        elapsed_time = Time.now - start_time
+
+        res
       end
 
-      return params
+      Kronk.cookie_jar.set_cookies_from_headers @uri.to_s, @_res.to_hash if
+        self.use_cookies
+
+      @response      = Response.new socket_io, @_res, self
+      @response.time = elapsed_time
+
+      @response
+    end
+
+
+    ##
+    # Returns the raw HTTP request String.
+
+    def to_s
+      out = "#{@http_method} #{@uri.request_uri} HTTP/1.1\r\n"
+      out << "host: #{@uri.host}:#{@uri.port}\r\n"
+
+      self.http_request.each do |name, value|
+        out << "#{name}: #{value}\r\n" unless name =~ /host/i
+      end
+
+      out << "\r\n"
+      out << @body.to_s
+    end
+
+
+    ##
+    # Ruby inspect.
+
+    def inspect
+      "#<#{self.class}:#{self.http_method} #{self.uri}>"
     end