rapidash 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: eb726775f243e6328acdfa4a53fba2ecbb81727d
+  data.tar.gz: fe0fdea46f6798d999095c5acf7d337c291cba14
+SHA512:
+  metadata.gz: 16a571aab676ca4d1f8f4209abbe3104184920c78f65349dbf50f12f6abf089f4347fefc66f57b154a55fd0752a3a548432a29fdd783748293de30f9d9ac0b74
+  data.tar.gz: fd8f336dc1436a0ca683c16a692006851dd6f3e9e5eddf0afc7d558740b1006dbbb66b4b92bf47a5656f04d91e1891c06952b3a15d7714788accc4a6c96f289f

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rapidash.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Gary 'Gazler' Rennie
+
+MIT License
+
+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/README.md

@@ -0,0 +1,116 @@
+# Rapidash
+
+Rapidash is an opinionated core for you to build a client for your API on.  The goal is to define a standard way that developers can quickly write a client for the consumption of their RESTful API.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rapidash'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rapidash
+
+## Usage
+
+### Resources
+
+Resources can be defined as follows:
+
+    class Users < Rapidash::Base
+      url "users"
+    end
+
+### Client
+
+The main thing a client must do is define a method, `oauth` and `http` are currently supported.  You can also define resources which links a resource as defined above to the client.
+
+    class Client < Rapidash::Client
+      method :oauth
+      resource :users
+    end
+
+OAuth provides an initialize method which you can see in the Facebook client example.
+
+Currently when using the HTTP method, you will need to define your own initialize method to set the site in use.
+
+### Making calls
+
+    client = Client.new
+    client.site = "http://example.com/"
+    client.users #Returns an instance of Users
+    client.users! #Will make a call to "http://example.com/users
+    client.users!(1) #Will make a call to http://example.com/users/1
+    client.users!(params => {:page => 1}}) # Will make a call to http://example.com/users?page=1
+
+## Example Clients
+
+### Facebook
+
+    require 'rapidash'
+
+    class Me < Rapidash::Base
+      url "me"
+    end
+
+    class Facebook < Rapidash::Client
+      method :oauth
+      resource :me
+    end
+
+    client = Facebook`.new({
+      :site => "https://graph.facebook.com",
+      :uid => "YOUR_ID",
+      :secret => "YOUR_SECRET",
+      :access_token => "YOUR_TOKEN"
+    })
+    p client.me!.first_name #Gary
+
+### Github
+
+  require 'rapidash'
+
+  class Users < Rapidash::Base
+    url :users
+
+    def user(name)
+      self.url += "/#{name}"
+      self
+    end
+
+    def repos!
+      self.url += "/repos"
+      call!
+    end
+
+    def user!(name)
+      user(name)
+      call!
+    end
+  end
+
+  class Github < Rapidash::Client
+    method :http
+    resource :users
+
+    def initialize
+      @site = "https://api.github.com/"
+    end
+  end
+
+  client = Github.new
+  p client.users.user!("Gazler").name           #Gary Rennie
+  p client.users.user("Gazler").repos![0].name  #Githug
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/rapidash.rb

@@ -0,0 +1,17 @@
+require "rapidash/version"
+
+require "rapidash/errors"
+
+require "rapidash/response"
+
+require "rapidash/clientable"
+require "rapidash/client"
+
+require "rapidash/urlable"
+require "rapidash/base"
+
+require "rapidash/http_client"
+require "rapidash/oauth_client"
+
+module Rapidash
+end

data/lib/rapidash/base.rb

@@ -0,0 +1,20 @@
+module Rapidash
+  class Base
+
+    include Urlable
+    attr_accessor :url, :options, :client
+
+    def initialize
+      raise ConfigurationError.new "Missing URL attribute on the resource, set it by calling `url` in your resource class"
+    end
+
+
+    def call!
+      self.options ||= {}
+      self.options[:header] ||= {}
+      self.options[:header]["content-type"] = "application/json"
+      method = self.options.delete(:method) || :get
+      client.send(method, url, self.options)
+    end
+  end
+end

data/lib/rapidash/client.rb

@@ -0,0 +1,9 @@
+module Rapidash
+  class Client
+    include Clientable
+
+      def initialize
+        raise ConfigurationError.new "Missing Method, define using `method` on your client"
+      end
+  end
+end

data/lib/rapidash/clientable.rb

@@ -0,0 +1,37 @@
+module Rapidash
+  module Clientable
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      def method(method)
+        if method == :http
+          include HTTPClient
+        elsif method == :oauth
+          include OAuthClient
+        else
+          raise ConfigurationError.new "Invalid API Authentication Method"
+        end
+      end
+
+      def resource(name)
+        mod = self.to_s.split("::")[0...-1]
+        if mod.empty?
+          mod = Kernel
+        else
+          mod = Kernel.const_get(mod.join("::"))
+        end
+        klass = mod.const_get(name.capitalize)
+        define_method(name) do |*args|
+          klass.new(self, *args)
+        end
+        define_method("#{name}!".to_sym) do |*args|
+          klass.new(self, *args).call!
+        end
+      end
+    end
+  end
+end

data/lib/rapidash/errors.rb

@@ -0,0 +1,4 @@
+module Rapidash
+  class ParseError < StandardError; end
+  class ConfigurationError < StandardError; end
+end

data/lib/rapidash/http_client.rb

@@ -0,0 +1,39 @@
+require 'faraday'
+
+module Rapidash
+  module HTTPClient
+
+    attr_accessor :site
+    attr_writer :connection
+
+    def site=(value)
+      @connection = nil
+      @site = value
+    end
+
+    def connection
+      @connection ||= Faraday.new(site)
+    end
+
+    def get(url, options = {})
+      request(:get, url, options)
+    end
+
+    def post(url, options = {})
+      request(:post, url, options)
+    end
+
+    def request(verb, url, options = {})
+      url = connection.build_url(url, options[:params]).to_s
+      response = connection.run_request(verb, url, options[:body], options[:header])
+
+      case response.status.to_s[0]
+      #Handle redirects
+      when "3"
+        request(verb, response.headers["location"], options)
+      when "2"
+        return Response.new(response)
+      end
+    end
+  end
+end

data/lib/rapidash/oauth_client.rb

@@ -0,0 +1,54 @@
+require 'oauth2'
+require 'hashie'
+
+module Rapidash
+  module OAuthClient
+
+    attr_accessor :secret, :uid, :access_token, :site
+
+    def initialize(options)
+      [:uid, :secret, :site].each do |key|
+        if options[key]
+          self.send("#{key.to_s}=".to_sym, options[key])
+        else
+          raise ConfigurationError.new "Missing #{key} value" 
+        end
+      end
+      self.access_token = options[:access_token] if options[:access_token]
+    end
+
+    def get(url, params = {})
+      request(:get, url, :params => params)
+    end
+
+    def request(verb, url, options = {})
+      response = oauth_access_token.send(verb.to_sym, "#{site}/#{url}", options)
+      body = JSON.parse(response.body)
+      if body.kind_of?(Hash)
+        return Hashie::Mash.new(body)
+      elsif body.kind_of?(Array)
+        output = []
+        body.each do |el|
+          output << Hashie::Mash.new(el)
+        end
+        return output
+      end
+    end
+
+    def access_token_from_code(code, url)
+      token = client.auth_code.get_token(code, :redirect_uri => url)
+      self.access_token = token.token
+    end
+
+    private
+
+    def client
+      @oauth_client ||= ::OAuth2::Client.new(uid, secret, :site => site) 
+    end
+
+    def oauth_access_token
+      @oauth_access_token ||= ::OAuth2::AccessToken.new(client, access_token)
+    end
+  end
+end
+

data/lib/rapidash/response.rb

@@ -0,0 +1,29 @@
+require 'json'
+require 'hashie'
+
+module Rapidash
+  class Response
+
+    class << self
+      def new(response)
+        type = response.headers["content-type"]
+        if type.include?("application/json")
+          body = JSON.parse(response.body)
+          if body.kind_of?(Hash)
+            return Hashie::Mash.new(body)
+          elsif body.kind_of?(Array)
+            output = []
+            body.each do |el|
+              output << Hashie::Mash.new(el)
+            end
+            return output
+          end
+        else
+          raise ParseError.new("Cannot parse content type: #{response.headers["content-type"]}")
+        end
+      end
+    end
+
+  end
+end
+

data/lib/rapidash/urlable.rb

@@ -0,0 +1,28 @@
+module Rapidash
+  module Urlable
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def url(url)
+        self.class_eval do
+          define_method(:initialize) do |*args|
+            @client, id, options = args
+            if id.is_a?(Hash)
+              options = id
+              id = nil
+            end
+            @options ||= {}
+            options ||= {}
+            @options.merge!(options)
+            @url = url.to_s
+            @url += "/#{id}" if id
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/rapidash/version.rb

@@ -0,0 +1,3 @@
+module Rapidash
+  VERSION = "0.0.1"
+end

data/rapidash.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rapidash/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rapidash"
+  spec.version       = Rapidash::VERSION
+  spec.authors       = ["Gary 'Gazler' Rennie"]
+  spec.email         = ["gazler@gmail.com"]
+  spec.description   = %q{Evolve your API}
+  spec.summary       = %q{An opinionated core for creating clients for RESTful APIs quickly}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 2.8"
+
+  spec.add_dependency 'faraday', '~> 0.8'
+  spec.add_dependency "oauth2", "~>0.6"
+  spec.add_dependency "hashie", "~>1.2"
+
+end

data/spec/rapidash/base_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+class BaseTester < Rapidash::Base
+  url "tester"
+end
+
+class InvalidApiTester < Rapidash::Base
+end
+
+
+describe Rapidash::Base do
+
+  describe ".initialize" do
+
+    it "should raise an error" do
+      expect {
+        InvalidApiTester.new
+      }.to raise_error(Rapidash::ConfigurationError)
+    end
+
+    it "should not raise an error if url has been called" do
+      expect {
+        BaseTester.new.should be_valid
+      }.to_not raise_error(Rapidash::ConfigurationError)
+    end
+
+  end
+
+  let(:client) { mock }
+  let(:headers) { {"content-type" => "application/json"} }
+  let (:subject) { BaseTester.new(client) }
+
+  describe ".call!" do
+    it "should call get on the client" do
+      subject.url = "tester/1"
+      client.should_receive(:get).with("tester/1", {:header => headers})
+      subject.call!
+    end
+
+
+    it "should call a post on the client if set" do
+      client.should_receive(:post).with("tester", {:header => headers})
+      subject.options = {:method => :post}
+      subject.url = "tester"
+      subject.call!
+    end
+  end
+
+end

data/spec/rapidash/client_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Rapidash::Client do
+  it "should raise an error when instantiated" do
+    expect {
+     Rapidash::Client.new
+    }.to raise_error(Rapidash::ConfigurationError)
+  end
+end

data/spec/rapidash/clientable_spec.rb

@@ -0,0 +1,99 @@
+require "spec_helper"
+
+class Rapidash::Users
+  def initialize(*args)
+  end
+end
+
+class Users 
+  def initialize(*args)
+  end
+end
+
+class Rapidash::ClientTester
+  include Rapidash::Clientable
+  resource :users
+end
+
+class ClientTester
+  include Rapidash::Clientable
+  resource :users
+end
+
+class OAuthClientTester
+  include Rapidash::Clientable
+  method :oauth
+end
+
+class HTTPClientTester
+  include Rapidash::Clientable
+  method :http
+end
+
+
+
+describe Rapidash::Clientable do
+
+  describe "#included" do
+    it "should include the resource method" do
+      Rapidash::ClientTester.methods.should include(:resource)
+    end
+
+    it "should include the method method" do
+      Rapidash::ClientTester.methods.should include(:method)
+    end
+  end
+
+  describe "#resource" do
+    it "should add a method with the name of the argument" do
+      Rapidash::ClientTester.new.methods.should include(:users)
+    end
+
+    it "should add a bang method with the name of the argument" do
+      Rapidash::ClientTester.new.methods.should include(:users!)
+    end
+  end
+
+  describe "#method" do
+
+    it "should include the HTTPClient" do
+      client = HTTPClientTester.new
+      client.class.ancestors.should include(Rapidash::HTTPClient)
+    end
+
+    it "should include the OAuthClient" do
+      client = OAuthClientTester.new({:uid => "foo", :secret => "bar", :site => "baz"})
+      client.class.ancestors.should include(Rapidash::OAuthClient)
+    end
+
+    it "should raise an error on anything else" do
+      expect {
+        class InvalidClientTester
+          include Rapidash::Clientable
+          method :invalid
+        end
+      }.to raise_error(Rapidash::ConfigurationError)
+    end
+    
+  end
+
+  describe ".users" do
+    it "should return an instance of the resource" do
+      Rapidash::ClientTester.new.users.class.should eql(Rapidash::Users)
+    end
+
+    it "should not use a namespace if not in a module" do
+      ClientTester.new.users.class.should eql(Users)
+    end
+  end
+
+  describe ".tickets!" do
+    it "should return an instance of the resource and call it" do
+      users = mock
+      Rapidash::Users.should_receive(:new).and_return(users)
+      users.should_receive(:call!)
+      Rapidash::ClientTester.new.users!
+    end
+  end
+
+end

data/spec/rapidash/http_client_spec.rb

@@ -0,0 +1,72 @@
+require "spec_helper"
+
+class HTTPTester
+  include Rapidash::HTTPClient
+end
+
+describe Rapidash::HTTPClient do
+
+  let!(:subject) { HTTPTester.new }
+
+  describe ".site=" do
+    it "should clear the connection variable" do
+      subject.instance_variable_get(:@connection).should eql(nil)
+      subject.connection
+      subject.instance_variable_get(:@connection).class.should eql(Faraday::Connection)
+      subject.site = "foo"
+      subject.instance_variable_get(:@connection).should eql(nil)
+    end
+
+    it "should set the site variable" do
+      subject.instance_variable_get(:@site).should eql(nil)
+      subject.site = "foo"
+      subject.instance_variable_get(:@site).should eql("foo")
+    end
+  end
+
+  describe ".connection" do
+    it "should create a Faraday object" do
+      subject.connection.class.should eql(Faraday::Connection)
+    end
+  end
+
+  describe ".get" do
+    it "should call request" do
+      subject.should_receive(:request).with(:get, "foo", {})
+      subject.get("foo")
+    end
+  end
+
+  describe ".get" do
+    it "should call request" do
+      subject.should_receive(:request).with(:post, "foo", {})
+      subject.post("foo")
+    end
+  end
+
+
+  describe ".request" do
+
+    let!(:valid_response) { OpenStruct.new(:status => "200")}
+    let!(:redirect_response) { OpenStruct.new(:status => "301", :headers => {"location" => "http://example.com/redirect"})}
+
+    before(:each) do
+      subject.site = "http://example.com"
+      Rapidash::Response.should_receive(:new).and_return("response")
+    end
+
+    it "should return a response object" do
+      subject.connection.should_receive(:run_request).with(:get, "http://example.com/foo", nil, nil).and_return(valid_response)
+      response = subject.request(:get, "foo")
+      response.should eql("response")
+    end
+
+    it "should perform a redirect" do
+      subject.connection.should_receive(:run_request).with(:get, "http://example.com/foo", nil, nil).and_return(redirect_response)
+      subject.connection.should_receive(:run_request).with(:get, "http://example.com/redirect", nil, nil).and_return(valid_response)
+      response = subject.request(:get, "foo")
+      response.should eql("response")
+    end
+  end
+
+end

data/spec/rapidash/oauth_client_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+class OAuthTester
+  include Rapidash::OAuthClient
+end
+
+describe Rapidash::OAuthClient do
+
+  let(:options) do
+    Hash({
+      :uid => "foo",
+      :secret => "bar",
+      :access_token => "baz",
+      :site => "http://example.com"
+    })
+ end 
+
+ let(:subject) { OAuthTester.new(options) }
+
+
+  describe ".site" do
+    it "should be example.com" do
+      subject.site.should eql("http://example.com")
+    end
+  end
+
+  describe ".access_token_from_code" do
+    it "should call livestax for the access token" do
+      auth_code = mock
+      client = mock
+      subject.stub(:client).and_return(client)
+      client.should_receive(:auth_code).and_return(auth_code)
+      auth_code.should_receive(:get_token).with("123", :redirect_uri => "http://localhost").and_return(OpenStruct.new(:token => "token"))
+      subject.access_token_from_code("123", "http://localhost").should eql("token")
+    end
+  end
+
+  describe ".client" do
+    it "should be an OAuth2::Client" do
+      subject.send(:client).class.should eql(OAuth2::Client)
+    end
+  end
+
+  describe ".oauth_access_token" do
+    it "should be an OAuth2::AccessToken" do
+      subject.send(:oauth_access_token).class.should eql(OAuth2::AccessToken)
+    end
+  end
+
+  describe ".get" do
+    it "should call request with the parameters" do
+      subject.should_receive(:request).with(:get, "me", :params => {:page => 1})
+      subject.get("me", {:page => 1})
+    end
+  end
+
+  describe ".request" do
+
+    let(:request) { mock }
+
+    describe "object returned from API call" do
+
+      let(:body) { {:foo => "bar"}.to_json }
+      let(:response) { OpenStruct.new(:body => body) }
+
+      before(:each) do
+        subject.stub(:oauth_access_token).and_return(request)
+        request.stub(:get).and_return(response)
+      end
+      it "should return a Hashie::Mash" do
+        subject.request(:get, "me").class.should eql(Hashie::Mash)
+      end
+
+      it "should return a traversable object" do
+        subject.request(:get, "me").foo.should eql("bar")
+      end
+
+    end
+
+    describe "array returned from API call" do
+
+      let(:body) { [{:foo => "bar"}, {:baz => "bra"}].to_json }
+      let(:response) { OpenStruct.new(:body => body) }
+
+      before(:each) do
+        subject.stub(:oauth_access_token).and_return(request)
+        request.stub(:get).and_return(response)
+      end
+      it "should return an array" do
+        subject.request(:get, "me").class.should eql(Array)
+      end
+
+      it "should return a traversable object" do
+        response = subject.request(:get, "me")
+        response[0].foo.should eql("bar")
+        response[1].baz.should eql("bra")
+      end
+
+    end
+  end
+
+
+end
+

data/spec/rapidash/response_spec.rb

@@ -0,0 +1,57 @@
+require 'json'
+require "spec_helper"
+
+def valid_response_object
+  body = {"foo" => "bar" }.to_json
+  OpenStruct.new({
+    :headers => {
+      "content-type" => "application/json"
+    },
+    :body => body
+  })
+end
+
+
+def valid_response_array
+  body = [{"foo" => "bar" }, {"baz" => "bra"}].to_json
+  OpenStruct.new({
+    :headers => {
+      "content-type" => "application/json"
+    },
+    :body => body
+  })
+end
+
+
+def invalid_response
+  OpenStruct.new({
+    :headers => {
+      "content-type" => "application/xml"
+    }
+  })
+end
+
+describe Rapidash::Response do
+
+  describe "#new" do
+    it "should parse JSON Objects" do
+      response = Rapidash::Response.new(valid_response_object)
+      response.foo.should eql("bar")
+    end
+
+    it "should parse JSON Arrays" do
+      response = Rapidash::Response.new(valid_response_array)
+      response[0].foo.should eql("bar")
+      response[1].baz.should eql("bra")
+    end
+
+
+    it "should raise an error on a non-json response" do
+      expect {
+        Rapidash::Response.new(invalid_response)
+      }.to raise_error(Rapidash::ParseError)
+    end
+  end
+
+
+end

data/spec/rapidash/urlable_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+class ApiTester
+  attr_accessor :url, :options, :client
+  include Rapidash::Urlable
+  url :foo
+end
+
+class ApiTesterNoUrl
+  include Rapidash::Urlable
+end
+
+describe Rapidash::Urlable do
+
+  let!(:client) { mock }
+
+  describe "#included" do
+    it "should add the url method" do
+      ApiTester.methods.should include(:url)
+    end
+  end
+
+  describe "#url" do
+    it "should override the initialize to set a url" do
+      ApiTesterNoUrl.new.instance_variable_get(:@url).should eql(nil)
+      ApiTester.new.instance_variable_get(:@url).should eql("foo")
+    end
+
+    it "should set options on the class" do
+      api = ApiTester.new(client, :option1 => "foo")
+      api.instance_variable_get(:@options).should eql({:option1 => "foo"})
+      api.instance_variable_get(:@url).should eql("foo")
+    end
+
+    it "should let an id be set on initialization" do
+      api = ApiTester.new(client, 1, :option1 => "foo")
+      api.instance_variable_get(:@options).should eql({:option1 => "foo"})
+      api.instance_variable_get(:@url).should eql("foo/1")
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require "./lib/rapidash"
+require "ostruct"

metadata

@@ -0,0 +1,161 @@
+--- !ruby/object:Gem::Specification
+name: rapidash
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Gary 'Gazler' Rennie
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.8'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: oauth2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description: Evolve your API
+email:
+- gazler@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/rapidash.rb
+- lib/rapidash/base.rb
+- lib/rapidash/client.rb
+- lib/rapidash/clientable.rb
+- lib/rapidash/errors.rb
+- lib/rapidash/http_client.rb
+- lib/rapidash/oauth_client.rb
+- lib/rapidash/response.rb
+- lib/rapidash/urlable.rb
+- lib/rapidash/version.rb
+- rapidash.gemspec
+- spec/rapidash/base_spec.rb
+- spec/rapidash/client_spec.rb
+- spec/rapidash/clientable_spec.rb
+- spec/rapidash/http_client_spec.rb
+- spec/rapidash/oauth_client_spec.rb
+- spec/rapidash/response_spec.rb
+- spec/rapidash/urlable_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.2
+signing_key: 
+specification_version: 4
+summary: An opinionated core for creating clients for RESTful APIs quickly
+test_files:
+- spec/rapidash/base_spec.rb
+- spec/rapidash/client_spec.rb
+- spec/rapidash/clientable_spec.rb
+- spec/rapidash/http_client_spec.rb
+- spec/rapidash/oauth_client_spec.rb
+- spec/rapidash/response_spec.rb
+- spec/rapidash/urlable_spec.rb
+- spec/spec_helper.rb