hayesdavis-grackle 0.0.1

data/History.txt

@@ -0,0 +1,4 @@
+== 1.0.0 / 2009-03-22
+
+* 1 major enhancement
+  * Birthday!

data/README.txt

@@ -0,0 +1,118 @@
+grackle
+    by Hayes Davis
+    http://www.appozite.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. 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 is somewhat different 
+from other Twitter API libraries. It does not 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. 
+
+==USING GRACKLE
+
+===Creating a Grackle::Client
+  require 'grackle'
+  client = Grackle::Client(:username=>'your_user',:password=>'yourpass')
+
+See Grackle::Client for more information about valid arguments to the constructor including for custom headers and SSL.
+
+===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
+Invoking the API method "/users/show" in XML format for the Twitter user "some_user" looks like
+  client.users.show.xml :id=>'some_user' #http://twitter.com/users/show.xml?id=some_user
+
+Or using the JSON format:
+  client.users.show.json :id=>'some_user' #http://twitter.com/users/show.json?id=some_user
+
+Or, since Twitter also allows certain ids to be part of their URLs, this works:
+  client.users.show.some_user.json #http://twitter.com/users/show/some_user.json
+
+The client has a default format of :json so if you want to use the above call with the default format you can do:
+  client.users.show.some_user? #http://twitter.com/users/show/some_user.json
+
+If you include a "?" at the end of any method name, that signals to the Grackle client that you want to execute an HTTP GET request.
+
+===POSTing data
+To use Twitter API methods that require an HTTP POST, you need to end your method chain with a bang (!)
+
+For example, 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
+
+Or, using the default format
+  client.statuses.update! :status=>'this status is from grackle' #POST to http://twitter.com/statuses/update.json
+
+===Search
+Search works the same as everything else but your queries get submitted to search.twitter.com
+  client.search? :q=>'grackle' #http://search.twitter.com/search.json?q=grackle
+
+===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 a Grackle::TwitterStruct (which is mostly just an OpenStruct) 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.
+
+===Formats
+Twitter allows you to request data in particular formats. Grackle currently supports JSON and XML. 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.
+
+== REQUIREMENTS:
+
+You'll need the following gems to use all features of Grackle:
+  *json_pure
+  *httpclient 
+
+== INSTALL:
+
+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/Rakefile

@@ -0,0 +1,35 @@
+# Look in the tasks/setup.rb file for the various options that can be
+# configured in this Rakefile. The .rake files in the tasks directory
+# are where the options are used.
+
+begin
+  require 'bones'
+  Bones.setup
+rescue LoadError
+  begin
+    load 'tasks/setup.rb'
+  rescue LoadError
+    raise RuntimeError, '### please install the "bones" gem ###'
+  end
+end
+
+ensure_in_path 'lib'
+require 'grackle'
+
+task :default => 'spec:run'
+
+PROJ.name = 'grackle'
+PROJ.authors = 'Hayes Davis'
+PROJ.email = 'hayes@appozite.com'
+PROJ.url = 'http://github.com/hayesdavis/grackle'
+PROJ.version = Grackle::VERSION
+PROJ.rubyforge.name = 'grackle'
+PROJ.summary = 'Grackle is a library for the Twitter REST and Search API'
+PROJ.description = 'Grackle is a library for the Twitter REST and Search API that aims to go with the flow.'
+PROJ.spec.opts << '--color'
+PROJ.exclude = %w(.git pkg)
+
+depend_on 'json'
+depend_on 'httpclient'
+
+# EOF

data/bin/grackle

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. lib grackle]))
+
+# Put your code here
+
+# EOF

data/grackle.gemspec

