relax 0.0.4 → 0.0.5

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2007 Tyler Hunt
+Copyright (c) 2007-2008 Tyler Hunt
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README

@@ -1,9 +1,10 @@
 = Relax
 
-Relax is a simple library for creating REST consumers.
+Relax is a simple library that provides a foundation for writing REST consumer
+APIs, including the logic to handle the HTTP requests, build URLs with query
+parameters, and parse XML responses.
 
-When used as a basis for writing REST consumer APIs, it provides a set of
-functionality common to all REST consumers, including:
+It provides a basic set of functionality common to most REST consumers:
 
 - building HTTP queries (Relax::Request)
 - issuing HTTP requests (Relax::Service)
@@ -106,8 +107,7 @@ There are three main pieces to every service call module:
 2. a Relax::Response object
 3. a call method that calls Relax::Service#call
 
-This module then gets included into the Service class, where the call method
-can be easily utilized.
+Here's what the PhotoSearch module looks like:
 
   module Flickr
     module PhotoSearch
@@ -137,8 +137,23 @@ can be easily utilized.
 
 As you can see, we have our request (PhotoSearchRequest), response
 (PhotoSearchResponse), and call method (actually, two in this case: search and
- find_by_tag). This will get included into our Flickr::Service class, and we
-can use it by calling either of the call methods.
+ find_by_tag). This now needs to be included into our Flickr::Service class,
+and then we'll be able to use it by calling either of the call methods.
+
+  module Flickr
+    class Service < Relax::Service
+      include Flickr::PhotoSearch
+
+      ENDPOINT = 'http://api.flickr.com/services/rest/'
+      
+      def initialize(api_key)
+        super(ENDPOINT)
+        Request[:api_key] = api_key
+      end
+    end
+  end
+
+Now we're ready to make a call against the API:
 
   flickr = Flickr::Service.new(ENV['FLICKR_API_KEY'])
   relax = flickr.find_by_tag('relax', :per_page => 10)
@@ -151,3 +166,6 @@ can use it by calling either of the call methods.
 
 This will output the IDs and titles for the first 10 photos on Flickr that have
 the tag "relax."
+
+
+Copyright (c) 2007-2008 Tyler Hunt, released under the MIT license

data/lib/relax.rb

@@ -1,6 +1,7 @@
 $:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
 require 'relax/query'
+require 'relax/parsers'
 require 'relax/request'
 require 'relax/response'
 require 'relax/service'
@@ -8,4 +9,5 @@ require 'relax/symbolic_hash'
 
 module Relax
   class MissingParameter < ArgumentError ; end
+  class UnrecognizedParser < ArgumentError ; end
 end

data/lib/relax/parsers.rb

@@ -0,0 +1,13 @@
+require 'date'
+require 'time'
+
+require 'relax/parsers/factory'
+require 'relax/parsers/base'
+
+require 'relax/parsers/hpricot'
+require 'relax/parsers/rexml'
+
+module Relax
+  module Parsers
+  end
+end

data/lib/relax/parsers/base.rb

@@ -0,0 +1,34 @@
+module Relax
+  module Parsers
+    
+    class Base
+      
+      attr_reader :parent
+      attr_reader :parameters
+      
+      def initialize(raw, parent)
+        @parent     = parent
+        @parameters = parent.class.instance_variable_get('@parameters')
+        parse!
+      end
+      
+      def parse!; end
+      
+      def root; end
+      def is?(name); end
+      def has?(name); end
+      def element(name); end
+      def elements(name); end
+      
+      def attribute(element, name); end
+      def value(value); end
+      def text_value(value); end
+      def integer_value(value); end
+      def float_value(value); end
+      def date_value(value); end
+      def time_value(value); end
+      
+    end
+    
+  end
+end

data/lib/relax/parsers/factory.rb

