bloveless_grackle 0.1.10

data/CHANGELOG.rdoc

@@ -0,0 +1,46 @@
+== 0.1.10 (2010-6-13)
+* Changed :v1 (api.twitter.com/1) to be the default API instead of REST. :rest is now deprecated
+* Fixed issue with DELETE requests not being able to have form encoded body parameters. This was causing the list membership delete method to fail. As a side note, it appears that Twitter is actually violating the HTTP 1.1 spec on this one since RFC 2616 states that a DELETE "requests that the origin server delete the resource identified by the Request-URI" (note no mention of any "enclosed entity").
+
+== 0.1.9 (2010-2-28)
+* Added support for a boolean option called auto_append_ids that controls whether parameters named "id" are automatically appended to the URL or used as request parameters. It's true by default so there's no change to existing behavior unless you explicitly set it to false.
+* Updated the README with changes describing how to use custom handlers (thanks akahn!)
+
+== 0.1.8 (2010-2-2)
+* Added proxy support to Grackle::Transport via proxy attribute. Can specify a Proc that returns a Net::HTTP subclass or a Net::HTTP subclass directly. Typically this will be from Net::HTTP.Proxy.
+
+== 0.1.7 (2009-12-13)
+* Fixed a bug in Ruby 1.9 where the client was incorrectly handling request method parameters
+* Fixed a bug in the _ method that wasn't correctly appending numeric path elements
+* Provided a way to specify SSL Certificate Authority certs for correct SSL validation
+* The only thing that doesn't work in 1.9 in this version is OAuth because that gem is not up to date
+
+== 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
+
+== 0.1.4 (2009-08-09)
+Added additional check for 3xx responses that don't have location headers. 
+
+== 0.1.3 (2009-08-09)
+Merged in changes from gotwalt for timeouts and redirects. Revised 30x 
+redirect handling to support a limit that prevents infinite redirects. 
+
+== 0.1.2 (2009-05-11)
+Changed :site param used by OAuth to be determined dynamically unless 
+explicitly specified as part of the :auth param to the Client constructor. 
+This param needs to match the scheme and authority of the request using 
+OAuth or the signing will not validate.
+
+== 0.1.1 (2009-05-10)
+Fixed issue where SSL setting wasn't being applied correctly to Net:HTTP 
+which was preventing SSL-enabled requests from working correctly.
+
+== 0.1.0 (2009-04-12)
+* Added OAuth authentication
+* Deprecated :username and :password Grackle::Client constructor params
+* Changed multipart upload implementation and removed dependency on httpclient gem
+* Added dependency on mime-types gem

data/README.rdoc

