@@ -1,3 +1,7 @@ +== 0.1.6 (2009-10-29) +* Added support for HTTP methods beside GET and POST using block syntax +* Added method for appending to the request path something that's not a valid ruby method + == 0.1.5 (2009-10-28) Added support for the Twitter version 1 API as a API symbol :v1 CHANGELOG.rdoc @@ -79,6 +79,20 @@ You can force a format. To update the authenticated user's status using the XML Or, with JSON client.statuses.update.json! :status=>'this status is from grackle' #POST to http://twitter.com/statuses/update.json + +===Using Other HTTP Verbs +To use HTTP verbs like DELETE or PUT, Grackle provides a slightly different syntax: + client.put{ hayesdavis.lists.my_list :name=>'New Name' } #HTTP PUT + client.delete{ direct_messages.destroy :id=>1 } #HTTP DELETE + +You may specify any method chain you wish in the block. Note that if your method chain inside the block +ends in a ! or ?, that the HTTP verb for the block will still be used. This means that + client.delete{ direct_messages.destroy! :id=>1 } #Uses HTTP DELETE, not POST + client.direct_messages.destroy! :id=>1 #Uses HTTP POST + +If for some reason you don't like the preferred block syntax above, you may specify a +parameter to your method chain called :__method (note the double underscores) to specify the HTTP verb: + client.direct_messages.destroy! :id=>1, :__method=>:delete #HTTP DELETE ===Toggling APIs By default, the Grackle::Client sends all requests to the unversioned Twitter REST API. If you want to send requests to @@ -125,6 +139,12 @@ the raw response body. The Grackle::Client has a default_format you can specify. If you don't include a named format in your method chain as described above, but use a "?" or "!" then the Grackle::Client.default_format is used. +===Odds and Ends +If you need to append something to the request path that isn't a valid ruby method, e.g. + /1user/lists.json #1user isn't a valid Ruby method +you can use the Grackle::Client#_ method like so: + client._('1user').lists.json + == REQUIREMENTS: You'll need the following gems to use all features of Grackle: README.rdoc @@ -2,11 +2,11 @@ Gem::Specification.new do |s| s.name = %q{grackle} - s.version = "0.1.5" + s.version = "0.1.6" s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version= s.authors = ["Hayes Davis"] - s.date = %q{2009-05-23} + s.date = %q{2009-10-29} s.description = %q{Grackle is a lightweight library for the Twitter REST and Search API.} s.email = %q{hayes@appozite.com} s.files = ["CHANGELOG.rdoc", "README.rdoc", "grackle.gemspec", "lib/grackle.rb", "lib/grackle/client.rb", "lib/grackle/handlers.rb", "lib/grackle/transport.rb", "lib/grackle/utils.rb", "test/test_grackle.rb", "test/test_helper.rb", "test/test_client.rb", "test/test_handlers.rb"] grackle.gemspec @@ -1,7 +1,7 @@ module Grackle # :stopdoc: - VERSION = '0.1.5' + VERSION = '0.1.6' LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR # :startdoc: lib/grackle.rb @@ -45,13 +45,12 @@ module Grackle class Client class Request #:nodoc: - attr_accessor :client, :path, :method, :api, :ssl + attr_accessor :client, :path, :method, :api, :ssl, :params def initialize(client,api=:rest,ssl=true) self.client = client self.api = api self.ssl = ssl - self.method = :get self.path = '' end @@ -74,9 +73,12 @@ module Grackle def scheme ssl ? 'https' :'http' end + + def params + @params ||= {} + end end - VALID_METHODS = [:get,:post,:put,:delete] VALID_FORMATS = [:json,:xml,:atom,:rss] # Contains the mapping of API name symbols to actual host (and path) @@ -133,26 +135,11 @@ module Grackle end end - def method_missing(name,*args) - #If method is a format name, execute using that format - if format_invocation?(name) - return call_with_format(name,*args) - end - #If method ends in ! or ? use that to determine post or get - if name.to_s =~ /^(.*)(!|\?)$/ - name = $1.to_sym - #! is a post, ? is a get - self.request.method = ($2 == '!' ? :post : :get) - if format_invocation?(name) - return call_with_format(name,*args) - else - self.request << "/#{$1}" - return call_with_format(self.default_format,*args) - end + def method_missing(name,*args,&block) + if block_given? + return request_with_http_method_block(name,&block) end - #Else add to the request path - self.request << "/#{name}" - self + append(name,*args) end # Used to toggle APIs for a particular request without setting the Client's default API @@ -197,21 +184,53 @@ module Grackle auth[:password] = value end + def append(name,*args) + name = name.to_sym + #The args will be a hash, store them if they're specified + self.request.params = *args + #If method is a format name, execute using that format + if format_invocation?(name) + return call_with_format(name) + end + #If method ends in ! or ? use that to determine post or get + if name.to_s =~ /^(.*)(!|\?)$/ + name = $1.to_sym + #! is a post, ? is a get - only set this if the method hasn't been set + self.request.method ||= ($2 == '!' ? :post : :get) + if format_invocation?(name) + return call_with_format(name) + else + self.request << "/#{$1}" + return call_with_format(self.default_format) + end + end + #Else add to the request path + self.request << "/#{name}" + self + end + + alias_method :_, :append + protected - def call_with_format(format,params={}) - id = params.delete(:id) + def call_with_format(format) + id = request.params.delete(:id) request << "/#{id}" if id request << ".#{format}" - res = send_request(params) + res = send_request process_response(format,res) ensure clear end - def send_request(params) + def send_request begin + http_method = ( + request.params.delete(:__method) or request.method or :get + ) transport.request( - request.method,request.url,:auth=>auth,:headers=>headers,:params=>params, :timeout => timeout + http_method, request.url, + :auth=>auth,:headers=>headers, + :params=>request.params,:timeout => timeout ) rescue => e puts e @@ -251,5 +270,19 @@ module Grackle def format_invocation?(name) self.request.path? && VALID_FORMATS.include?(name) end + + def pending_request? + !@request.nil? + end + + def request_with_http_method_block(method,&block) + request.method = method + response = instance_eval(&block) + if pending_request? + call_with_format(self.default_format) + else + response + end + end end end \ No newline at end of file lib/grackle/client.rb @@ -19,12 +19,7 @@ module Grackle DEFAULT_REDIRECT_LIMIT = 5 def req_class(method) - case method - when :get then Net::HTTP::Get - when :post then Net::HTTP::Post - when :put then Net::HTTP::Put - when :delete then Net::HTTP::Delete - end + Net::HTTP.const_get(method.to_s.capitalize) end # Options are one of lib/grackle/transport.rb @@ -195,6 +195,45 @@ class TestClient < Test::Unit::TestCase client.statuses.public_timeline? :since=>time assert_equal("/statuses/public_timeline.json?since=#{CGI::escape(time.httpdate)}",Net::HTTP.request.path) end + + def test_simple_http_method_block + client = new_client(200,'[{"id":1,"text":"test 1"}]') + client.delete { direct_messages.destroy :id=>1, :other=>'value' } + assert_equal(:delete,client.transport.method, "delete block should use delete method") + assert_equal("/direct_messages/destroy/1.json",Net::HTTP.request.path) + assert_equal('value',client.transport.options[:params][:other]) + + client = new_client(200,'{"id":54321,"screen_name":"test_user"}') + value = client.get { users.show.json? :screen_name=>'test_user' } + assert_equal(:get,client.transport.method) + assert_equal('http',client.transport.url.scheme) + assert(!Net::HTTP.last_instance.use_ssl?,'Net::HTTP instance should not be set to use SSL') + assert_equal('twitter.com',client.transport.url.host) + assert_equal('/users/show.json',client.transport.url.path) + assert_equal('test_user',client.transport.options[:params][:screen_name]) + assert_equal('screen_name=test_user',Net::HTTP.request.path.split(/\?/)[1]) + assert_equal(54321,value.id) + end + + def test_http_method_blocks_choose_right_method + client = new_client(200,'[{"id":1,"text":"test 1"}]') + client.get { search :q=>'test' } + assert_equal(:get,client.transport.method, "Get block should choose get method") + client.delete { direct_messages.destroy :id=>1 } + assert_equal(:delete,client.transport.method, "Delete block should choose delete method") + client.post { direct_messages.destroy :id=>1 } + assert_equal(:post,client.transport.method, "Post block should choose post method") + client.put { direct_messages :id=>1 } + assert_equal(:put,client.transport.method, "Put block should choose put method") + end + + def test_http_method_selection_precedence + client = new_client(200,'[{"id":1,"text":"test 1"}]') + client.get { search! :q=>'test' } + assert_equal(:get,client.transport.method, "Get block should override method even if post bang is used") + client.delete { search? :q=>'test', :__method=>:post } + assert_equal(:post,client.transport.method, ":__method=>:post should override block setting and method suffix") + end private def with_http_responder(responder) test/test_client.rb 8cd15c339b8ed13d9e0464557b0c5e9f4384e3a8 Hayes Davis hayes@appozite.com http://github.com/hayesdavis/grackle/commit/7041b6408e387eca9ba89d3e5ef33ef766cbc1f7 7041b6408e387eca9ba89d3e5ef33ef766cbc1f7 2009-10-29T19:45:57-07:00 2009-10-29T19:45:57-07:00 Added new block syntax for HTTP methods that aren't GET and POST. Also added support for building a request path that has a part that is not a valid Ruby method. These two changes give Grackle better support for the upcoming Twitter Lists API and its more RESTful approach. This is version 0.1.6. d633f2e7561d320d6973046e4670716e7f2a45b1 Hayes Davis hayes@appozite.com