geoloqi 0.9.0

data/.gitignore

@@ -0,0 +1 @@
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+gemspec
+gem 'ruby-debug19'

data/README.markdown

@@ -0,0 +1,102 @@
+Geoloqi Library for Ruby
+===
+Powerful, flexible, lightweight interface to the awesome Geoloqi platform API! Uses Faraday, and can be used with Ruby 1.9 and EM-Synchrony for really fast, highly concurrent development.
+
+This library was developed with two goals in mind: to be as simple as possible, but also to be very powerful to allow for much higher-end development (multiple Geoloqi apps per instance, concurrency, performance).
+
+Installation
+---
+
+    gem install geoloqi
+
+Basic Usage
+---
+Geoloqi uses OAuth2 for authentication, but if you're only working with your own account, you don't need to go through the authorization steps! Simply go to your account settings on the [Geoloqi site](http://geoloqi.com), click on "Connections" and copy the OAuth 2 Access Token. You can use this token to run the following examples:
+
+	require 'geoloqi'
+	geoloqi = Geoloqi::Session.new :access_token => 'YOUR OAUTH2 ACCESS TOKEN GOES HERE'
+	response = geoloqi.get 'layer/info/Gx'
+	puts response.inspect
+
+This example returns a hash with the following:
+
+	{"layer_id"=>"Gx", "user_id"=>"4", "type"=>"normal", "name"=>"USGS Earthquakes",
+	 "description"=>"Real-time notifications of earthquakes near you.",
+	 "icon"=>"http://beta.geoloqi.com/images/earthquake-layer.png", "public"=>"1",
+	 "url"=>"https://a.geoloqi.com/layer/description/Gx", "subscription"=>false, "settings"=>false}
+
+Both GET and POST are supported. To send a POST to create a place (in this case, the entire city of Portland, Oregon):
+
+	response = geoloqi.post 'place/create', {
+	  "layer_id" => "1Wn",
+	  "name" => "3772756364",
+	  "latitude" => "45.5037078163837",
+	  "longitude" => "-122.622699737549",
+	  "radius" => "3467.44",
+	  "extra" => {
+	    "description" => "Portland",
+	     "url" => "http://en.wikipedia.org/wiki/Portland"
+	  }
+	}
+
+This returns response['place_id'], which you can use to store and/or remove the place:
+
+	response = geoloqi.post "place/delete/#{response['place_id']}"
+
+Which returns response['result'] with a value of "ok".
+
+Implementing OAuth2
+---
+
+OAuth2 has been implemented so that it's very easy to store the session's authorization data in a hash. If the access token expires or becomes invalid, the refresh token is used to retrieve a fresh token. This is done automatically, so you don't have to worry about it. Just store the hash in a session, feed it back in on each request and you're good to go.
+
+Here is a simple Sinatra example implementing the OAuth2 flow with Geoloqi:
+
+	require 'rubygems'
+	require 'sinatra'
+	require 'geoloqi'
+
+	GEOLOQI_REDIRECT_URI = 'http://yourwebsite.net'
+
+	enable :sessions
+
+	def geoloqi
+	  @geoloqi ||= Geoloqi::Session.new :auth => session[:geoloqi_auth],
+	                                    :config => {:client_id => 'YOUR OAUTH CLIENT ID',
+	                                                :client_secret => 'YOUR CLIENT SECRET'}
+	end
+
+	get '/?' do
+	  session[:geoloqi_auth] = geoloqi.get_auth(params[:code], GEOLOQI_REDIRECT_URI) if params[:code] && !geoloqi.access_token?
+	  redirect geoloqi.authorize_url(GEOLOQI_REDIRECT_URI) unless geoloqi.access_token?
+	  username = geoloqi.get('account/username')['username']
+	  "You have successfully logged in as #{username}!"
+	end
+
+Now, here's a power example: Uses [sinatra-synchrony](http://github.com/kyledrake/sinatra-synchrony) to provide a massive concurrency improvement via EventMachine. This will allow your app to serve other requests, the app will not hang while waiting for content from the Geoloqi API. Works on anything that supports Thin (Rack, EY, Heroku, etc):
+
+	# To install deps: gem install sinatra sinatra-synchrony geoloqi
+	# To run from command line: ruby sinatra_synchrony.rb -s thin
+	require 'rubygems'
+	require 'sinatra'
+	require 'sinatra/synchrony'
+	require 'geoloqi'
+
+	GEOLOQI_REDIRECT_URI = 'http://example.com'
+
+	enable :sessions
+
+	configure do
+	  Geoloqi.config :client_id => 'YOUR OAUTH CLIENT ID', :client_secret => 'YOUR CLIENT SECRET', :adapter => :em_synchrony
+	end
+
+	def geoloqi
+	  @geoloqi ||= Geoloqi::Session.new :auth => session[:geoloqi_auth]
+	end
+
+	get '/?' do
+	  session[:geoloqi_auth] = geoloqi.get_auth(params[:code], GEOLOQI_REDIRECT_URI) if params[:code] && !geoloqi.access_token?
+	  redirect geoloqi.authorize_url(GEOLOQI_REDIRECT_URI) unless geoloqi.access_token?
+	  username = geoloqi.get('account/username')['username']
+	  "You have successfully logged in as #{username}!"
+	end

data/examples/simple.rb

@@ -0,0 +1,26 @@
+# Create a layer, create a place on the layer, and then delete the place and the layer.
+
+require 'rubygems'
+require 'geoloqi'
+
+geoloqi = Geoloqi::Session.new :oauth_token => 'YOUR OAUTH TOKEN GOES HERE'
+
+layer_id = geoloqi.post('layer/create', :name => 'Test Layer')['layer_id']
+
+puts geoloqi.get("layer/info/#{layer_id}")
+
+place_id = geoloqi.post('place/create', {
+  "layer_id" => layer_id,
+  "name" => "Munich on the Willamette",
+  "latitude" => "45.5037078163837",
+  "longitude" => "-122.622699737549",
+  "radius" => "3467.44",
+  "extra" => {
+    "description" => "Portland",
+    "url" => "http://en.wikipedia.org/wiki/Portland,_Oregon"
+  }
+})['place_id']
+
+puts geoloqi.post("place/delete/#{place_id}")
+
+puts geoloqi.post("layer/delete/#{layer_id}")

data/examples/sinatra.rb

@@ -0,0 +1,21 @@
+# A simple Sinatra example demonstrating OAuth2 implementation with Geoloqi
+
+require 'rubygems'
+require 'sinatra'
+require 'geoloqi'
+
+GEOLOQI_REDIRECT_URI = 'http://example.com'
+
+enable :sessions
+
+def geoloqi
+  Geoloqi.config :client_id => 'YOUR OAUTH CLIENT ID', :client_secret => 'YOUR CLIENT SECRET'
+  @geoloqi ||= Geoloqi::Session.new :auth => session[:geoloqi_auth]
+end
+
+get '/?' do
+  session[:geoloqi_auth] = geoloqi.get_auth(params[:code], GEOLOQI_REDIRECT_URI) if params[:code] && !geoloqi.access_token?
+  redirect geoloqi.authorize_url(GEOLOQI_REDIRECT_URI) unless geoloqi.access_token?
+  username = geoloqi.get('account/username')['username']
+  "You have successfully logged in as #{username}!"
+end

data/examples/sinatra_synchrony.rb

@@ -0,0 +1,29 @@
+# A simple Sinatra example demonstrating OAuth2 implementation with Geoloqi
+# This version of the example is powerful! It uses sinatra-synchrony to implement real concurrency with EventMachine. 
+# Your calls to the Geoloqi api will not block the app from serving other requests!
+# Run this example with Thin (which uses EventMachine under the hood): ruby sinatra_synchrony.rb -s thin
+# Works on anything that supports Thin (Rack, EY, Heroku, etc..)
+
+require 'rubygems'
+require 'sinatra'
+require 'sinatra/synchrony'
+require 'geoloqi'
+
+GEOLOQI_REDIRECT_URI = 'http://example.com'
+
+enable :sessions
+
+configure do
+  Geoloqi.config :client_id => 'YOUR OAUTH CLIENT ID', :client_secret => 'YOUR CLIENT SECRET', :adapter => :em_synchrony
+end
+
+def geoloqi
+  @geoloqi ||= Geoloqi::Session.new :auth => session[:geoloqi_auth]
+end
+
+get '/?' do
+  session[:geoloqi_auth] = geoloqi.get_auth(params[:code], GEOLOQI_REDIRECT_URI) if params[:code] && !geoloqi.access_token?
+  redirect geoloqi.authorize_url(GEOLOQI_REDIRECT_URI) unless geoloqi.access_token?
+  username = geoloqi.get('account/username')['username']
+  "You have successfully logged in as #{username}!"
+end

data/geoloqi.gemspec

@@ -0,0 +1,25 @@
+require './lib/geoloqi/version.rb'
+Gem::Specification.new do |s|
+  s.name = 'geoloqi'
+  s.version = Geoloqi::VERSION
+  s.authors = ['Kyle Drake', 'Aaron Parecki']
+  s.email = ['kyledrake@gmail.com', 'aaron@parecki.com']
+  s.homepage = 'https://github.com/kyledrake/geoloqi-ruby'
+  s.summary = 'Powerful, flexible, lightweight interface to the awesome Geoloqi platform API'
+  s.description = 'Powerful, flexible, lightweight interface to the awesome Geoloqi platform API! Uses Faraday, '+
+                  'and can be used with Ruby 1.9 and EM-Synchrony for really fast, highly concurrent development.'
+
+  s.files = `git ls-files`.split("\n")
+  s.require_paths = %w[lib]
+  s.rubyforge_project = s.name
+  s.required_rubygems_version = '>= 1.3.4'
+
+  s.add_dependency 'json'
+  s.add_dependency 'faraday'
+
+  s.add_development_dependency 'wrong', '= 0.5.0'
+  s.add_development_dependency 'minitest'
+  s.add_development_dependency 'em-http-request'
+  s.add_development_dependency 'em-synchrony'
+  s.add_development_dependency 'webmock'
+end

data/lib/geoloqi.rb

@@ -0,0 +1,26 @@
+require 'json'
+require 'faraday'
+require 'logger'
+require 'geoloqi/config'
+require 'geoloqi/error'
+require 'geoloqi/session'
+require 'geoloqi/version'
+
+module Geoloqi
+  API_VERSION = 1
+  API_URL = 'https://api.geoloqi.com'
+  OAUTH_URL = 'https://beta.geoloqi.com/oauth/authorize'
+  @@adapter = :net_http
+  @@enable_logging = false
+  @@config = nil
+
+  def self.config(opts=nil)
+    return @@config if opts.nil?
+    @@config = Config.new opts
+  end
+
+  def self.authorize_url(client_id=nil, redirect_uri=nil)
+    raise "client_id required to authorize url. Pass with Geoloqi.config" unless client_id
+    "#{OAUTH_URL}?response_type=code&client_id=#{Rack::Utils.escape client_id}&redirect_uri=#{Rack::Utils.escape redirect_uri}"
+  end
+end

data/lib/geoloqi/config.rb

@@ -0,0 +1,18 @@
+module Geoloqi
+  class Config
+    attr_accessor :client_id, :client_secret, :adapter, :enable_logging
+    def initialize(opts={})
+      opts.each {|k,v| send("#{k}=", v)}
+      self.enable_logging ||= false
+      raise ArgumentError, 'enable_logging must be boolean' unless [true, false].include? self.enable_logging
+    end
+
+    def client_id?
+      !client_id.nil? && !client_id.empty?
+    end
+
+    def client_secret?
+      !client_secret.nil? && !client_secret.empty?
+    end
+  end
+end

data/lib/geoloqi/error.rb

@@ -0,0 +1,10 @@
+module Geoloqi
+  class ApiError < StandardError
+    def initialize(type, message=nil)
+      type += " - #{message}" if message
+      super type
+    end
+  end
+  
+  class Error < StandardError; end
+end

data/lib/geoloqi/session.rb

@@ -0,0 +1,123 @@
+module Geoloqi
+  class Session
+    attr_reader :auth
+    attr_accessor :config
+
+    def initialize(opts={})
+      opts[:config] = Geoloqi::Config.new opts[:config] if opts[:config].is_a? Hash
+      @config = opts[:config] || (Geoloqi.config || Geoloqi::Config.new)
+      self.auth = opts[:auth] || {}
+      self.auth[:access_token] = opts[:access_token] if opts[:access_token]
+
+      @connection = Faraday.new(:url => API_URL) do |builder|
+        builder.response :logger if @config.enable_logging
+        builder.adapter  @config.adapter || :net_http
+      end
+    end
+
+    def auth=(hash)
+      @auth = hash.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+    end
+
+    def access_token
+      @auth[:access_token]
+    end
+
+    def access_token?
+      !access_token.nil?
+    end
+
+    def authorize_url(redirect_uri)
+      Geoloqi.authorize_url @config.client_id, redirect_uri
+    end
+
+    def get(path)
+      run :get, path
+    end
+
+    def post(path, body=nil)
+      run :post, path, body
+    end
+
+    def run(meth, path, body=nil)
+      renew_access_token! if auth[:expires_at] && auth[:expires_at] <= Time.now
+
+      body = body.to_json if body.is_a? Hash
+      
+      retry_attempt = 0
+      begin
+        response = @connection.send(meth) do |req|
+          req.url "/#{API_VERSION.to_s}/#{path.gsub(/^\//, '')}"
+          req.headers = headers
+          req.body = body if body
+        end
+
+        json = JSON.parse response.body
+        raise ApiError.new(json['error'], json['error_description']) if json.is_a?(Hash) && json['error']
+      rescue Geoloqi::ApiError
+        raise Error.new('Unable to procure fresh access token from API on second attempt') if retry_attempt > 0
+        if json['error'] == 'expired_token'
+          retry_attempt += 1
+          retry
+        else
+          fail
+        end
+      end
+      json
+    end
+
+    # TODO: DRY and refactor
+    def renew_access_token!
+      require 'client_id and client_secret are required to get access token' unless @config.client_id? && @config.client_secret?
+      args = {:client_id => @config.client_id,
+              :client_secret => @config.client_secret,
+              :grant_type => 'refresh_token',
+              :refresh_token => auth[:refresh_token]}
+
+      response = @connection.post do |req|
+        req.url "/#{API_VERSION.to_s}/oauth/token"
+        req.headers = headers false
+        req.body = args.to_json
+      end
+
+      auth = JSON.parse response.body
+
+      # expires_at is likely incorrect. I'm chopping 5 seconds
+      # off to allow for a more graceful failover.
+      auth['expires_at'] = (Time.now + @expires_in.to_i)-5
+
+      self.auth = JSON.parse response.body
+      self.auth
+    end
+
+    def get_auth(code, redirect_uri)
+      require 'client_id and client_secret are required to get access token' unless @config.client_id? && @config.client_secret?
+      args = {:client_id => @config.client_id,
+              :client_secret => @config.client_secret,
+              :code => code,
+              :grant_type => 'authorization_code',
+              :redirect_uri => redirect_uri}
+
+      response = @connection.post do |req|
+        req.url "/#{API_VERSION.to_s}/oauth/token"
+        req.headers = headers false
+        req.body = args.to_json
+      end
+
+      auth = JSON.parse response.body
+
+      # expires_at is likely incorrect. I'm chopping 5 seconds
+      # off to allow for a more graceful failover.
+      auth['expires_at'] = (Time.now + @expires_in.to_i)-5
+
+      self.auth = JSON.parse response.body
+      self.auth
+    end
+
+    def headers(with_oauth=true)
+      headers = {'Content-Type' => 'application/json', 'User-Agent' => "geoloqi-ruby #{Geoloqi::VERSION}", 'Accept' => 'application/json'}
+      headers['Authorization'] = "OAuth #{access_token}" if with_oauth
+      headers
+    end
+  end
+end

data/lib/geoloqi/version.rb

@@ -0,0 +1,3 @@
+module Geoloqi
+  VERSION = '0.9.0'
+end

data/spec/geoloqi_spec.rb

@@ -0,0 +1,198 @@
+raise ArgumentError, 'usage: be ruby spec/geoloqi_spec.rb "client_id" "client_secret" "access_token"' unless ARGV.length == 3
+Bundler.setup
+require './lib/geoloqi.rb'
+require 'minitest/autorun'
+require 'wrong'
+require 'wrong/adapters/minitest'
+require 'webmock'
+
+Wrong.config.alias_assert :expect
+
+describe Geoloqi do
+  it 'reads geoloqi config' do
+    Geoloqi.config :client_id => 'client_id', :client_secret => 'client_secret'
+    expect { Geoloqi.config.is_a?(Geoloqi::Config) }
+    expect { Geoloqi.config.client_id == 'client_id' }
+    expect { Geoloqi.config.client_secret == 'client_secret' }
+  end
+
+  it 'returns authorize url' do
+    authorize_url = Geoloqi.authorize_url 'test', 'http://blah.blah/test'
+    expect { authorize_url == "#{Geoloqi::OAUTH_URL}?"+
+                              'response_type=code&'+
+                              "client_id=#{Rack::Utils.escape 'test'}&"+
+                              "redirect_uri=#{Rack::Utils.escape 'http://blah.blah/test'}" }
+  end
+end
+
+describe Geoloqi::Config do
+  it 'throws exception if non-boolean value is fed to logging' do
+    expect { rescuing { Geoloqi.config(:client_id => '', :client_secret => '', :enable_logging => :cats )}.class == ArgumentError }
+  end
+
+  it 'correctly checks booleans for client_id and client_secret' do
+    [:client_id, :client_secret].each do |k|
+      expect { Geoloqi.config(k => '').send("#{k}?") == false }
+      expect { Geoloqi.config(k => nil).send("#{k}?") == false }
+      expect { Geoloqi.config(k => 'lol').send("#{k}?") == true }
+    end
+  end
+end
+
+describe Geoloqi::Session do
+  describe 'with nothing passed' do
+    before do
+      @session = Geoloqi::Session.new
+    end
+
+    it 'should not find access token' do
+      expect { !@session.access_token? }
+    end
+  end
+
+  describe 'with access token and no config' do
+    before do
+      @session = Geoloqi::Session.new :access_token => ARGV[2]
+    end
+
+    it 'successfully makes call to api with forward slash' do
+      response = @session.get '/layer/info/Gx'
+      expect { response['layer_id'] == 'Gx' }
+    end
+
+    it 'successfully makes call to api without forward slash' do
+      response = @session.get '/layer/info/Gx'
+      expect { response['layer_id'] == 'Gx' }
+    end
+
+    it 'creates a layer, reads its info, and then deletes the layer' do
+      layer_id = @session.post('/layer/create', :name => 'Test Layer')['layer_id']
+      layer_info = @session.get "/layer/info/#{layer_id}"
+      layer_delete = @session.post "/layer/delete/#{layer_id}"
+
+      expect { layer_id.is_a?(String) }
+      expect { !layer_id.empty? }
+      expect { layer_info['name'] == 'Test Layer' }
+      expect { layer_delete['result'] == 'ok' }
+    end
+  end
+
+  describe 'with oauth id, secret, and access token via Geoloqi::Config' do
+    it 'should load config' do
+      @session = Geoloqi::Session.new :access_token => ARGV[2], :config => Geoloqi::Config.new(:client_id => ARGV[0],
+                                                                                               :client_secret => ARGV[1])
+      expect { @session.config.client_id == ARGV[0] }
+      expect { @session.config.client_secret == ARGV[1] }
+    end
+  end
+
+  describe 'with em synchrony adapter and access token' do
+    it 'makes call to api' do
+      session = Geoloqi::Session.new :access_token => ARGV[2], :config => {:adapter => :em_synchrony}
+      response = session.get 'layer/info/Gx'
+      expect { response['layer_id'] == 'Gx' }
+    end
+  end
+
+  describe 'with client id, client secret, and access token via direct hash' do
+    before do
+      @session = Geoloqi::Session.new :access_token => ARGV[2], :config => {:client_id => ARGV[0], :client_secret => ARGV[1]}
+    end
+
+    it 'should return access token' do
+      expect { @session.access_token == ARGV[2] }
+    end
+
+    it 'should recognize access token exists' do
+      expect { @session.access_token? }
+    end
+
+    it 'gets authorize url' do
+      authorize_url = @session.authorize_url('http://blah.blah/test')
+      expect { authorize_url == "#{Geoloqi::OAUTH_URL}?"+
+                                "response_type=code&"+
+                                "client_id=#{Rack::Utils.escape ARGV[0]}&"+
+                                "redirect_uri=#{Rack::Utils.escape 'http://blah.blah/test'}" }
+    end
+  end
+
+  describe 'with bunk access token' do
+    before do
+      @session = Geoloqi::Session.new :access_token => 'hey brah whats up let me in its cool 8)'
+    end
+
+    it 'fails with an exception' do
+      expect { rescuing { @session.get 'message/send' }.message == 'invalid_token' }
+    end
+  end
+
+  describe 'with config' do
+    before do
+      @session = Geoloqi::Session.new :config => {:client_id => ARGV[0], :client_secret => ARGV[1]}
+    end
+
+    it 'retrieves auth with mock' do
+      WebMock.disable_net_connect!
+      begin
+        response = @session.get_auth('1234', 'http://test.site/')
+      ensure
+        WebMock.allow_net_connect!
+      end
+      expect { response == {:access_token => 'access_token1234',
+                            :scope => nil,
+                            :expires_in => '86400',
+                            :refresh_token => 'refresh_token1234'} }
+    end
+  end
+  
+  describe 'with config and expired auth' do
+    before do
+      @session = Geoloqi::Session.new :config => {:client_id => ARGV[0], :client_secret => ARGV[1]},
+                                      :auth => { :access_token => 'access_token1234',
+                                                 :scope => nil,
+                                                 :expires_in => '86400',
+                                                 :expires_at => Time.at(0),
+                                                 :refresh_token => 'refresh_token1234' }
+    end
+    
+    it 'retrieves new access token and retries query if expired' do
+      WebMock.disable_net_connect!
+      begin
+        @session.get('account/username')
+      ensure
+        WebMock.allow_net_connect!
+      end
+      expect { @session.auth[:access_token] == 'access_token4567' }
+    end
+  end
+end
+
+include WebMock::API
+
+stub_request(:post, "https://api.geoloqi.com/1/oauth/token").
+  with(:body => {:client_id => ARGV[0],
+                 :client_secret => ARGV[1],
+                 :code => "1234",
+                 :grant_type => "authorization_code",
+                 :redirect_uri => "http://test.site/"}.to_json).
+  to_return(:status => 200,
+            :body => {:access_token => 'access_token1234',
+                      :scope => nil,
+                      :expires_in => '86400',
+                      :refresh_token => 'refresh_token1234'}.to_json)
+
+stub_request(:post, "https://api.geoloqi.com/1/oauth/token").
+  with(:body => {:client_id => ARGV[0],
+                 :client_secret => ARGV[1],
+                 :grant_type => "refresh_token",
+                 :refresh_token => "refresh_token1234"}.to_json).
+  to_return(:status => 200,
+            :body => {:access_token => 'access_token4567',
+                      :scope => nil,
+                      :expires_in => '5000',
+                      :refresh_token => 'refresh_token4567'}.to_json)
+
+stub_request(:get, "https://api.geoloqi.com/1/account/username").
+  with(:headers => {'Authorization'=>'OAuth access_token4567'}).
+  to_return(:status => 200,
+            :body => {'username' => 'pikachu4lyfe'}.to_json)

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification 
+name: geoloqi
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.9.0
+platform: ruby
+authors: 
+- Kyle Drake
+- Aaron Parecki
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-05 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: faraday
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: wrong
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 0.5.0
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: em-http-request
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: em-synchrony
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: webmock
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id007
+description: Powerful, flexible, lightweight interface to the awesome Geoloqi platform API! Uses Faraday, and can be used with Ruby 1.9 and EM-Synchrony for really fast, highly concurrent development.
+email: 
+- kyledrake@gmail.com
+- aaron@parecki.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.markdown
+- examples/simple.rb
+- examples/sinatra.rb
+- examples/sinatra_synchrony.rb
+- geoloqi.gemspec
+- lib/geoloqi.rb
+- lib/geoloqi/config.rb
+- lib/geoloqi/error.rb
+- lib/geoloqi/session.rb
+- lib/geoloqi/version.rb
+- spec/geoloqi_spec.rb
+has_rdoc: true
+homepage: https://github.com/kyledrake/geoloqi-ruby
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.3.4
+requirements: []
+
+rubyforge_project: geoloqi
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Powerful, flexible, lightweight interface to the awesome Geoloqi platform API
+test_files: []
+