@@ -0,0 +1,43 @@
+module Relax
+  module Parsers
+    
+    ##
+    # Manages the Relax::Parsers in the library.
+    # 
+    module Factory
+      
+      class << self
+        
+        ##
+        # Returns the parser class which has been registered for the given 
+        # +name+.
+        # 
+        def get(name)
+          @@parsers ||= {}
+          @@parsers[name] || raise(UnrecognizedParser, "Given parser name not recognized: #{name.inspect}.  Expected one of: #{@@parsers.keys.inspect}")
+        end
+        
+        ##
+        # Registers a new parser with the factory.  The +name+ should be unique,
+        # but if not, it will override the previously defined parser for the
+        # given +name+.
+        # 
+        def register(name, klass)
+          @@parsers ||= {}
+          @@parsers[:default] = klass if @@parsers.empty?
+          @@parsers[name] = klass
+        end
+        
+        ##
+        # Removes all registered parsers from the factory.
+        # 
+        def clear!
+          @@parsers = {}
+        end
+        
+      end
+      
+    end
+    
+  end
+end

data/lib/relax/parsers/hpricot.rb

@@ -0,0 +1,145 @@
+require 'rubygems'
+require 'hpricot'
+
+module Relax
+  module Parsers
+    
+    ##
+    # Parses the server's raw response using the Hpricot library.
+    # 
+    class Hpricot < Base
+      
+      FACTORY_NAME = :hpricot
+      
+      def initialize(raw, parent)
+        @xml = ::Hpricot.XML(raw)
+        super(raw, parent)
+      end
+      
+      def parse!
+        if parameters
+          parameters.each do |parameter, options|
+            begin
+              element = options[:element] || parameter
+
+              if attribute = options[:attribute] and attribute == true
+                node = attribute(root, element)
+              elsif attribute
+                node = attribute(element(element), attribute)
+              elsif options[:collection]
+                node = elements(element)
+              else
+                node = element(element)
+              end
+
+              if options[:collection]
+                value = node.collect do |element|
+                  options[:collection].new(element)
+                end
+              else
+                case type = options[:type]
+                  when Response
+                    value = type.new(node)
+
+                  when :date
+                    value = date_value(node)
+
+                  when :time
+                    value = time_value(node)
+
+                  when :float
+                    value = float_value(node)
+
+                  when :integer
+                    value = integer_value(node)
+
+                  when :text
+                  else
+                    value = text_value(node)
+                end
+              end
+
+              parent.instance_variable_set("@#{parameter}", value)
+            rescue ::Hpricot::Error
+              raise Relax::MissingParameter if options[:required]
+            end
+          end
+        end
+      end
+      
+      # Returns the root of the XML document.
+      def root
+        @xml.root
+      end
+      
+      # Checks the name of the root node.
+      def is?(name)
+        root.name.gsub(/.*:(.*)/, '\1') == node_name(name)
+      end
+      
+      # Returns a set of elements matching name.
+      def elements(name)
+        root.search(root_path(name))
+      end
+      
+      # Returns an element of the specified name.
+      def element(name)
+        root.at(root_path(name))
+      end
+      alias :has? :element
+      
+      # Returns an attribute on an element.
+      def attribute(element, name)
+        element[name]
+      end
+
+      # Gets the value of an element or attribute.
+      def value(value)
+        value.is_a?(::Hpricot::Elem) ? value.inner_text : value.to_s
+      end
+      
+      # Gets a text value.
+      def text_value(value)
+        value(value)
+      end
+
+      # Gets an integer value.
+      def integer_value(value)
+        value(value).to_i
+      end
+
+      # Gets a float value.
+      def float_value(value)
+        value(value).to_f
+      end
+
+      # Gets a date value.
+      def date_value(value)
+        Date.parse(value(value))
+      end
+
+      # Gets a time value.
+      def time_value(value)
+        Time.parse(value(value))
+      end
+      
+      
+      private
+      
+      
+      # Converts a name to a node name.
+      def node_name(name)
+        name.to_s
+      end
+
+      # Gets the XPath expression representing the root node.
+      def root_path(name)
+        "/#{node_name(name)}"
+      end
+      
+    end
+    
+    Factory.register(Hpricot::FACTORY_NAME, Hpricot)
+    
+  end
+end

data/lib/relax/parsers/rexml.rb

