partigirb 0.2.7 → 0.3.0

data/README.markdown

@@ -12,23 +12,35 @@ There is also a [complete documentation of the API](http://partigi.pbworks.com/)
 
 ## Install
 
+    gem install oauth
     gem install partigirb -s http://gemcutter.org
 
 ## Usage
 
 ### Creating a client
 
-#### Without Authentication
+Since Partigi started to require OAuth in all its API requests they support two authorization modes: the common OAuth specification ([http://oauth.net/core/1.0a/](http://oauth.net/core/1.0a/)) for read-write access and OAuth with a slightly modification for read-only access, which just consists of skiping the oauth_token when signing the requests.
 
-    client = Partigirb::Client.new
+Regardless of the access method used you will need to register your application and get a `consumer_key` and a `consumer_secret`, used in both access methods. ([http://www.partigi.com/applications](http://www.partigi.com/applications))
 
-#### With Authentication
+#### Read-only access
 
-    client = Partigirb::Client.new(:auth => {:login => 'SOMEUSERLOGIN', :api_secret => 'SECRETGENERATEDFORTHEUSER'})
-  
-#### With specific API version
-  
-    client = Partigirb::Client.new(:api_version => 2)
+    client = Partigirb::Client.new('consumer_key', 'consumer_secret')
+
+#### Read-write access
+
+    client = Partigirb::Client.new('consumer_key', 'consumer_secret')
+    client.set_callback_url('http://myapplication.test/partigi')
+    request_token = client.request_token
+    
+    # At this point we must redirect the user to Partigi so he can authorize our application to access
+    # his profile, we can get the authorization url with request_token.authorize_url
+    
+    # Once we are back Partigi will give us the parameter oauth_verifier, which we will use
+    # to get the access token
+    client.authorize_from_request(request_token.token, request_token.secret, oauth_verifier)
+    
+    # Now our client is fully authorized to call write methods for the user
   
 ### Request methods
 
@@ -100,6 +112,12 @@ There are two special cases to be aware of in regard to PartigiStruct:
 
 In case Partigi returns an error response, this is turned into a PartigiError object which message attribute is set to the error string returned in the XML response.
 
+### Verifying our credentials
+
+A way to check if our client is correctly authorized for write access or to just get the current user's information is by using the verify_credentials method, which will return either the PartigiStruct object with user's information or a PartigiError object in case of authorization failure.
+
+    client.verify_credentials
+
 ## Requirements
 
 - json

data/VERSION

@@ -1 +1 @@
-0.2.7
+0.3.0

data/examples/last_reviews_summary.rb

@@ -1,5 +1,8 @@
 require File.dirname(__FILE__) + '/../lib/partigirb'
 
+CONSUMER_KEY = "your_consumer_key"
+CONSUMER_SECRET = "your_consumer_secret"
+
 if ARGV.empty?
   puts "\nUsage: ruby #{__FILE__} user_id_or_login\n\n"
   exit
@@ -14,15 +17,15 @@ def show_reviews(client, reviews, title)
   puts
   
   reviews.each do |review|
-      film = client.items.show? :id => review.ptItem_id, :type => 'film'
-      puts "- #{film.title}"
+      item = client.items.show? :id => review.ptItem_id, :item_type => review.ptItem_type
+      puts "- #{item.title}"
       puts "  Comment: #{review.content.text}"
       puts
   end
   puts
 end
 
-client = Partigirb::Client.new
+client = Partigirb::Client.new(CONSUMER_KEY, CONSUMER_SECRET)
 
 reviews = client.reviews.index? :user_id => user_id, :per_page => 5, :status => 0, :order => 'desc'
 show_reviews(client, reviews, "Latest 5 films you want to watch")

data/examples/who_ignores_me.rb

@@ -1,5 +1,8 @@
 require File.dirname(__FILE__) + '/../lib/partigirb'
 
+CONSUMER_KEY = "your_consumer_key"
+CONSUMER_SECRET = "your_consumer_secret"
+
 if ARGV.empty?
   puts "\nUsage: #{__FILE__} user_id_or_login\n\n"
   exit
@@ -7,7 +10,7 @@ end
 
 user_id = ARGV.first
 
-client = Partigirb::Client.new
+client = Partigirb::Client.new(CONSUMER_KEY, CONSUMER_SECRET)
 
 traitors = []
 

data/lib/partigirb/client.rb

@@ -46,28 +46,22 @@ module Partigirb
     PARTIGI_API_HOST = "www.partigi.com"
     TIMESTAMP_FORMAT = '%Y-%m-%dT%H:%M:%SZ'
     
-    attr_accessor :default_format, :headers, :api_version, :transport, :request, :api_host, :auth, :handlers
-    
-    def initialize(options={})
-      self.transport = Transport.new
-      self.api_host = PARTIGI_API_HOST.clone
-      self.api_version = options[:api_version] || Partigirb::CURRENT_API_VERSION
-      self.headers = {"User-Agent"=>"Partigirb/#{Partigirb::VERSION}"}.merge!(options[:headers]||{})
-      self.default_format = options[:default_format] || :atom
-      self.handlers = {
+    attr_accessor :consumer_key, :consumer_secret, :default_format, :headers, :api_version, :transport, :request, :api_host, :auth, :handlers, :access_token
+    
+    def initialize(consumer_key, consumer_secret, options={})
+      @consumer = ::OAuth::Consumer.new(consumer_key, consumer_secret, {:site => "http://#{PARTIGI_API_HOST}"})
+      @transport = Transport.new(@consumer)
+      @api_host = PARTIGI_API_HOST.clone
+      @api_version = options[:api_version] || Partigirb::CURRENT_API_VERSION
+      @headers = {"User-Agent"=>"Partigirb/#{Partigirb::VERSION}"}.merge!(options[:headers]||{})
+      @default_format = options[:default_format] || :atom
+      @handlers = {
         :json => Partigirb::Handlers::JSONHandler.new,
         :xml => Partigirb::Handlers::XMLHandler.new,
         :atom => Partigirb::Handlers::AtomHandler.new,
         :unknown => Partigirb::Handlers::StringHandler.new
       }
-      self.handlers.merge!(options[:handlers]||{})
-      
-      # Authentication param should be a hash with keys:
-      # login (required)
-      # api_secret (required)
-      # nonce (optional, would be automatically generated if missing)
-      # timestamp (optional, current timestamp will be automatically used if missing)
-      self.auth = options[:auth]
+      @handlers.merge!(options[:handlers]) if options[:handlers]
     end
     
     def method_missing(name,*args)
@@ -101,6 +95,43 @@ module Partigirb
       @request ||= Request.new(self,api_version)
     end
     
+    # OAuth related methods
+    
+    # Note: If using oauth with a web app, be sure to provide :oauth_callback.
+    def request_token(options={})
+      @request_token ||= consumer.get_request_token(options)
+    end
+    
+    def set_callback_url(url)
+      clear_request_token
+      request_token(:oauth_callback => url)
+    end
+    
+    # For web apps use params[:oauth_verifier], for desktop apps,
+    # use the verifier is the pin that twitter gives users.
+    def authorize_from_request(request_token, request_secret, verifier_or_pin)
+      request_token = OAuth::RequestToken.new(consumer, request_token, request_secret)
+      @access_token = request_token.get_access_token(:oauth_verifier => verifier_or_pin)
+    end
+    
+    def consumer
+      @consumer
+    end
+    
+    def access_token
+      @access_token
+    end
+    
+    def authorize_from_access(token, secret)
+      @access_token = OAuth::AccessToken.new(consumer, token, secret)
+    end
+    
+    # Shortcut methods
+    
+    def verify_credentials
+      account.verify_credentials?
+    end
+    
     protected
     
     def call_with_format(format,params={})
@@ -113,11 +144,9 @@ module Partigirb
     
     def send_request(params)
       begin
-        set_authentication_headers
-        
-        transport.request(
-          request.method, request.url, :headers=>headers, :params=>params
-        )
+        options = {:headers=>headers, :params=>params}
+        options.merge!(:access_token => @access_token) unless @access_token.nil?
+        transport.request(request.method, request.url, options)
       rescue => e
         puts e
       end        
@@ -128,19 +157,15 @@ module Partigirb
       
       begin
         if res.code.to_i != 200
-          handle_error_response(res, Partigirb::Handlers::XMLHandler.new)
+          handle_error_response(res)
         else
           fmt_handler.decode_response(res.body)
         end
       end
     end
     
-    # TODO: Test for errors
-    def handle_error_response(res, handler)
-      # Response for errors is an XML document containing an error tag as a root,
-      # having a text node with error name. As XMLHandler starts building the Struct
-      # on root node the returned value from the handler will always be the error name text.
-      raise PartigiError.new(handler.decode_response(res.body))
+    def handle_error_response(res)
+      raise PartigiError.new(res.body)
     end
     
     def format_invocation?(name)
@@ -151,40 +176,8 @@ module Partigirb
       handlers[format] || handlers[:unknown]
     end
     
-    # Adds the proper WSSE headers if there are the right authentication parameters
-    def set_authentication_headers
-      unless self.auth.nil? || self.auth === Hash || self.auth.empty?
-        auths = self.auth.stringify_keys
-      
-        if auths.has_key?('login') &&  auths.has_key?('api_secret')
-          if !auths['timestamp'].nil?
-            timestamp = case auths['timestamp']
-            when Time
-              auths['timestamp'].strftime(TIMESTAMP_FORMAT)
-            when String
-              auths['timestamp']
-            end
-          else
-            timestamp = Time.now.strftime(TIMESTAMP_FORMAT) if timestamp.nil?
-          end
-        
-          nonce = auths['nonce'] || generate_nonce
-          password_digest = generate_password_digest(nonce, timestamp, auths['login'], auths['api_secret'])
-          headers.merge!({
-            'Authorization' => "WSSE realm=\"#{PARTIGI_API_HOST}\", profile=\"UsernameToken\"",
-            'X-WSSE' => "UsernameToken Username=\"#{auths['login']}\", PasswordDigest=\"#{password_digest}\", Nonce=\"#{nonce}\", Created=\"#{timestamp}\""
-          })
-        end
-      end
-    end
-    
-    def generate_nonce
-      o =  [('a'..'z'),('A'..'Z')].map{|i| i.to_a}.flatten
-      Digest::MD5.hexdigest((0..10).map{o[rand(o.length)]}.join)
-    end
-    
-    def generate_password_digest(nonce, timestamp, login, secret)
-      Base64.encode64(Digest::SHA1.hexdigest("#{nonce}#{timestamp}#{login}#{secret}")).chomp
+    def clear_request_token
+      @request_token = nil
     end
   end
 end

data/lib/partigirb/transport.rb

@@ -13,8 +13,12 @@ module Partigirb
   
   class Transport
     
-    attr_accessor :debug
-  
+    attr_accessor :debug, :consumer
+    
+    def initialize(consumer)
+      @consumer = consumer
+    end
+    
     CRLF = "\r\n"
     
     def req_class(method)
@@ -44,23 +48,25 @@ module Partigirb
     end
     
     def execute_request(method,url,options={})
-      conn = Net::HTTP.new(url.host, url.port)
-      #conn.use_ssl = (url.scheme == 'https')
-      conn.start do |http|
-        req = req_class(method).new(url.request_uri)
-        
-        add_headers(req,options[:headers])
-        if file_param?(options[:params])
-          add_multipart_data(req,options[:params])
-        else
-          add_form_data(req,options[:params])
-        end
-        
-        dump_request(req) if debug
-        res = http.request(req)
-        dump_response(res) if debug
-        res
+      http = Net::HTTP.new(url.host, url.port)
+      
+      req = req_class(method).new(url.request_uri)
+      add_headers(req,options[:headers])
+      if file_param?(options[:params])
+        add_multipart_data(req,options[:params])
+      else
+        add_form_data(req,options[:params])
       end
+      
+      # Sign the request with OAuth
+      # when there is no options[:access_token] the request is signed without oauth_token
+      # so it will be a Partigi OAuth Readonly request
+      req.oauth!(http, @consumer, options[:access_token])
+      
+      dump_request(req) if debug
+      res = http.request(req)
+      dump_response(res) if debug
+      res
     end
 
     def query_string(params)

data/lib/partigirb.rb

@@ -1,5 +1,5 @@
 module Partigirb
-  VERSION='0.1.0'
+  VERSION='0.3.0'
   CURRENT_API_VERSION=1
 end
 
@@ -14,6 +14,7 @@ require 'digest'
 require 'rexml/document'
 require 'mime/types'
 require 'ostruct'
+require 'oauth'
 
 require 'partigirb/core_ext'
 
@@ -23,5 +24,4 @@ require 'partigirb/handlers/json_handler'
 require 'partigirb/handlers/string_handler'
 
 require 'partigirb/transport'
-require 'partigirb/client'
-
+require 'partigirb/client'

data/partigirb.gemspec

@@ -1,15 +1,15 @@
 # Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
 # -*- encoding: utf-8 -*-
 
 Gem::Specification.new do |s|
   s.name = %q{partigirb}
-  s.version = "0.2.7"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Alvaro Bautista", "Fernando Blat"]
-  s.date = %q{2009-10-28}
+  s.date = %q{2010-02-10}
   s.email = ["alvarobp@gmail.com", "ferblape@gmail.com"]
   s.extra_rdoc_files = [
     "LICENSE",
@@ -73,4 +73,3 @@ Gem::Specification.new do |s|
   else
   end
 end
-

data/test/client_test.rb

@@ -88,71 +88,6 @@ class ClientTest < Test::Unit::TestCase
     assert_equal 'header', Net::HTTP.request['Fake']
   end
   
-  should "add authentication headers when login and secret are provided" do
-    @client = new_client(200, '', :auth => {:login => 'auser', :api_secret => 'his_api_secret'})
-    
-    @client.friendships.update! :id => 321
-    
-    assert_not_nil Net::HTTP.request['Authorization']
-    assert_equal "WSSE realm=\"#{Partigirb::Client::PARTIGI_API_HOST}\", profile=\"UsernameToken\"", Net::HTTP.request['Authorization']
-    
-    assert_not_nil Net::HTTP.request['X-WSSE']
-    assert_match /UsernameToken Username="auser", PasswordDigest="[^"]+", Nonce="[^"]+", Created="[^"]+"/, Net::HTTP.request['X-WSSE']
-  end
-  
-  should "not add authentication headers if no auth params are provided" do
-    @client.friendships.update! :id => 321
-    
-    assert_nil Net::HTTP.request['Authorization']
-    assert_nil Net::HTTP.request['X-WSSE']
-  end
-  
-  should "use given nonce for authentication" do
-    @client = new_client(200, '', :auth => {:login => 'auser', :api_secret => 'his_api_secret', :nonce => '123456789101112'})
-    @client.friendships.update! :id => 321
-    
-    assert_equal "WSSE realm=\"#{Partigirb::Client::PARTIGI_API_HOST}\", profile=\"UsernameToken\"", Net::HTTP.request['Authorization']
-    assert_match /UsernameToken Username="auser", PasswordDigest="[^"]+", Nonce="123456789101112", Created="[^"]+"/, Net::HTTP.request['X-WSSE']
-  end
-  
-  should "use given timestamp string for authentication" do
-    @client = new_client(200, '', :auth => {:login => 'auser', :api_secret => 'his_api_secret', :timestamp => '2009-07-15T14:43:07Z'})
-    @client.friendships.update! :id => 321
-    
-    assert_equal "WSSE realm=\"#{Partigirb::Client::PARTIGI_API_HOST}\", profile=\"UsernameToken\"", Net::HTTP.request['Authorization']
-    assert_match /UsernameToken Username="auser", PasswordDigest="[^"]+", Nonce="[^"]+", Created="2009-07-15T14:43:07Z"/, Net::HTTP.request['X-WSSE']
-  end
-  
-  should "use given Time object as timestamp for authentication" do
-    timestamp = Time.now
-    @client = new_client(200, '', :auth => {:login => 'auser', :api_secret => 'his_api_secret', :timestamp => timestamp})
-    @client.friendships.update! :id => 321
-    
-    assert_equal "WSSE realm=\"#{Partigirb::Client::PARTIGI_API_HOST}\", profile=\"UsernameToken\"", Net::HTTP.request['Authorization']
-    assert_match /UsernameToken Username="auser", PasswordDigest="[^"]+", Nonce="[^"]+", Created="#{timestamp.strftime(Partigirb::Client::TIMESTAMP_FORMAT)}"/, Net::HTTP.request['X-WSSE']
-  end
-  
-  should "use the PasswordDigest from given parameters" do
-    @client = new_client(200, '', :auth => {:login => 'auser', :api_secret => 'his_api_secret', :nonce => '123456789101112', :timestamp => '2009-07-15T14:43:07Z'})
-    @client.friendships.update! :id => 321
-    
-    pdigest = Base64.encode64(Digest::SHA1.hexdigest("1234567891011122009-07-15T14:43:07Zauserhis_api_secret")).chomp
-    
-    assert_equal "WSSE realm=\"#{Partigirb::Client::PARTIGI_API_HOST}\", profile=\"UsernameToken\"", Net::HTTP.request['Authorization']
-    assert_match /UsernameToken Username="auser", PasswordDigest="#{pdigest}", Nonce="123456789101112", Created="2009-07-15T14:43:07Z"/, Net::HTTP.request['X-WSSE']
-  end
-  
-  context "generate_nonce method" do
-    should "generate random strings" do
-      @client.instance_eval do
-        nonces = []
-        1.upto(25) do
-          assert !nonces.include?(generate_nonce)
-        end
-      end
-    end
-  end
-  
   should "process XML response by XML handler" do
     Partigirb::Handlers::XMLHandler.any_instance.expects(:decode_response).once
     Partigirb::Handlers::AtomHandler.any_instance.expects(:decode_response).never
@@ -175,14 +110,88 @@ class ClientTest < Test::Unit::TestCase
   end  
   
   should "raise a PartigiError with response error text as the message when http response codes are other than 200" do
-   client = new_client(400, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<error>Partigi::BadAPIRequestRequiredParams</error>\n")
-   
-   begin
-     client.items.show.xml :id => 'madeup'
-   rescue Exception => e
-     assert e.is_a?(Partigirb::PartigiError)
-     assert_equal 'Partigi::BadAPIRequestRequiredParams', e.message
-   end
+    client = new_client(400, "Partigi::BadAPIRequestRequiredParams")
+
+    begin
+      client.items.show.xml :id => 'madeup'
+    rescue Exception => e
+      assert e.is_a?(Partigirb::PartigiError)
+      assert_equal 'Partigi::BadAPIRequestRequiredParams', e.message
+    end
+  end
+  
+  should "initialize with OAuth consumer key and secret" do
+    client = Partigirb::Client.new('my_consumer_key', 'my_consumer_secret')
+    
+    assert client.consumer.is_a?(OAuth::Consumer)
+    assert_equal 'my_consumer_key', client.consumer.key
+    assert_equal 'my_consumer_secret', client.consumer.secret
+  end
+  
+  should "get a request token from the consumer" do
+    consumer = mock('oauth consumer')
+    request_token = mock('request token')
+    OAuth::Consumer.expects(:new).with('my_consumer_key', 'my_consumer_secret', {:site => 'http://www.partigi.com'}).returns(consumer)
+    client = Partigirb::Client.new('my_consumer_key', 'my_consumer_secret')
+    
+    consumer.expects(:get_request_token).returns(request_token)
+    
+    assert_equal request_token, client.request_token
+  end
+  
+  should "clear request token and set the callback url" do
+    consumer = mock('oauth consumer')
+    request_token = mock('request token')      
+    OAuth::Consumer.expects(:new).with('my_consumer_key', 'my_consumer_secret', {:site => 'http://www.partigi.com'}).returns(consumer)
+    client = Partigirb::Client.new('my_consumer_key', 'my_consumer_secret')
+    
+    client.expects(:clear_request_token).once
+    consumer.expects(:get_request_token).with({:oauth_callback => 'http://testing.com/oauth_callback'}).returns(request_token)
+    
+    client.set_callback_url('http://testing.com/oauth_callback')
+  end
+  
+  should "create and set access token from request token, request secret and verifier" do
+    client = Partigirb::Client.new('my_consumer_key', 'my_consumer_secret')
+    consumer = OAuth::Consumer.new('my_consumer_key', 'my_consumer_secret', {:site => 'http://www.partigi.com'})
+    client.stubs(:consumer).returns(consumer)
+    
+    access_token  = mock('access token')
+    request_token = mock('request token')
+    request_token.expects(:get_access_token).with(:oauth_verifier => 'verify_me').returns(access_token)
+      
+    OAuth::RequestToken.expects(:new).with(consumer, 'the_request_token', 'the_request_secret').returns(request_token)
+    
+    client.authorize_from_request('the_request_token', 'the_request_secret', 'verify_me')
+    assert_equal access_token, client.access_token
+  end
+  
+  should "create and set access token from access token and secret" do
+    client = Partigirb::Client.new('my_consumer_key', 'my_consumer_secret')
+    consumer = OAuth::Consumer.new('my_consumer_key', 'my_consumer_secret', {:site => 'http://www.partigi.com'})
+    client.stubs(:consumer).returns(consumer)
+    
+    client.authorize_from_access('the_access_token', 'the_access_secret')
+    assert client.access_token.is_a?(OAuth::AccessToken)
+    assert_equal 'the_access_token', client.access_token.token
+    assert_equal 'the_access_secret', client.access_token.secret
+  end
+  
+  should "pass access token on Transport requests when available" do
+    access_token  = mock('access token')
+    OAuth::AccessToken.expects(:new).with(anything, 'the_access_token', 'the_access_secret').returns(access_token)
+    @client.transport.expects(:request).with(anything, anything, has_entries({:access_token => access_token})).returns(MockResponse.new(200,''))
+    @client.authorize_from_access('the_access_token', 'the_access_secret')
+    @client.user.show.xml
+  end
+  
+  context "verify_credentials method" do
+    should "make a request to /account/verify_credentials" do
+      @client = new_client(200, '')
+      @client.verify_credentials
+
+      assert_equal '/api/v1/account/verify_credentials.atom', @client.transport.url.path
+    end
   end
   
   # Copied from Grackle

data/test/mocks/transport_mock.rb

@@ -2,8 +2,9 @@
 class MockTransport < Partigirb::Transport
   attr_accessor :status, :body, :method, :url, :options
 
-  def initialize(status,body,headers={})
+  def initialize(consumer,status,body,headers={})
     Net::HTTP.response = MockResponse.new(status,body,headers)
+    super(consumer)
   end
 
   def request(method, string_url, options)

data/test/test_helper.rb

@@ -13,8 +13,8 @@ Dir.glob('test/mocks/*_mock.rb').each { |e| require e }
 
 class Test::Unit::TestCase
   def new_client(status=200, response_body='', client_opts={})
-    client = Partigirb::Client.new(client_opts)
-    client.transport = MockTransport.new(status,response_body)
+    client = Partigirb::Client.new('prb_consumer_key', 'prb_consumer_secret', client_opts)
+    client.transport = MockTransport.new(client.consumer,status,response_body)
     client
   end
   

data/test/transport_test.rb

@@ -1,8 +1,25 @@
 require File.dirname(__FILE__) + '/test_helper'
 require 'net/http'
 
-class RequestTest < Test::Unit::TestCase
-  def test_nothing
-    assert true
+class TransportTest < Test::Unit::TestCase
+  should "sign request using OAuth without access token by default" do
+    consumer = ::OAuth::Consumer.new('consumer_key', 'this_is_secret')
+    transport = Partigirb::Transport.new(consumer)
+    
+    Net::HTTP::Get.any_instance.expects(:oauth!).with(anything, consumer, nil).once
+    Net::HTTP.any_instance.expects(:request).once
+    
+    transport.request :get, "http://test.host"
   end
-end
+  
+  should "sign request using OAuth with the given Access Token" do
+    consumer = ::OAuth::Consumer.new('consumer_key', 'this_is_secret')
+    access_token = ::OAuth::AccessToken.new('access_token', 'access_secret')
+    transport = Partigirb::Transport.new(consumer)
+    
+    Net::HTTP::Get.any_instance.expects(:oauth!).with(anything, consumer, access_token).once
+    Net::HTTP.any_instance.expects(:request).once
+    
+    transport.request :get, "http://test.host", :access_token => access_token
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: partigirb
 version: !ruby/object:Gem::Version 
-  version: 0.2.7
+  version: 0.3.0
 platform: ruby
 authors: 
 - Alvaro Bautista
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-28 00:00:00 +01:00
+date: 2010-02-10 00:00:00 +01:00
 default_executable: 
 dependencies: []