kronk 1.0.0

data/lib/kronk/request.rb

@@ -0,0 +1,191 @@
+class Kronk
+
+  ##
+  # Request wrapper class for net/http.
+
+  class Request
+
+    class NotFoundError < Exception; end
+
+    ##
+    # 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={}
+      rdir = options[:follow_redirects]
+      rdir = rdir - 1 if Integer === rdir && rdir > 0
+
+      retrieve_uri resp['Location'], options.merge(:follow_redirects => rdir)
+    end
+
+
+    ##
+    # Check the rdir value to figure out if redirect should be followed.
+
+    def self.follow_redirect? resp, rdir
+      resp.code.to_s =~ /^30\d$/ &&
+      (rdir == true || Integer === rdir && rdir > 0)
+    end
+
+
+    ##
+    # Returns the value from a url, file, or cache as a String.
+    # Options supported are:
+    # :data:: Hash/String - the data to pass to the http request
+    # :follow_redirects:: Integer/Bool - number of times to follow redirects
+    # :headers:: Hash - extra headers to pass to the request
+    # :http_method:: Symbol - the http method to use; defaults to :get
+    #
+    # TODO: Log request speed.
+
+    def self.retrieve query, options={}
+      resp =
+        if !local?(query)
+          retrieve_uri query, options
+        else
+          retrieve_file query, options
+        end
+
+      begin
+        File.open(options[:cache_response], "w+") do |file|
+          file.write resp.raw
+        end if options[:cache_response]
+      rescue => e
+        $stderr << "#{e.class}: #{e.message}"
+      end
+
+      resp
+    rescue SocketError, Errno::ENOENT
+      raise NotFoundError, "#{query} could not be found"
+    end
+
+
+    ##
+    # Check if a URI should be treated as a local file.
+
+    def self.local? uri
+      !(uri =~ %r{^\w+://})
+    end
+
+
+    ##
+    # Read http response from a file and return a HTTPResponse instance.
+
+    def self.retrieve_file path, options={}
+      options = options.dup
+
+      path = Kronk::DEFAULT_CACHE_FILE if path == :cache
+      resp = nil
+
+      File.open(path, "r") do |file|
+        begin
+          resp = Response.read_new file
+
+        rescue Net::HTTPBadResponse
+          file.rewind
+          resp = HeadlessResponse.new file.read
+          resp['Content-Type'] = File.extname path
+        end
+      end
+
+      resp = follow_redirect resp, options if
+        follow_redirect? resp, options[:follow_redirects]
+
+      resp
+    end
+
+
+    ##
+    # 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
+    # :follow_redirects:: Integer/Bool - number of times to follow redirects
+    # :headers:: Hash - extra headers to pass to the request
+    # :http_method:: Symbol - the http method to use; defaults to :get
+    #
+    # Note: if no http method is specified and data is given, will default
+    # to using a post request.
+
+    def self.retrieve_uri uri, options={}
+      options     = options.dup
+      http_method = options.delete(:http_method)
+      http_method ||= options[:data] ? :post : :get
+
+      resp = self.call http_method, uri, options
+
+      resp = follow_redirect resp, options if
+        follow_redirect? resp, options[:follow_redirects]
+
+      resp
+    end
+
+
+    ##
+    # 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
+    # :follow_redirects:: Integer/Bool - number of times to follow redirects
+    # :headers:: Hash - extra headers to pass to the request
+    # :http_method:: Symbol - the http method to use; defaults to :get
+
+    def self.call http_method, uri, options={}
+      suffix = options.delete :uri_suffix
+
+      uri    = "#{uri}#{suffix}" if suffix
+      uri    = URI.parse uri unless URI === uri
+
+      data   = options[:data]
+      data &&= Hash === data ? build_query(data) : data.to_s
+
+      socket = socket_io = nil
+
+      resp = Net::HTTP.start uri.host, uri.port do |http|
+        socket = http.instance_variable_get "@socket"
+        socket.debug_output = socket_io = StringIO.new
+
+        http.send_request http_method.to_s.upcase,
+                          uri.request_uri,
+                          data,
+                          options[:headers]
+      end
+
+      resp.extend Response::Helpers
+
+      r_req, r_resp, r_bytes = Response.read_raw_from socket_io
+      resp.instance_variable_set "@raw", r_resp
+
+      resp
+    end
+
+
+    ##
+    # Creates a query string from data.
+
+    def self.build_query data, param=nil
+      raise ArgumentError,
+        "Can't convert #{data.class} to query without a param name" unless
+          Hash === data || param
+
+      case data
+      when Array
+        out = data.map do |value|
+          key = "#{param}[]"
+          build_query value, key
+        end
+
+        out.join "&"
+
+      when Hash
+        out = data.sort.map do |key, value|
+          key = param.nil? ? key : "#{param}[#{key}]"
+          build_query value, key
+        end
+
+        out.join "&"
+
+      else
+        "#{param}=#{data}"
+      end
+    end
+  end
+end

data/lib/kronk/response.rb

@@ -0,0 +1,226 @@
+class Kronk
+
+  ##
+  # Wrapper to add a few niceties to the Net::HTTPResponse class.
+
+  class Response < Net::HTTPResponse
+
+    class MissingParser < Exception; end
+
+    ##
+    # Create a new Response instance from an IO object.
+
+    def self.read_new io
+      io = Net::BufferedIO.new io unless Net::BufferedIO === io
+      io.debug_output = socket_io = StringIO.new
+
+      begin
+        resp = super io
+        resp.reading_body io, true do;end
+      rescue EOFError
+      end
+
+      resp.extend Helpers
+
+      r_req, r_resp, r_bytes = read_raw_from socket_io
+      resp.instance_variable_set "@raw", r_resp
+      resp.instance_variable_set "@read", true
+      resp.instance_variable_set "@socket", true
+
+      resp.instance_variable_set "@body", resp.raw.split("\r\n\r\n",2)[1] if
+        !resp.body
+
+      resp
+    end
+
+
+    ##
+    # Read the raw response from a debug_output instance and return an array
+    # containing the raw request, response, and number of bytes received.
+
+    def self.read_raw_from debug_io
+      req = nil
+      resp = ""
+      bytes = nil
+
+      debug_io.rewind
+      output = debug_io.read.split "\n"
+
+      if output.first =~ %r{<-\s(.*)}
+        req = instance_eval $1
+        output.delete_at 0
+      end
+
+      if output.last =~ %r{read (\d+) bytes}
+        bytes = $1.to_i
+        output.delete_at(-1)
+      end
+
+      output.map do |line|
+        next unless line[0..2] == "-> "
+        resp << instance_eval(line[2..-1])
+      end
+
+      [req, resp, bytes]
+    end
+
+
+    ##
+    # Helper methods for Net::HTTPResponse objects.
+
+    module Helpers
+
+      ##
+      # Returns the raw http response.
+
+      def raw
+        @raw
+      end
+
+
+      ##
+      # Returns the body data parsed according to the content type.
+      # If no parser is given will look for the default parser based on
+      # the Content-Type, or will return the cached parsed body if available.
+
+      def parsed_body parser=nil
+        return @parsed_body if @parsed_body && !parser
+        parser ||= Kronk.parser_for self['Content-Type']
+
+        raise MissingParser,
+          "No parser for Content-Type: #{self['Content-Type']}" unless parser
+
+        @parsed_body = parser.parse self.body
+      end
+
+
+      ##
+      # Returns the parsed header hash.
+
+      def parsed_header include_headers=true
+        headers = self.to_hash.dup
+
+        case include_headers
+        when nil, false
+          nil
+
+        when Array, String
+          include_headers = [*include_headers].map{|h| h.to_s.downcase}
+
+          headers.each do |key, value|
+            headers.delete key unless
+              include_headers.include? key.to_s.downcase
+          end
+
+          headers
+
+        when true
+          headers
+        end
+      end
+
+
+      ##
+      # Returns the header portion of the raw http response.
+
+      def raw_header include_headers=true
+        headers = "#{raw.split("\r\n\r\n", 2)[0]}\r\n"
+
+        case include_headers
+        when nil, false
+          nil
+
+        when Array, String
+          includes = [*include_headers].join("|")
+          headers.scan(%r{^((?:#{includes}): [^\n]*\n)}im).flatten.join
+
+        when true
+          headers
+        end
+      end
+
+
+      ##
+      # Returns the raw response with selective headers and/or the body of
+      # the response. Supports the following options:
+      # :no_body:: Bool - Don't return the body; default nil
+      # :with_headers:: Bool/String/Array - Return headers; default nil
+
+      def selective_string options={}
+        str = self.body unless options[:no_body]
+
+        if options[:with_headers]
+          header = raw_header(options[:with_headers])
+          str = [header, str].compact.join "\r\n"
+        end
+
+        str
+      end
+
+
+      ##
+      # Returns the parsed response with selective headers and/or the body of
+      # the response. Supports the following options:
+      # :no_body:: Bool - Don't return the body; default nil
+      # :with_headers:: Bool/String/Array - Return headers; default nil
+      # :ignore_data:: String/Array - Removes the data from given data paths
+      # :only_data:: String/Array - Extracts the data from given data paths
+
+      def selective_data options={}
+        data = nil
+
+        unless options[:no_body]
+          ds = DataSet.new parsed_body
+
+          ds.collect_data_points options[:only_data]  if options[:only_data]
+          ds.delete_data_points options[:ignore_data] if options[:ignore_data]
+
+          data = ds.data
+        end
+
+        if options[:with_headers]
+          data = [parsed_header(options[:with_headers]), data].compact
+        end
+
+        data
+      end
+    end
+  end
+
+
+  ##
+  # Mock response object without a header for body-only http responses.
+
+  class HeadlessResponse
+
+    include Response::Helpers
+
+    attr_accessor :body, :code
+
+    def initialize body
+      @body = body
+      @raw  = body
+      @header = {}
+    end
+
+
+    ##
+    # Interface method only. Returns nil for all but content type.
+
+    def [] key
+      @header[key]
+    end
+
+    def []= key, value
+      @header[key] = value
+    end
+
+
+    ##
+    # Interface method only. Returns empty hash.
+
+    def to_hash
+      Hash.new
+    end
+  end
+end

data/lib/kronk/xml_parser.rb

@@ -0,0 +1,108 @@
+class Kronk
+
+  ##
+  # Wrapper class for Nokogiri parser.
+
+  class XMLParser
+
+    ##
+    # Takes an xml string and returns a data hash.
+    # Ignores blank spaces between tags.
+
+    def self.parse str
+      root_node = Nokogiri.XML str do |config|
+        config.default_xml.noblanks
+      end
+
+      hash = node_value root_node.children
+      hash.values.first
+    end
+
+
+    ##
+    # Build a hash from a nokogiri xml node.
+
+    def self.node_value xml_node, as_array=false
+      case xml_node
+      when Nokogiri::XML::Text    then xml_node.text
+
+      # Returns hash or array
+      when Nokogiri::XML::NodeSet then node_set_value(xml_node, as_array)
+
+      # Returns node name and value
+      when Nokogiri::XML::Element then element_node_value(xml_node)
+      end
+    end
+
+
+    ##
+    # Returns the value for an xml node set.
+    # Can be a Hash, Array, or String
+
+    def self.node_set_value xml_node, as_array=false
+      orig = {}
+      data = as_array ? Array.new : Hash.new
+
+      xml_node.each do |node|
+        node_data, name = node_value node
+        return node_data unless name
+
+        case data
+        when Array
+          data << node_data
+        when Hash
+          orig[name] ||= node_data
+
+          if data.has_key?(name)
+            data[name] = [data[name]] if data[name] == orig[name]
+            data[name] << node_data
+          else
+            data[name] = node_data
+          end
+        end
+      end
+
+      data
+    end
+
+
+    ##
+    # Returns an Array containing the value of an element node
+    # and its name.
+
+    def self.element_node_value xml_node
+      name     = xml_node.name
+      datatype = xml_node.attr :type
+      is_array = array? xml_node.children, name
+      data     = node_value xml_node.children, is_array
+
+      data = case datatype
+             when 'array'   then data.to_a
+             when 'symbol'  then data.to_sym
+             when 'integer' then data.to_i
+             when 'float'   then data.to_f
+             when 'boolean'
+               data == 'true' ? true : false
+             else
+               data
+             end
+
+      [data, name]
+    end
+
+
+    ##
+    # Checks if a given node set should be interpreted as an Array.
+
+    def self.array? node_set, parent_name=nil
+      names = node_set.map do |n|
+        return unless Nokogiri::XML::Element === n
+        n.name
+      end
+
+      names.uniq.length == 1 && (names.length > 1 ||
+      parent_name && (names.first == parent_name ||
+      names.first.pluralize == parent_name))
+    end
+  end
+end