@@ -0,0 +1,158 @@
+require 'rubygems'
+require 'rexml/document'
+
+module Relax
+  module Parsers
+    
+    ##
+    # Parsers the server's response using the REXML library.
+    # 
+    # Benefits:
+    #
+    # * XML Namespace support (parameter :foo, :namespace => 'bar')
+    # 
+    # Drawbacks:
+    #
+    # * Case sensitive field names (<Status>..</> != parameter :status)
+    # 
+    class REXML < Base
+      
+      FACTORY_NAME = :rexml
+      
+      def initialize(raw, parent)
+        @xml = ::REXML::Document.new(raw)
+        super(raw, parent)
+      end
+      
+      def parse!
+        if parameters
+          parameters.each do |parameter, options|
+            begin
+              element = options[:element] || parameter
+              namespace = options[:namespace]
+            
+              if attribute = options[:attribute] and attribute == true
+                node = attribute(root, element, namespace)
+              elsif attribute
+                node = attribute(element(element), attribute, namespace)
+              elsif options[:collection]
+                node = elements(element, namespace)
+              else
+                node = element(element, namespace)
+              end
+              
+              if options[:collection]
+                value = node.collect do |element|
+                  options[:collection].new(element.deep_clone)
+                end
+              else
+                case type = options[:type]
+                  when Response
+                    value = type.new(node)
+            
+                  when :date
+                    value = date_value(node)
+            
+                  when :time
+                    value = time_value(node)
+            
+                  when :float
+                    value = float_value(node)
+            
+                  when :integer
+                    value = integer_value(node)
+            
+                  when :text
+                  else
+                    value = text_value(node)
+                end
+              end
+            
+              parent.instance_variable_set("@#{parameter}", value)
+            rescue
+              raise(Relax::MissingParameter) if node.nil? && options[:required]
+            end
+          end
+        end
+      end
+      
+      # Returns the root of the XML document.
+      def root
+        @xml.root
+      end
+      
+      # Checks the name of the root node.
+      def is?(name, namespace = nil)
+        root.name == node_name(name, nil)
+      end
+      
+      # Returns a set of elements matching name.
+      def elements(name, namespace = nil)
+        root.get_elements(node_path(name, namespace))
+      end
+      
+      # Returns an element of the specified name.
+      def element(name, namespace = nil)
+        root.elements[node_path(name, namespace)]
+      end
+      alias :has? :element
+      
+      # Returns an attribute on an element.
+      def attribute(element, name, namespace = nil)
+        element.attribute(name)
+      end
+
+      # Gets the value of an element or attribute.
+      def value(value)
+        value.is_a?(::REXML::Element) ? value.text : value.to_s
+      end
+      
+      # Gets a text value.
+      def text_value(value)
+        value(value)
+      end
+
+      # Gets an integer value.
+      def integer_value(value)
+        value(value).to_i
+      end
+
+      # Gets a float value.
+      def float_value(value)
+        value(value).to_f
+      end
+
+      # Gets a date value.
+      def date_value(value)
+        Date.parse(value(value))
+      end
+
+      # Gets a time value.
+      def time_value(value)
+        Time.parse(value(value))
+      end
+      
+      
+      private
+      
+      
+      # Converts a name to a node name.
+      def node_name(name, namespace = nil)
+        "#{namespace.to_s + ':' if namespace}#{name}"
+      end
+
+      # Gets the XPath expression representing the root node.
+      def root_path(name)
+        "/#{node_name(name)}"
+      end
+      
+      def node_path(name, namespace = nil)
+        "#{node_name(name, namespace)}"
+      end
+      
+    end
+    
+    Factory.register(REXML::FACTORY_NAME, REXML)
+    
+  end
+end

data/lib/relax/query.rb

@@ -1,4 +1,4 @@
-require 'erb'
+require 'cgi'
 require 'uri'
 
 require 'relax/symbolic_hash'
@@ -18,8 +18,8 @@ module Relax
       # Parses a URL and returns a Query with its query portion.
       def parse(uri)
         query = uri.query.split('&').inject({}) do |query, parameter|
-          key, value = parameter.split('=')
-          query[key] = unescape_value(value)
+          key, value = parameter.split('=', 2)
+          query[unescape_value(key)] = unescape_value(value)
           query
         end
         self.new(query)
@@ -27,12 +27,12 @@ module Relax
 
       # Escapes a query parameter value.
       def escape_value(value)
-        ERB::Util.url_encode(value.to_s).gsub('%20', '+')
+        CGI.escape(value.to_s).gsub('%20', '+')
       end
 
       # Unescapes a query parameter value.
       def unescape_value(value)
-        URI.unescape(value)
+        CGI.unescape(value)
       end
     end
 

data/lib/relax/request.rb