@@ -0,0 +1,217 @@
+=grackle
+by Hayes Davis
+- http://twitter.com/hayesdavis
+- hayes [at] unionmetrics [dot] com
+- http://unionmetrics.com
+- http://hayesdavis.net
+
+== DESCRIPTION
+Grackle is a lightweight Ruby wrapper around the Twitter REST and Search APIs.
+It's based on my experience using the Twitter API to build http://cheaptweet.com
+and http://tweetreach.com. The main goal of Grackle is to never require a
+release when the Twitter API changes (which it often does) or in the face of a
+particular Twitter API bug. As such it's somewhat different from other Twitter
+API libraries. It doesn't try to hide the Twitter "methods" under an access
+layer nor does it introduce concrete classes for the various objects returned by
+Twitter. Instead, calls to the Grackle client map directly to Twitter API URLs.
+The objects returned by API calls are generated as OpenStructs on the fly and
+make no assumptions about the presence or absence of any particular attributes.
+Taking this approach means that changes to URLs used by Twitter, parameters
+required by those URLs or return values will not require a new release. It will
+potentially require, however, some modifications to your code that uses Grackle.
+
+=== Support and Announcements
+The preferred forum for questions and discussions is the Google group at
+http://groups.google.com/group/gracklerb. You can email me directly or @reply me
+on Twitter, but the group is better since the questions and responses will be
+available to everyone. I'll also make announcements there. There are some
+examples on the wiki at http://wiki.github.com/hayesdavis/grackle. If you prefer
+your information in 140 characters, follow @gracklerb[http://twitter.com/gracklerb].
+
+==USING GRACKLE
+
+Before you do anything else, you'll need to
+  require 'grackle'
+
+===Creating a Grackle::Client
+====Using OAuth
+  client = Grackle::Client.new(:auth=>{
+    :type=>:oauth,
+    :consumer_key=>'SOMECONSUMERKEYFROMTWITTER', :consumer_secret=>'SOMECONSUMERTOKENFROMTWITTER',
+    :token=>'ACCESSTOKENACQUIREDONUSERSBEHALF', :token_secret=>'SUPERSECRETACCESSTOKENSECRET'
+  })
+  
+OAuth can be a bit complicated. See the wiki[http://wiki.github.com/hayesdavis/grackle/grackle-and-oauth] 
+for more information on acquiring the keys, tokens and secrets needed to 
+successfully authenticate with OAuth.
+
+====Using No Auth
+  client = Grackle::Client.new
+
+====Using Basic Auth (DEPRECATED)
+As of August 31st, 2010, Twitter has deprecated basic authentication in favor of OAuth. Please refer to the section on OAuth authentication.
+  client = Grackle::Client.new(:auth=>{:type=>:basic,:username=>'your_user',:password=>'yourpass'})
+
+See Grackle::Client for more information about valid arguments to the constructor. It's quite configurable. Among other things, you can turn on ssl and specify custom headers. The calls below are pretty much as simple as it gets.
+
+===Grackle Method Syntax
+Grackle uses a method syntax that corresponds to the Twitter API URLs with a few twists. Where you would have a slash in 
+a Twitter URL, that becomes a "." in a chained set of Grackle method calls. Each call in the method chain is used to build 
+Twitter URL path until a particular call is encountered which causes the request to be sent. Methods which will cause a 
+request to be execute include:
+- A method call ending in "?" will cause an HTTP GET to be executed
+- A method call ending in "!" will cause an HTTP POST to be executed
+- If a valid format such as .json, .xml, .rss or .atom is encounted, a get will be executed with that format
+- A format method can also include a ? or ! to determine GET or POST in that format respectively
+
+===GETting Data
+The preferred and simplest way of executing a GET is to use the "?" method notation. This will use the default client 
+format (usually JSON, but see Formats section below):
+  client.users.show? :screen_name=>'some_user' #http://twitter.com/users/show.json?screen_name=some_user
+
+You can force XML format by doing:
+  client.users.show.xml? :screen_name=>'some_user' #http://twitter.com/users/show.xml?screen_name=some_user
+  
+You can force JSON:
+  client.users.show.json? :screen_name=>'some_user' #http://twitter.com/users/show.json?screen_name=some_user
+
+Or, since Twitter also allows certain ids/screen_names to be part of their URLs, this works:
+  client.users.show.some_user? #http://twitter.com/users/show/some_user.json
+
+If you use an explicit format, you can leave off the "?" like so:
+  client.users.show.xml :screen_name=>'some_user' #http://twitter.com/users/show.xml?screen_name=some_user
+
+===POSTing data
+To use Twitter API methods that require an HTTP POST, you need to end your method chain with a bang (!)
+
+The preferred way is to use the Client's default format (usually JSON, but see Formats section below):
+  client.statuses.update! :status=>'this status is from grackle' #POST to http://twitter.com/statuses/update.json
+
+You can force a format. To update the authenticated user's status using the XML format:
+  client.statuses.update.xml! :status=>'this status is from grackle' #POST to http://twitter.com/statuses/update.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
+DEPRECATION NOTICE: The :rest API key (pointing to twitter.com) has been 
+deprecated in favor of the versioned API :v1 (pointing to api.twitter.com/1). 
+:v1 is now the default if you do not specify an API. Please do not use :rest 
+in your code.
+
+By default, the Grackle::Client sends all requests to the versioned Twitter REST API. If you want to send requests to 
+the Twitter Search API, just set Grackle::Client.api to :search. To toggle back, set it to be :v1. All requests made 
+after setting this attribute will go to that API.
+
+If you want to make a specific request to one API and not change the Client's overall api setting beyond that request, you can use the 
+bracket syntax like so:
+  client[:search].trends.daily? :exclude=>'hashtags'
+  client[:v1].users.show? :id=>'hayesdavis'
+ 
+Search and REST requests are all built using the same method chaining and termination conventions.
+
+===Parameter handling
+- All parameters are URL encoded as necessary.
+- If you use a File object as a parameter it will be POSTed to Twitter in a multipart request.
+- If you use a Time object as a parameter, .httpdate will be called on it and that value will be used
+
+===Return Values
+Regardless of the format used, Grackle returns an OpenStruct (actually a Grackle::TwitterStruct) of data. The attributes 
+available on these structs correspond to the data returned by Twitter.
+
+===Dealing with Errors
+If the request to Twitter does not return a status code of 200, then a TwitterError is thrown. This contains the HTTP method used, 
+the full request URI, the response status, the response body in text and a response object build by parsing the formatted error 
+returned by Twitter. It's a good idea to wrap your API calls with rescue clauses for Grackle::TwitterError.
+
+If there is an unexpected connection error or Twitter returns data in the wrong format (which it can do), you'll still get a TwitterError.
+
+===Formats
+Twitter allows you to request data in particular formats. Grackle automatically 
+parses JSON and XML formatted responses and returns an OpenStruct. The 
+Grackle::Client has a default_format you can specify. By default, the 
+default_format is :json. 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.
+
+If you specify a format that Grackle doesn't parse for you, you'll receive a 
+string containing the raw response body. If you want to receive the raw 
+response body even for XML or JSON formatted responses, tell the Grackle client 
+to use the +StringHandler+ handler. For example, the following code sets the 
+Grackle client to return JSON instead of an OpenStruct:
+
+  client = Grackle::Client.new(:handlers=>{:json=>Grackle::Handlers::StringHandler.new })
+
+===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:
+- json
+- oauth 
+- mime-types
+
+=== Ruby Version Support
+Grackle works just fine on Ruby 1.8.x. It is also known to work on 1.9.1 with 
+the exception of OAuth. The OAuth gem used by Grackle has not been updated fully 
+to support 1.9. Please see this thread[http://groups.google.com/group/oauth-ruby/browse_thread/thread/d0851a907878cd22] 
+for more information.
+
+Once the OAuth gem has been updated, Grackle will work fully on 1.9. If you 
+aren't using OAuth it should be fine for use on 1.9 as is.
+
+== INSTALL
+The grackle gem is now hosted at http://gemcutter.org. If you've already setup gemcutter 
+in your sources, you can do the following:
+  sudo gem install grackle
+
+If you haven't yet setup gemcutter in your sources, go to http://gemcutter.org and follow the instructions there.
+They will likely tell you to do the following:
+  sudo gem install gemcutter
+  sudo gem tumble
+
+Once you've done that you can do: 
+  sudo gem install grackle
+
+== LICENSE
+
+(The MIT License)
+
+Copyright (c) 2009
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/grackle.gemspec

@@ -0,0 +1,40 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{bloveless_grackle}
+  s.version = "0.1.10"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Hayes Davis", "Brennon Loveless"]
+  #s.date = %q{2010-6-13}
+  s.description = %q{Grackle is a lightweight library for the Twitter REST and Search API. Brennon Loveless added the upload api endpoint.}
+  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"]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/hayesdavis/grackle}
+  s.rdoc_options = ["--inline-source", "--charset=UTF-8","--main=README.rdoc"]
+  s.extra_rdoc_files = ['README.rdoc']
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{grackle}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{Grackle is a library for the Twitter REST and Search API designed to not require a new release in the face Twitter API changes or errors. It supports both basic and OAuth authentication mechanisms.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<json>, [">= 0"])
+      s.add_dependency(%q<mime-types>, [">= 0"])
+      s.add_dependency(%q<oauth>, [">= 0"])
+    else
+      s.add_dependency(%q<json>, [">= 0"])
+      s.add_dependency(%q<mime-types>, [">= 0"])
+      s.add_dependency(%q<oauth>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<json>, [">= 0"])
+    s.add_dependency(%q<mime-types>, [">= 0"])
+    s.add_dependency(%q<oauth>, [">= 0"])
+  end
+end

data/lib/grackle.rb

@@ -0,0 +1,31 @@
+module Grackle
+
+  # :stopdoc:
+  VERSION = '0.1.10'
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  # Returns the version string for the library.
+  def self.version
+    VERSION
+  end
+
+end  # module Grackle
+
+$:.unshift File.dirname(__FILE__)
+
+require 'ostruct'
+require 'open-uri'
+require 'net/http'
+require 'time'
+require 'rexml/document'
+require 'json'
+require 'oauth'
+require 'oauth/client'
+require 'mime/types'
+
+require 'grackle/utils'
+require 'grackle/transport'
+require 'grackle/handlers'
+require 'grackle/client'

data/lib/grackle/client.rb

@@ -0,0 +1,295 @@
+module Grackle
+  
+  #Returned by methods which retrieve data from the API
+  class TwitterStruct < OpenStruct
+    attr_accessor :id
+  end
+
+  #Raised by methods which call the API if a non-200 response status is received 
+  class TwitterError < StandardError
+    attr_accessor :method, :request_uri, :status, :response_body, :response_object
+  
+    def initialize(method, request_uri, status, response_body, msg=nil)
+      self.method = method
+      self.request_uri = request_uri
+      self.status = status
+      self.response_body = response_body
+      super(msg||"#{self.method} #{self.request_uri} => #{self.status}: #{self.response_body}")
+    end
+  end  
+  
+  # The Client is the public interface to Grackle. You build Twitter API calls using method chains. See the README for details 
+  # and new for information on valid options.
+  #
+  # ==Authentication
+  # Twitter is migrating to OAuth as the preferred mechanism for authentication (over HTTP basic auth). Grackle supports both methods.
+  # Typically you will supply Grackle with authentication information at the time you create your Grackle::Client via the :auth parameter.
+  # ===Basic Auth
+  #   client = Grackle.Client.new(:auth=>{:type=>:basic,:username=>'twitteruser',:password=>'secret'})
+  # Please note that the original way of specifying basic authentication still works but is deprecated
+  #   client = Grackle.Client.new(:username=>'twitteruser',:password=>'secret') #deprecated
+  #
+  # ===OAuth
+  # OAuth is a relatively complex topic. For more information on OAuth applications see the official OAuth site at http://oauth.net and the 
+  # OAuth specification at http://oauth.net/core/1.0. For authentication using OAuth, you will need do the following:
+  # - Acquire a key and token for your application ("Consumer" in OAuth terms) from Twitter. Learn more here:  http://apiwiki.twitter.com/OAuth-FAQ
+  # - Acquire an access token and token secret for the user that will be using OAuth to authenticate into Twitter
+  # The process of acquiring the access token and token secret are outside the scope of Grackle and will need to be coded on a per-application 
+  # basis. Grackle comes into play once you've acquired all of the above pieces of information. To create a Grackle::Client that uses OAuth once 
+  # you've got all the necessary tokens and keys:
+  #   client = Grackle::Client.new(:auth=>{
+  #     :type=>:oauth,
+  #     :consumer_key=>'SOMECONSUMERKEYFROMTWITTER, :consumer_secret=>'SOMECONSUMERTOKENFROMTWITTER',
+  #     :token=>'ACCESSTOKENACQUIREDONUSERSBEHALF', :token_secret=>'SUPERSECRETACCESSTOKENSECRET'
+  #   }) 
+  class Client
+    
+    class Request #:nodoc:
+      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.path = ''
+      end
+      
+      def <<(path)
+        self.path << path
+      end
+      
+      def path?
+        path.length > 0
+      end
+    
+      def url
+        "#{scheme}://#{host}#{path}"
+      end
+         
+      def host
+        client.api_hosts[api]
+      end
+    
+      def scheme
+        ssl ? 'https' :'http'
+      end
+      
+      def params
+        @params ||= {}
+      end
+    end
+    
+    VALID_FORMATS = [:json,:xml,:atom,:rss]
+
+    # Contains the mapping of API name symbols to actual host (and path) 
+    # prefixes to use with requests. You can add your own to this hash and 
+    # refer to it wherever Grackle::Client uses an API symbol. You may wish 
+    # to do this when Twitter introduces API versions greater than 1.
+    TWITTER_API_HOSTS = {
+      :search=>'search.twitter.com', :v1=>'api.twitter.com/1', :upload=>'upload.twitter.com/1'
+    }
+    TWITTER_API_HOSTS[:rest] = TWITTER_API_HOSTS[:v1]
+    
+    #Basic OAuth information needed to communicate with Twitter
+    TWITTER_OAUTH_SPEC = {
+      :request_token_path=>'/oauth/request_token',
+      :access_token_path=>'/oauth/access_token',
+      :authorize_path=>'/oauth/authorize'
+    }
+    
+    attr_accessor :auth, :handlers, :default_format, :headers, :ssl, :api, 
+      :transport, :request, :api_hosts, :timeout, :auto_append_ids, :uri_extension
+    
+    # Arguments (all are optional):
+    # - :username       - twitter username to authenticate with (deprecated in favor of :auth arg)
+    # - :password       - twitter password to authenticate with (deprecated in favor of :auth arg)
+    # - :handlers       - Hash of formats to Handler instances (e.g. {:json=>CustomJSONHandler.new})
+    # - :default_format - Symbol of format to use when no format is specified in an API call (e.g. :json, :xml)
+    # - :headers        - Hash of string keys and values for headers to pass in the HTTP request to twitter
+    # - :ssl            - true or false to turn SSL on or off. Default is off (i.e. http://)
+    # - :api            - one of :rest, :search or :v1. :v1 is the default and :rest is now deprecated
+    # - :auth           - Hash of authentication type and credentials. Must have :type key with value one of :basic or :oauth
+    #   - :type=>:basic  - Include :username and :password keys
+    #   - :type=>:oauth  - Include :consumer_key, :consumer_secret, :token and :token_secret keys
+    # - :uri_extension   - true or false to include format in URI (e.g. /test.json). Default is true
+    def initialize(options={})
+      self.transport = Transport.new
+      self.handlers = {:json=>Handlers::JSONHandler.new,:xml=>Handlers::XMLHandler.new,:unknown=>Handlers::StringHandler.new}
+      self.handlers.merge!(options[:handlers]||{})
+      self.default_format = options[:default_format] || :json 
+      self.headers = {"User-Agent"=>"Grackle/#{Grackle::VERSION}"}.merge!(options[:headers]||{})
+      self.ssl = options[:ssl] == true
+      self.api = options[:api] || :v1
+      self.api_hosts = TWITTER_API_HOSTS.clone
+      self.timeout = options[:timeout] || 60
+      self.auto_append_ids = options[:auto_append_ids] == false ? false : true
+      self.auth = {}
+      self.uri_extension = options[:uri_extension] == false ? false : true
+      if options.has_key?(:username) || options.has_key?(:password)
+        #Use basic auth if :username and :password args are passed in
+        self.auth.merge!({:type=>:basic,:username=>options[:username],:password=>options[:password]})
+      end
+      #Handle auth mechanism that permits basic or oauth
+      if options.has_key?(:auth)
+        self.auth = options[:auth]
+        if auth[:type] == :oauth
+          self.auth = TWITTER_OAUTH_SPEC.merge(auth)
+        end
+      end
+    end
+               
+    def method_missing(name,*args,&block)
+      if block_given?
+        return request_with_http_method_block(name,&block)
+      end
+      append(name,*args)
+    end
+    
+    # Used to toggle APIs for a particular request without setting the Client's default API
+    #   client[:rest].users.show.hayesdavis?
+    def [](api_name)
+      request.api = api_name
+      self
+    end
+    
+    #Clears any pending request built up by chained methods but not executed
+    def clear
+      self.request = nil
+    end
+    
+    #Deprecated in favor of using the auth attribute.
+    def username
+      if auth[:type] == :basic
+        auth[:username]
+      end
+    end
+    
+    #Deprecated in favor of using the auth attribute.    
+    def username=(value)
+      unless auth[:type] == :basic
+        auth[:type] = :basic        
+      end
+      auth[:username] = value
+    end
+    
+    #Deprecated in favor of using the auth attribute.    
+    def password
+      if auth[:type] == :basic
+        auth[:password]
+      end
+    end
+    
+    #Deprecated in favor of using the auth attribute.    
+    def password=(value)
+      unless auth[:type] == :basic
+        auth[:type] = :basic
+      end
+      auth[:password] = value
+    end
+    
+    def append(name,*args)
+      name = name.to_s.to_sym
+      #The args will be a hash, store them if they're specified
+      self.request.params = args.first
+      #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)
+        if auto_append_ids
+          id = request.params.delete(:id)
+          request << "/#{id}" if id
+        end
+        if uri_extension
+          request << ".#{format}"
+        end
+        res = send_request
+        process_response(format,res)
+      ensure
+        clear
+      end
+      
+      def send_request
+        begin
+          http_method = (
+            request.params.delete(:__method) or request.method or :get
+          )
+          transport.request(
+            http_method, request.url,
+            :auth=>auth,:headers=>headers,
+            :params=>request.params,:timeout => timeout
+          )
+        rescue => e
+          puts e
+          raise TwitterError.new(request.method,request.url,nil,nil,"Unexpected failure making request: #{e}")
+        end        
+      end
+      
+      def process_response(format,res)
+        fmt_handler = handler(format)        
+        begin
+          unless res.status == 200
+            handle_error_response(res,fmt_handler)
+          else
+            fmt_handler.decode_response(res.body)
+          end
+        rescue TwitterError => e
+          raise e
+        rescue => e
+          raise TwitterError.new(res.method,res.request_uri,res.status,res.body,"Unable to decode response: #{e}")
+        end
+      end
+      
+      def request
+        @request ||= Request.new(self,api,ssl)
+      end
+      
+      def handler(format)
+        handlers[format] || handlers[:unknown]
+      end
+      
+      def handle_error_response(res,handler)
+        err = TwitterError.new(res.method,res.request_uri,res.status,res.body)
+        err.response_object = handler.decode_response(err.response_body)
+        raise err        
+      end
+      
+      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