@@ -0,0 +1,39 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{grackle}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Hayes Davis"]
+  s.date = %q{2009-03-22}
+  s.description = %q{Grackle is a library for the Twitter REST and Search API that aims to go with the flow.}
+  s.email = %q{hayes@appozite.com}
+  s.files = ["History.txt", "README.txt", "Rakefile", "bin/grackle", "grackle.gemspec", "lib/grackle.rb", "lib/grackle/client.rb", "lib/grackle/handlers.rb", "lib/grackle/transport.rb", "lib/grackle/utils.rb", "spec/grackle_spec.rb", "spec/spec_helper.rb", "test/test_grackle.rb"]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/hayesdavis/grackle}
+  s.rdoc_options = ["--inline-source", "--charset=UTF-8"]
+  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}
+
+  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_runtime_dependency(%q<httpclient>, [">= 2.1.4"])
+      s.add_development_dependency(%q<bones>, [">= 2.4.2"])
+    else
+      s.add_dependency(%q<json>, [">= 0"])
+      s.add_dependency(%q<httpclient>, [">= 2.1.4"])
+      s.add_dependency(%q<bones>, [">= 2.4.2"])
+    end
+  else
+    s.add_dependency(%q<json>, [">= 0"])
+    s.add_dependency(%q<httpclient>, [">= 2.1.4"])
+    s.add_dependency(%q<bones>, [">= 2.4.2"])
+  end
+end

data/lib/grackle.rb

@@ -0,0 +1,27 @@
+module Grackle
+
+  # :stopdoc:
+  VERSION = '0.0.1'
+  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 'rexml/document'
+require 'json'
+
+require 'grackle/utils'
+require 'grackle/transport'
+require 'grackle/handlers'
+require 'grackle/client'

data/lib/grackle/client.rb

@@ -0,0 +1,153 @@
+module Grackle
+  
+  class TwitterStruct < OpenStruct
+    attr_accessor :id
+  end
+
+  class TwitterError < StandardError
+    attr_accessor :method, :request_uri, :status, :response_body, :response_object
+  
+    def initialize(method, request_uri, status, response_body)
+      self.method = method
+      self.request_uri = request_uri
+      self.status = status
+      self.response_body = response_body
+      super("#{self.method} #{self.request_uri} => #{self.status}: #{self.response_body}")
+    end
+  end  
+  
+  class Client
+        
+    class Request
+      attr_accessor :path, :method
+      
+      def method
+        @method ||= :get
+      end
+      
+      def <<(path)
+        self.path << path
+      end
+      
+      def path
+        @path ||= ''
+      end
+      
+      def path?
+        path.length > 0
+      end
+    end
+    
+    VALID_METHODS = [:get,:post,:put,:delete]
+    VALID_FORMATS = [:json,:xml,:atom,:rss]
+    
+    REST_API_DOMAIN = 'twitter.com'
+    SEARCH_API_DOMAIN = 'search.twitter.com'
+    
+    attr_accessor :username, :password, :handlers, :default_format, :headers, :ssl, :transport, :request
+    
+    # Arguments (all are optional):
+    #   :username - twitter username to authenticate with
+    #   :password - twitter password to authenticate with
+    #   :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)
+    #   :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://)
+    def initialize(options={})
+      self.transport = Transport.new
+      self.username = options.delete(:username)
+      self.password = options.delete(:password)
+      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/1.0'}.merge!(options[:headers]||{})
+      self.ssl = options[:ssl] == true
+    end
+               
+    def method_missing(name,*args)
+      #Check for HTTP method and apply it to the request. 
+      #Can use this for an explict HTTP method
+      if http_method_invocation?(name)
+        self.request.method = name
+        return self
+      end
+      #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
+      end
+      #Else add to the request path
+      self.request << "/#{name}"
+      self
+    end
+    
+    protected
+      def rest_api_domain
+        REST_API_DOMAIN
+      end
+    
+      def search_api_domain
+        SEARCH_API_DOMAIN
+      end
+
+      def call_with_format(format,params={})
+        id = params.delete(:id)
+        self.request << "/#{id}" if id
+        self.request << ".#{format}"
+        url = "#{scheme}://#{request_host}#{self.request.path}"
+        req_info = self.request
+        self.request = nil
+        res = transport.request(
+          req_info.method,url,:username=>self.username,:password=>self.password,:headers=>headers,:params=>params
+        )
+        fmt_handler = handler(format) 
+        unless res.status == 200
+          handle_error_response(res,fmt_handler)
+        else
+          fmt_handler.decode_response(res.body)
+        end
+      end
+      
+      def request
+        @request ||= Request.new
+      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 http_method_invocation?(name)
+        !self.request.path? && VALID_METHODS.include?(name)
+      end
+      
+      def format_invocation?(name)
+        self.request.path? && VALID_FORMATS.include?(name)
+      end
+            
+      def request_host
+        self.request.path =~ /^\/search/ ? search_api_domain : rest_api_domain
+      end
+    
+      def scheme
+        self.ssl ? 'https' :'http'
+      end
+    
+  end
+end