@@ -57,7 +57,7 @@ module Relax
     # the parameter name separated by two underscores. This method can be
     # overridden by child classes.
     def convert_complex_key(key, parameter)
-      "#{key}.#{parameter}"
+      "#{convert_key(key)}.#{convert_key(parameter)}"
     end
     protected :convert_complex_key
 

data/lib/relax/response.rb

@@ -1,8 +1,3 @@
-require 'rubygems'
-require 'hpricot'
-
-require 'date'
-
 module Relax
   # Response is intended to be a parent class for responses passed to
   # Service#call.
@@ -12,122 +7,26 @@ module Relax
   # #element and #attribute.
   class Response
     attr_accessor :raw
-    attr_accessor :xml
-
-    # New takes in the XML from the response. For the initial response, this
-    # will be the root element, but child elements may also be passed into
-    # Response objects.
+    
+    # New takes in and parses the raw response.
     #
     # This will raise a MissingParameter error if a parameterd marked as
-    # required is not present in the XML response.
+    # required is not present in the parsed response.
     def initialize(xml)
-      @raw = xml
-      @xml = Hpricot.XML(xml.to_s)
-
-      if parameters = self.class.instance_variable_get('@parameters')
-        parameters.each do |parameter, options|
-          begin
-            element = options[:element] || parameter
-
-            if attribute = options[:attribute] and attribute == true
-              node = attribute(root, element)
-            elsif attribute
-              node = attribute(element(element), attribute)
-            elsif options[:collection]
-              node = elements(element)
-            else
-              node = element(element)
-            end
-
-            if options[:collection]
-              value = node.collect do |element|
-                options[:collection].new(element)
-              end
-            else
-              case type = options[:type]
-                when Response
-                  value = type.new(node)
-
-                when :date
-                  value = date_value(node)
-
-                when :time
-                  value = time_value(node)
-
-                when :float
-                  value = float_value(node)
-
-                when :integer
-                  value = integer_value(node)
-
-                when :text
-                else
-                  value = text_value(node)
-              end
-            end
-
-            instance_variable_set("@#{parameter}", value)
-          rescue Hpricot::Error
-            raise MissingParameter if options[:required]
-          end
-        end
-      end
-    end
-
-    # Returns the root of the XML document.
-    def root
-      @xml.root
+      @raw    = xml
+      @parser = Relax::Parsers::Factory.get(parser_name).new(xml.to_s, self)
     end
-
-    # Checks the name of the root node.
-    def is?(name)
-      root.name.gsub(/.*:(.*)/, '\1') == node_name(name)
-    end
-
-    # Returns an element of the specified name.
-    def element(name)
-      root.at(root_path(name))
-    end
-    alias :has? :element
-
-    # Returns an attribute on an element.
-    def attribute(element, name)
-      element[name]
+    
+    def parser_name
+      self.class.instance_variable_get('@parser') || :default
     end
-
-    # Returns a set of elements matching name.
-    def elements(name)
-      root.search(root_path(name))
-    end
-
-    # Gets the value of an element or attribute.
-    def value(value)
-      value.is_a?(Hpricot::Elem) ? value.inner_text : value.to_s
-    end
-
-    # Gets a text value.
-    def text_value(value)
-      value(value)
-    end
-
-    # Gets an integer value.
-    def integer_value(value)
-      value(value).to_i
-    end
-
-    # Gets a float value.
-    def float_value(value)
-      value(value).to_f
-    end
-
-    # Gets a date value.
-    def date_value(value)
-      Date.parse(value(value))
-    end
-
-    # Gets a time value.
-    def time_value(value)
-      Time.parse(value(value))
+    
+    def method_missing(method, *args) #:nodoc:
+      if @parser.respond_to?(method)
+        @parser.__send__(method, *args)
+      else
+        super
+      end
     end
 
     class << self
@@ -140,6 +39,7 @@ module Relax
         @parameters.each do |name, options|
           subclass.parameter(name, options)
         end if @parameters
+        subclass.parser(@parser) if @parser
       end
 
       # Specifes a parameter that will be automatically parsed when the
@@ -159,22 +59,20 @@ module Relax
         @parameters ||= {}
         @parameters[name] = options
       end
+      
+      # Specifies the parser to use when decoding the server response.  If 
+      # no parser is specified for the response, then the default parser will
+      # be used.
+      # 
+      # See Relax::Parsers for a list of available parsers.
+      def parser(name)
+        @parser ||= name
+      end
 
       def ===(response)
         response.is_a?(Class) ? response.ancestors.include?(self) : super
       end
     end
 
