octoplex 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

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

data/README.md

@@ -0,0 +1,61 @@
+# Octoplex
+
+A lightweight wrapper around Github's v3 API
+
+## Installation
+
+``` ruby
+gem 'octoplex'
+```
+
+## Usage
+
+Octoplex provides both authenticated and unauthenticated usage, however authenticated usage assumes you have
+acquired an OAuth token for your user from another service, e.g. using Omniauth and Devise.
+
+If you haven't already done so, register your application with the Github API at [https://github.com/account/applications](https://github.com/account/applications)
+
+### Authenticated
+
+Initialise the client with an auth token:
+
+``` ruby
+Octoplex.client(:token => "OAUTH_TOKEN")
+```
+
+Request this users details:
+
+``` ruby
+Octoplex.user
+```
+
+Request a specific users details:
+
+``` ruby
+Octoplex.users('ivanvanderbyl')
+```
+
+All client methods are designed to match closely to the [Github v3 API](http://developer.github.com/v3/users/) REST methods.
+
+Example: Calling `Octoplex.user` will make an API call equivalent to `GET /user`
+
+Alternatively you can use `Octoplex` as a connection wrapper for the API:
+
+``` ruby
+Octoplex.get('/user')
+Octoplex.get('/user/repos')
+```
+    
+All requests return a `Hashr` object or `Array` of `Hashr` objects
+
+All requests on the new v3 API are rate limited, to find out your current usage you can query
+these two methods after each request:
+
+``` ruby
+Octoplex.rate_limit #=> 5000
+Octoplex.rate_limit_remaining #=> 4999
+```
+
+### Language note
+
+This library is written in International English, so if you're wondering why we've swapped your Zs for S, and added a U to colour – get a dictionary.

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+
+$: << 'lib'
+
+require "octoplex"
+require 'rake'
+require "rspec/core/rake_task"
+
+desc "Run all examples"
+RSpec::Core::RakeTask.new
+
+task :default => :spec

data/bin/octoplex_console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "rubygems"
+require 'irb'
+require 'irb/completion'
+require "bundler"
+Bundler.setup
+
+$: << 'lib'
+
+require "awesome_print"
+require "octoplex"
+
+IRB.start

data/lib/faraday/response/hashr.rb

@@ -0,0 +1,21 @@
+require 'hashr'
+
+module Faraday
+  class Response
+    class Hashr < Response::Middleware
+
+      def on_complete(env)
+        begin
+          if env[:body].is_a?(Array)
+            env[:body] = env[:body].map { |o| ::Hashr.new(o) }
+          else
+            env[:body] = ::Hashr.new(env[:body])
+          end
+        rescue
+          env[:body] = env[:body]
+        end
+      end
+
+    end
+  end
+end

data/lib/faraday/response/multi_json.rb

@@ -0,0 +1,23 @@
+require 'multi_json'
+require 'yajl'
+
+module Faraday
+  class Response
+    class MultiJson < Response::Middleware
+
+      def initialize(*args)
+        super
+        ::MultiJson.engine = :yajl
+      end
+
+      def on_complete(env)
+        begin
+          env[:body] = ::MultiJson.decode(env[:body])
+        rescue MultiJson::ParserError
+          env[:body] = nil
+        end
+      end
+
+    end
+  end
+end

data/lib/faraday/response/raise_octoplex_error.rb

@@ -0,0 +1,42 @@
+require 'faraday'
+require 'multi_json'
+
+# @api private
+module Faraday
+  class Response::RaiseOctoplexError < Response::Middleware
+    def on_complete(response)
+      case response[:status].to_i
+      when 400
+        raise Octoplex::BadRequest, error_message(response)
+      when 401
+        raise Octoplex::Unauthorized, error_message(response)
+      when 403
+        raise Octoplex::Forbidden, error_message(response)
+      when 404
+        raise Octoplex::NotFound, error_message(response)
+      when 406
+        raise Octoplex::NotAcceptable, error_message(response)
+      when 422
+        raise Octoplex::UnprocessableEntity, error_message(response)
+      when 500
+        raise Octoplex::InternalServerError, error_message(response)
+      when 501
+        raise Octoplex::NotImplemented, error_message(response)
+      when 502
+        raise Octoplex::BadGateway, error_message(response)
+      when 503
+        raise Octoplex::ServiceUnavailable, error_message(response)
+      end
+    end
+
+    def error_message(response)
+      message = if body = response[:body]
+        body = ::MultiJson.decode(body) if body.is_a? String
+        ": #{body[:error] || body[:message] || ''}"
+      else
+        ''
+      end
+      "#{response[:method].to_s.upcase} #{response[:url].to_s}: #{response[:status]}#{message}"
+    end
+  end
+end

data/lib/octoplex.rb

@@ -0,0 +1,45 @@
+require "octoplex/version"
+require "cgi"
+require "hashr"
+require "octoplex/errors"
+
+module Octoplex
+  autoload :Connection, 'octoplex/connection'
+  autoload :Client,     'octoplex/client'
+
+  class << self
+    # A global instance of the Client class
+    #
+    # Options:
+    #   :token - The OAuth token you have retrieved earlier.
+    #
+    def client(options = {})
+      @client ||= Octoplex::Client.new(options)
+    end
+
+    def discard_client!
+      @client = nil
+    end
+
+    # @private
+    def log
+      @log ||= begin
+        log = Logger.new($stdout)
+        log.level = Logger::INFO
+        log
+      end
+    end
+
+    # Delegate missing API calls to client, so we can do things like:
+    # Octoplex.users('octocat')
+    # Octoplex.user
+    # Octoplex.repos('octocat')
+    def method_missing(meth, *args, &blk)
+      if client.respond_to?(meth)
+        client.send(meth, *args, &blk)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/octoplex/client.rb

@@ -0,0 +1,51 @@
+module Octoplex
+  class Client
+
+    autoload :Root,       'octoplex/client/root'
+    autoload :Base,       'octoplex/client/base'
+    autoload :User,       'octoplex/client/user'
+    autoload :Repository, 'octoplex/client/repository'
+
+    include Octoplex::Client::Root
+
+    attr_accessor :options
+
+    def initialize(options = nil)
+      @options = options
+    end
+
+    def connection
+      @connection ||= Octoplex::Connection.new(options)
+    end
+
+    # The maximum number of API requests you can do this hour
+    # for this token.
+    def rate_limit
+      connection.rate_limit
+    end
+
+    # The number of API requests you have left this hour.
+    def rate_limit_remaining
+      connection.rate_limit_remaining
+    end
+
+    # API Helper methods
+
+    def get(path)
+      connection.get(path)
+    end
+
+    def post(path, body)
+      connection.post(path, body)
+    end
+
+    def put(path, body)
+      connection.put(path, body)
+    end
+
+    def delete(path)
+      connection.delete(path)
+    end
+
+  end
+end

data/lib/octoplex/client/base.rb

@@ -0,0 +1,15 @@
+module Octoplex
+  class Client
+    class Base < Hashr
+
+      attr_reader :client
+
+      def initialize(client, data)
+        @client = client
+
+        super(data)
+      end
+
+    end
+  end
+end

data/lib/octoplex/client/repository.rb

@@ -0,0 +1,48 @@
+module Octoplex
+  class Client
+    class Repository < Base
+
+      attr_reader :owner
+
+      def initialize(owner, client, data)
+        super(client, data)
+        @owner = owner
+      end
+
+
+
+      # GET /repos/:user/:repo
+
+      # GET /repos/:user/:repo/contributors
+      def contributors
+
+      end
+
+      # GET /repos/:user/:repo/languages
+      def languages
+
+      end
+
+      # GET /repos/:user/:repo/teams
+      def teams
+
+      end
+
+      # GET /repos/:user/:repo/branches
+      def branches
+
+      end
+
+      # Commits:
+      # GET /repos/:user/:repo/commits
+      # GET /repos/:user/:repo/commits/:sha
+      # GET /repos/:user/:repo/comments
+      # GET /repos/:user/:repo/commits/:sha/comments
+      # POST /repos/:user/:repo/commits/:sha/comments
+      # GET /repos/:user/:repo/comments/:id
+      # PATCH /repos/:user/:repo/comments/:id
+      # GET /repos/:user/:repo/compare/:base...:head
+
+    end
+  end
+end

data/lib/octoplex/client/root.rb

@@ -0,0 +1,37 @@
+module Octoplex
+  class Client
+    module Root
+
+      # GET /users/:user
+      # GET /users/:user/repos
+      def users(login)
+        (@users ||= {})[login] ||= Octoplex::API::User.new(self, get("/users/#{login}"))
+      end
+
+      # GET /user
+      # GET /user/repos
+      def user
+        @user ||= Octoplex::API::User.current
+      end
+
+      # GET /orgs/:org/repos
+      def orgs(login)
+        Octoplex::API::Organisation.find(login)
+      end
+
+      alias_method :organisations, :orgs
+      alias_method :organizations, :orgs
+
+      # GET /repos/:user/:repo
+      # GET /repos/:user/:repo/contributors
+      # GET /repos/:user/:repo/languages
+      # GET /repos/:user/:repo/teams
+      # GET /repos/:user/:repo/branches
+
+      def repos(user, repo)
+        (@repos ||= {})[user] ||= Octoplex::API::Repository.new(user, self, get("/repos/#{user}"))
+      end
+
+    end
+  end
+end

data/lib/octoplex/client/user.rb

@@ -0,0 +1,29 @@
+module Octoplex
+  class Client
+    class Users < Base
+
+
+
+      # class << self
+      #   def find(client, login)
+      #     new(client.get("/users/#{login}"))
+      #   end
+      #
+      #   def current(client)
+      #     new(client.get("/user"))
+      #   end
+      # end
+
+      # GET /users/:user/[repos]
+      # def repos
+      #   Octoplex::API::Repository.all
+      #   # get("/user/#{login}/repos")
+      # end
+
+      def repos
+        Octoplex::API::Repository.new(login, self, get("/users/repos"))
+      end
+
+    end
+  end
+end

data/lib/octoplex/connection.rb

@@ -0,0 +1,74 @@
+require "faraday"
+require "faraday/response/multi_json"
+require "faraday/response/hashr"
+require "faraday/response/raise_octoplex_error"
+
+module Octoplex
+  class Connection
+
+    attr_reader :conn, :options, :token, :rate_limit, :rate_limit_remaining
+
+    def initialize(options = {})
+      options ||= {}
+
+      @options = {
+        :token => nil,
+        :per_page => 100
+      }.update(options)
+
+      @token = options.delete(:token)
+      @rate_limit = @rate_limit_remaining = 0
+      setup
+    end
+
+    def setup
+      @conn = Faraday.new(:url => 'https://api.github.com') do |builder|
+        builder.use Faraday::Request::JSON
+        builder.use Faraday::Response::Logger
+        builder.use Faraday::Adapter::NetHttp
+        builder.use Faraday::Response::Hashr
+        builder.use Faraday::Response::RaiseOctoplexError
+        builder.use Faraday::Response::MultiJson
+      end
+    end
+
+    def authentication_param
+      {:access_token => token}
+    end
+
+    def get(path)
+      request(path, :get)
+    end
+
+    def post(path, body)
+      request(path, :post, body)
+    end
+
+    def put(path, body)
+      request(path, :put, body)
+    end
+
+    def delete(path)
+      request(path, :delete)
+    end
+
+    private
+
+    def request(path, method = :get, body = nil)
+      response = conn.send(method) do |req|
+        req.url(path, options)
+        req.body = body unless body.nil?
+        req.params['access_token'] = self.token if self.token.is_a?(String)
+      end
+
+      if response.env[:response_headers].has_key?('x-ratelimit-limit')
+        @rate_limit           = response.env[:response_headers]['x-ratelimit-limit'].to_i
+        @rate_limit_remaining = response.env[:response_headers]['x-ratelimit-remaining'].to_i
+      end
+
+      response.body
+    end
+
+  end
+
+end

data/lib/octoplex/errors.rb

@@ -0,0 +1,34 @@
+module Octoplex
+  # Custom error class for rescuing from all GitHub errors
+  class Error < StandardError; end
+
+  # Raised when GitHub returns a 400 HTTP status code
+  class BadRequest < Error; end
+
+  # Raised when GitHub returns a 401 HTTP status code
+  class Unauthorized < Error; end
+
+  # Raised when GitHub returns a 403 HTTP status code
+  class Forbidden < Error; end
+
+  # Raised when GitHub returns a 404 HTTP status code
+  class NotFound < Error; end
+
+  # Raised when GitHub returns a 406 HTTP status code
+  class NotAcceptable < Error; end
+
+  # Raised when GitHub returns a 422 HTTP status code
+  class UnprocessableEntity < Error; end
+
+  # Raised when GitHub returns a 500 HTTP status code
+  class InternalServerError < Error; end
+
+  # Raised when GitHub returns a 501 HTTP status code
+  class NotImplemented < Error; end
+
+  # Raised when GitHub returns a 502 HTTP status code
+  class BadGateway < Error; end
+
+  # Raised when GitHub returns a 503 HTTP status code
+  class ServiceUnavailable < Error; end
+end

data/lib/octoplex/version.rb

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

data/octoplex.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "octoplex/version"
+
+Gem::Specification.new do |s|
+  s.name        = "octoplex"
+  s.version     = Octoplex::VERSION
+  s.authors     = ["Ivan Vanderbyl"]
+  s.email       = ["ivanvanderbyl@me.com"]
+  s.homepage    = "http://testpilot.me/testpilot/octoplex"
+  s.summary     = %q{A lightweight wrapper around the Github v3 API}
+  s.description = %q{A lightweight wrapper around the Github v3 API}
+
+  s.rubyforge_project = "octoplex"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "mocha"
+  s.add_development_dependency "awesome_print"
+
+  s.add_runtime_dependency "faraday"
+  s.add_runtime_dependency "multi_json"
+  s.add_runtime_dependency "yajl-ruby"
+  s.add_runtime_dependency "hashr"
+  s.add_runtime_dependency "link_header", "0.0.5"
+end

data/spec/lib/octoplex/api/user_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+describe Octoplex::API::User do
+  describe "repos" do
+    it "should make API call to /user/repos" do
+
+    end
+
+    it "should return an array of Repository objects" do
+
+    end
+  end
+
+  describe "followers" do
+    it "should make an API call to /user/followers" do
+
+    end
+
+    it "should return an array of User objects" do
+
+    end
+  end
+end

data/spec/lib/octoplex/client_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+require "json"
+require "octoplex/connection"
+
+describe Octoplex::Client do
+  before(:each) do
+    Octoplex.discard_client!
+    c = Faraday::Adapter::Test::Stubs.new
+
+    test = Faraday.new do |builder|
+      builder.adapter :test, c do |stub|
+        stub.get('/user/keys') {[ 200, {'x-ratelimit-remaining' => '4999', 'x-ratelimit-limit' => '5000'}, "{}" ]}
+        stub.post('/user/keys/123') {[ 200, {}, "{}" ]}
+      end
+
+      builder.use Faraday::Response::MultiJson
+    end
+    Octoplex::Connection.any_instance.stubs(:setup)
+    Octoplex::Connection.any_instance.stubs(:conn).returns(test)
+  end
+
+  describe "rate limits" do
+    it "should be updated after each request" do
+      Octoplex.client.rate_limit.should == 0
+      Octoplex.client.connection.get('/user/keys')
+      Octoplex.client.rate_limit.should == 5000
+    end
+
+    it "should update remaining limit after request" do
+      Octoplex.client.rate_limit_remaining.should == 0
+      Octoplex.client.connection.get('/user/keys')
+      Octoplex.client.rate_limit_remaining.should == 4999
+    end
+  end
+
+  describe "API methods" do
+    it "should delegate #get to connection" do
+      Octoplex::Connection.any_instance.expects(:get).once.with('/user/keys')
+      Octoplex.client.get('/user/keys')
+    end
+
+    it "should delegate #post to connection" do
+      Octoplex::Connection.any_instance.expects(:post).once.with('/user/keys', {:key => '1233'})
+      Octoplex.client.post('/user/keys', {:key => '1233'})
+    end
+
+    it "should delegate #put to connection" do
+      Octoplex::Connection.any_instance.expects(:put).once.with('/user/keys', {:key => '1233'})
+      Octoplex.client.put('/user/keys', {:key => '1233'})
+    end
+
+    it "should delegate #delete to connection" do
+      Octoplex::Connection.any_instance.expects(:delete).once.with('/user/keys')
+      Octoplex.client.delete('/user/keys')
+    end
+  end
+end

data/spec/lib/octoplex/connection_spec.rb

@@ -0,0 +1,50 @@
+require "spec_helper"
+require "json"
+describe Octoplex::Connection do
+  let(:user_key) {
+    {
+      :key => 'ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEA2',
+      :url => "https://api.github.com/user/keys/123",
+      :title => "SSH Key",
+      :id => 123
+    }
+  }
+
+  let(:user_keys_payload) {
+    keys = [
+      user_key
+    ]
+
+    JSON.dump(keys)
+  }
+
+  before(:each) do
+    c = Faraday::Adapter::Test::Stubs.new
+
+    test = Faraday.new do |builder|
+      builder.adapter :test, c do |stub|
+        stub.get('/user/keys') {[ 200, {}, user_keys_payload ]}
+        stub.post('/user/keys/123') {[ 200, {}, JSON.dump(user_key) ]}
+      end
+
+      builder.use Faraday::Response::MultiJson
+    end
+    Octoplex::Connection.any_instance.stubs(:setup)
+    Octoplex::Connection.any_instance.stubs(:conn).returns(test)
+  end
+
+  it "should handle a GET request to github and parse response" do
+    conn = Octoplex::Connection.new
+    conn.get('/user/keys').should be_a Array
+  end
+
+  it "should handle a POST request to github and parse response" do
+    conn = Octoplex::Connection.new
+    conn.post('/user/keys/123', {:key => 'ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEA2'}).values.should == user_key.values
+  end
+
+  it "should return accept token as first argument" do
+    conn = Octoplex::Connection.new('1234')
+    conn.token.should == '1234'
+  end
+end

data/spec/lib/octoplex_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+
+describe Octoplex do
+  describe "#connection" do
+    it "should store a cached instance of Client" do
+      Octoplex.instance_variable_get("@client").should be_nil
+      Octoplex.client.should be_a Octoplex::Client
+      Octoplex.instance_variable_get("@client").should be_a Octoplex::Client
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'mocha'
+require "octoplex"
+
+Dir[File.expand_path("../support/*.rb", __FILE__)].each { |file| require file }
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+
+  config.before(:all) do
+  end
+end

data/spec/support/custom.rb

@@ -0,0 +1 @@
+alias :doing :lambda

metadata

@@ -0,0 +1,164 @@
+--- !ruby/object:Gem::Specification
+name: octoplex
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Ivan Vanderbyl
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70317821260920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70317821260920
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: &70317821254640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70317821254640
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: &70317821248040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70317821248040
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: &70317821244280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70317821244280
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: &70317817138400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70317817138400
+- !ruby/object:Gem::Dependency
+  name: yajl-ruby
+  requirement: &70317817135720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70317817135720
+- !ruby/object:Gem::Dependency
+  name: hashr
+  requirement: &70317817133640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70317817133640
+- !ruby/object:Gem::Dependency
+  name: link_header
+  requirement: &70317817129820 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 0.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: *70317817129820
+description: A lightweight wrapper around the Github v3 API
+email:
+- ivanvanderbyl@me.com
+executables:
+- octoplex_console
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- bin/octoplex_console
+- lib/faraday/response/hashr.rb
+- lib/faraday/response/multi_json.rb
+- lib/faraday/response/raise_octoplex_error.rb
+- lib/octoplex.rb
+- lib/octoplex/client.rb
+- lib/octoplex/client/base.rb
+- lib/octoplex/client/repository.rb
+- lib/octoplex/client/root.rb
+- lib/octoplex/client/user.rb
+- lib/octoplex/connection.rb
+- lib/octoplex/errors.rb
+- lib/octoplex/version.rb
+- octoplex.gemspec
+- spec/lib/octoplex/api/user_spec.rb
+- spec/lib/octoplex/client_spec.rb
+- spec/lib/octoplex/connection_spec.rb
+- spec/lib/octoplex_spec.rb
+- spec/spec_helper.rb
+- spec/support/custom.rb
+homepage: http://testpilot.me/testpilot/octoplex
+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: '0'
+requirements: []
+rubyforge_project: octoplex
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A lightweight wrapper around the Github v3 API
+test_files:
+- spec/lib/octoplex/api/user_spec.rb
+- spec/lib/octoplex/client_spec.rb
+- spec/lib/octoplex/connection_spec.rb
+- spec/lib/octoplex_spec.rb
+- spec/spec_helper.rb
+- spec/support/custom.rb