data/lib/grackle/handlers.rb

@@ -0,0 +1,90 @@
+module Grackle
+  
+  # This module contain handlers that know how to take a response body 
+  # from Twitter and turn it into a TwitterStruct return value. Handlers are 
+  # used by the Client to give back return values from API calls. A handler
+  # is intended to provide a +decode+ method which accepts the response body 
+  # as a string.
+  module Handlers
+    
+    # Decodes JSON Twitter API responses
+    class JSONHandler
+    
+      def decode_response(res)
+        json_result = JSON.parse(res)
+        load_recursive(json_result)
+      end
+      
+      private
+        def load_recursive(value)
+          if value.kind_of? Hash
+            build_struct(value)
+          elsif value.kind_of? Array
+            value.map{|v| load_recursive(v)}
+          else
+            value
+          end
+        end
+      
+        def build_struct(hash)
+          struct = TwitterStruct.new
+          hash.each do |key,v|
+            struct.send("#{key}=",load_recursive(v))
+          end
+          struct
+        end
+      
+    end
+    
+    # Decodes XML Twitter API responses
+    class XMLHandler
+      
+      #Known nodes returned by twitter that contain arrays
+      ARRAY_NODES = ['ids','statuses','users']
+      
+      def decode_response(res)
+        xml = REXML::Document.new(res)
+        load_recursive(xml.root)
+      end
+      
+      private
+        def load_recursive(node)
+          if array_node?(node)
+            node.elements.map {|e| load_recursive(e)}
+          elsif node.elements.size > 0
+            build_struct(node)
+          elsif node.elements.size == 0
+            value = node.text
+            fixnum?(value) ? value.to_i : value
+          end
+        end
+      
+        def build_struct(node)
+          ts = TwitterStruct.new
+          node.elements.each do |e|
+            ts.send("#{e.name}=",load_recursive(e))  
+          end
+          ts
+        end
+        
+        # Most of the time Twitter specifies nodes that contain an array of 
+        # sub-nodes with a type="array" attribute. There are some nodes that 
+        # they dont' do that for, though, including the <ids> node returned 
+        # by the social graph methods. This method tries to work in both situations.
+        def array_node?(node)
+          node.attributes['type'] == 'array' || ARRAY_NODES.include?(node.name)
+        end
+      
+        def fixnum?(value)
+          value =~ /^\d+$/
+        end
+    end
+    
+    # Just echoes back the response body. This is primarily used for unknown formats
+    class StringHandler
+      def decode_response(res)
+        res
+      end
+    end
+  end
+end

data/lib/grackle/transport.rb