-    private
-
-    # Converts a name to a node name.
-    def node_name(name)
-      name.to_s
-    end
-
-    # Gets the XPath expression representing the root node.
-    def root_path(name)
-      "/#{node_name(name)}"
-    end
   end
 end

data/spec/parsers/factory_spec.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require 'relax'
+require 'relax/parsers/factory'
+
+class TestParser ; end
+
+describe 'a parser factory' do
+  
+  before(:each) do
+    @factory = Relax::Parsers::Factory
+    Relax::Parsers::Factory.register(:test, TestParser)
+  end
+  
+  it 'should raise UnrecognizedParser for un-registered names' do
+    lambda {
+      @factory.get(:bad_name)
+    }.should raise_error(Relax::UnrecognizedParser)
+  end
+  
+  it 'should return a registered parser class' do
+    @factory.get(:test).should ==TestParser
+  end
+  
+  it 'should register the first registered parser as the default' do
+    @factory.get(:default).should ==Relax::Parsers::Hpricot
+  end
+  
+end

data/spec/parsers/hpricot_spec.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/../parser_helper'
+
+
+class HpricotTestResponse < Relax::Response
+  class Token < Relax::Response
+    parser :hpricot
+    parameter :token_id, :element => :tokenid
+    parameter :status
+  end
+
+  class Error < Relax::Response
+    parser :hpricot
+    parameter :code, :type => :integer
+    parameter :message
+  end
+  
+  parser :hpricot
+  parameter :status, :required => true
+  parameter :request_id, :element => :requestid, :type => :integer
+  parameter :valid_request, :element => :requestid, :attribute => :valid
+  parameter :tokens, :collection => Token
+  parameter :error, :type => Error
+end
+
+
+describe 'an Hpricot parser' do
+  
+  before(:each) do
+    @response = HpricotTestResponse.new(XML)
+  end
+  
+  it_should_behave_like 'a successfully parsed response'
+  
+end

data/spec/parsers/rexml_spec.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+require File.dirname(__FILE__) + '/../parser_helper'
+
+
+class RexmlTestResponse < Relax::Response
+  class Token < Relax::Response
+    parser :rexml
+    parameter :token_id,  :element => 'TokenId'
+    parameter :status,    :element => 'Status'
+  end
+  
+  class Error < Relax::Response
+    parser :rexml
+    parameter :code,      :element => 'Code',         :type => :integer
+    parameter :message,   :element => 'Message'
+  end
+  
+  parser :rexml
+  parameter :status,        :element => 'Status',     :required => true
+  parameter :request_id,    :element => 'RequestId',  :type => :integer
+  parameter :valid_request, :element => 'RequestId',  :attribute => :valid
+  parameter :namespace,     :element => 'Namespace',  :namespace => 'ns1'
+  parameter :tokens,        :element => 'Tokens',     :collection => Token
+  parameter :error,         :element => 'Error',      :type => Error
+end
+
+
+describe 'a REXML parser' do
+  
+  before(:each) do
+    @response = RexmlTestResponse.new(XML)
+  end
+  
+  it_should_behave_like 'a successfully parsed response'
+  
+  it 'should parse namespaced parameters' do
+    @response.namespace.should eql('Passed')
+  end
+  
+end

data/spec/query_spec.rb

@@ -23,7 +23,7 @@ describe 'a query' do
   it 'should escape its values using "+" instead of "%20"' do
     Relax::Query.send(:escape_value, 'two words').should == 'two+words'
   end
-
+  
   it 'should sort its parameters' do
     @query[:charlie] = 3
     @query[:alpha] = 1
@@ -42,4 +42,19 @@ describe 'a query' do
     parsed_query[:action].should eql('search')
     parsed_query[:query].should eql('keyword')
   end
+  
+  it 'should parse key value pairs into only two parts' do
+    parsed_query = Relax::Query.parse(URI.parse("http://example.com/?action=test=&foo=bar"))
+    parsed_query[:action].should eql('test=')
+  end
+  
+  it 'should unescape query string key-value pair keys' do
+    parsed_query = Relax::Query.parse(URI.parse("http://example.com/?action%20helper=test"))
+    parsed_query[:"action helper"].should eql('test')
+  end
+  
+  it 'should unescape query string key-value pair values' do
+    parsed_query = Relax::Query.parse(URI.parse("http://example.com/?action=test%20action"))
+    parsed_query[:action].should eql('test action')
+  end
 end