@@ -0,0 +1,137 @@
+module Grackle
+  
+  class Response
+    attr_accessor :method, :request_uri, :status, :body
+    
+    def initialize(method,request_uri,status,body)
+      self.method = method
+      self.request_uri = request_uri
+      self.status = status
+      self.body = body
+    end
+  end
+  
+  class Transport
+  
+    def get(string_url,options={})
+      request(:get,url,options)
+    end
+    
+    def post(string_url,options={})
+      request(:post,url,options)
+    end
+    
+    def put(url,options={})
+      request(:put,url,options)
+    end
+    
+    def delete(url,options={})
+      request(:delete,url,options)
+    end
+    
+    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
+    end
+    
+    def request(method, string_url, options={})
+      params = stringify_params(options[:params])
+      if method == :get && params
+        string_url << query_string(params)
+      end
+      url = URI.parse(string_url)
+      begin
+        if file_param?(options[:params])
+          request_multipart(method,url,options)
+        else
+          request_standard(method,url,options)
+        end
+      rescue Timeout::Error
+        raise "Timeout while #{req.method}ing #{url.to_s}"
+      end
+    end
+    
+    def request_multipart(method, url, options={})
+      require 'httpclient' unless defined? HTTPClient
+      client = HTTPClient.new
+      if options[:username] && options[:password]
+        client.set_auth(url.to_s,options.delete(:username),options.delete(:password))
+      end
+      res = client.request(method,url.to_s,nil,options[:params],options[:headers])
+      Response.new(method,url.to_s,res.status,res.content)
+    end
+    
+    def request_standard(method,url,options={})
+      Net::HTTP.new(url.host, url.port).start do |http| 
+        req = req_class(method).new(url.request_uri)
+        add_headers(req,options[:headers])
+        add_form_data(req,options[:params])
+        add_basic_auth(req,options[:username],options[:password])
+        res = http.request(req)
+        Response.new(method,url.to_s,res.code.to_i,res.body)
+      end        
+    end
+
+    def query_string(params)
+      query = case params
+        when Hash then params.map{|key,value| url_encode_param(key,value) }.join("&")
+        else url_encode(params.to_s)
+      end
+      if !(query == nil || query.length == 0) && query[0,1] != '?'
+        query = "?#{query}"
+      end
+      query
+    end      
+  
+    private
+      def stringify_params(params)
+        return nil unless params
+        params.inject({}) do |h, pair|
+          key, value = pair
+          if value.respond_to? :httpdate
+            value = value.httpdate
+          end
+          h[key] = value
+          h
+        end
+      end
+      
+      def file_param?(params)
+        return false unless params
+        params.any? {|key,value| value.respond_to? :read }
+      end
+      
+      def url_encode(value)
+        require 'cgi' unless defined?(CGI) && defined?(CGI::escape)
+        CGI.escape(value.to_s)
+      end
+      
+      def url_encode_param(key,value)
+        "#{url_encode(key)}=#{url_encode(value)}"
+      end
+      
+      def add_headers(req,headers)
+        if headers
+          headers.each do |header, value|
+            req[header] = value
+          end
+        end        
+      end
+    
+      def add_form_data(req,params)
+        if req.request_body_permitted? && params
+          req.set_form_data(params)
+        end
+      end
+    
+      def add_basic_auth(req,username,password)
+        if username && password
+          req.basic_auth(username,password)
+        end
+      end
+  end
+end

data/lib/grackle/utils.rb

@@ -0,0 +1,16 @@
+module Grackle
+  module Utils
+    
+    VALID_PROFILE_IMAGE_SIZES = [:bigger,:normal,:mini]
+    
+    #Easy method for getting different sized profile images using Twitter's naming scheme
+    def profile_image_url(url,size=:normal)
+      size = VALID_PROFILE_IMAGE_SIZES.find(:normal){|s| s == size.to_sym}
+      return url if url.nil? || size == :normal
+      url.sub(/_normal\./,"_#{size.to_s}.")
+    end
+  
+    module_function :profile_image_url    
+    
+  end
+end

data/spec/grackle_spec.rb

@@ -0,0 +1,7 @@
+
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe Grackle do
+end
+
+# EOF

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. lib grackle]))
+
+Spec::Runner.configure do |config|
+  # == Mock Framework
+  #
+  # RSpec uses it's own mocking framework by default. If you prefer to
+  # use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+end
+
+# EOF

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification 
+name: hayesdavis-grackle
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Hayes Davis
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-22 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: httpclient
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.1.4
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: bones
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.4.2
+    version: 
+description: Grackle is a library for the Twitter REST and Search API that aims to go with the flow.
+email: hayes@appozite.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- History.txt
+- README.txt
+- Rakefile
+- bin/grackle
+- grackle.gemspec
+- lib/grackle.rb
+- lib/grackle/client.rb
+- lib/grackle/handlers.rb
+- lib/grackle/transport.rb
+- lib/grackle/utils.rb
+- spec/grackle_spec.rb
+- spec/spec_helper.rb
+- test/test_grackle.rb
+has_rdoc: true
+homepage: http://github.com/hayesdavis/grackle
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+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: []
+
+rubyforge_project: grackle
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Grackle is a library for the Twitter REST and Search API
+test_files: []
+