data/spec/response_spec.rb

@@ -1,26 +1,5 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
-require 'relax/response'
-
-XML = <<EOF
-<?xml version="1.0"?>
-<RESTResponse>
-  <Tokens>
-    <TokenId>JPMQARDVJK</TokenId>
-    <Status>Active</Status>
-  </Tokens>
-  <Tokens>
-    <TokenId>RDVJKJPMQA</TokenId>
-    <Status>Inactive</Status>
-  </Tokens>
-  <Status>Success</Status>
-  <RequestId valid="true">44287</RequestId>
-  <Error>
-    <Code>1</Code>
-    <Message>Failed</Message>
-  </Error>
-</RESTResponse>
-EOF
 
 class BaseResponse < Relax::Response
   parameter :status, :required => true
@@ -34,6 +13,7 @@ class TestResponse < BaseResponse
   end
 
   class Error < Relax::Response
+    parser :hpricot
     parameter :code, :type => :integer
     parameter :message
   end
@@ -43,6 +23,7 @@ class TestResponse < BaseResponse
   parameter :error, :type => Error
 end
 
+
 describe 'a response' do
   before(:each) do
     @response = Relax::Response.new(XML)
@@ -106,4 +87,12 @@ describe 'a response' do
   it 'should raise MissingParameter if required parameters are missing' do
     proc { TestResponse.new('') }.should raise_error(Relax::MissingParameter)
   end
+  
+  it 'should use the default parser when undefined' do
+    TestResponse::Token.new('').parser_name.should ==:default
+  end
+  
+  it 'should use the defined parser when given' do
+    TestResponse::Error.new('').parser_name.should ==:hpricot
+  end
 end

metadata

@@ -1,66 +1,90 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.4
-specification_version: 1
 name: relax
 version: !ruby/object:Gem::Version 
-  version: 0.0.4
-date: 2007-11-17 00:00:00 -05:00
-summary: A simple library for creating REST consumers.
-require_paths: 
-- lib
-email: tyler@protoh.com
-homepage: http://protoh.com/
-rubyforge_project: 
-description: 
-autorequire: relax
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-  - - ">"
-    - !ruby/object:Gem::Version 
-      version: 0.0.0
-  version: 
+  version: 0.0.5
 platform: ruby
-signing_key: 
-cert_chain: 
-post_install_message: 
 authors: 
 - Tyler Hunt
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-10-20 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hpricot
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.6"
+    version: 
+description: 
+email: tyler@tylerhunt.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
 files: 
 - lib/relax
+- lib/relax/parsers
+- lib/relax/parsers/base.rb
+- lib/relax/parsers/factory.rb
+- lib/relax/parsers/hpricot.rb
+- lib/relax/parsers/rexml.rb
+- lib/relax/parsers.rb
 - lib/relax/query.rb
 - lib/relax/request.rb
 - lib/relax/response.rb
 - lib/relax/service.rb
 - lib/relax/symbolic_hash.rb
 - lib/relax.rb
-- README
-- LICENSE
-test_files: 
+- spec/parsers/factory_spec.rb
+- spec/parsers/hpricot_spec.rb
+- spec/parsers/rexml_spec.rb
 - spec/query_spec.rb
 - spec/request_spec.rb
 - spec/response_spec.rb
 - spec/symbolic_hash_spec.rb
-rdoc_options: []
-
-extra_rdoc_files: 
 - README
 - LICENSE
-executables: []
-
-extensions: []
+has_rdoc: true
+homepage: http://tylerhunt.com/
+post_install_message: 
+rdoc_options: []
 
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
 requirements: []
 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: hpricot
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Version::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0.6"
-    version: 
+rubyforge_project: relax
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A simple library for creating REST consumers.
+test_files: 
+- spec/parsers/factory_spec.rb
+- spec/parsers/hpricot_spec.rb
+- spec/parsers/rexml_spec.rb
+- spec/query_spec.rb
+- spec/request_spec.rb
+- spec/response_spec.rb
+- spec/symbolic_hash_spec.rb