git_hub_bub 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 833f07fd265f877003b7f27782bd3c0b40b63cfe
+  data.tar.gz: 4e63581207216c9c6147a384f7ea411c3432fd04
+SHA512:
+  metadata.gz: 78424f9c9e28d47175c5c7ae70a9f5ac247be3bec1659cd7e33a3393e2167cc6a55675f81d14a891492564a48ddb48ff6037703a54a8c1e0bc8980a921a59583
+  data.tar.gz: 73fe92e332b1098962208a9ebe487855981c2cbeddea6f003208f0e5b6d128fc7f4d4b65dc8da2b08bf13d903e1c80a140905ed430837dacca8f3ea53042edd2

data/.gitignore

@@ -0,0 +1,3 @@
+.env
+.DS_Store
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - ruby-head
+  - jruby-19mode
+matrix:
+  allow_failures:
+    - rvm: ruby-head

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,214 @@
+# GitHubBub
+
+A low level GitHub client that makes the disgusting issue of header based url pagination simple.
+
+## What
+
+Seriously? I just told you, see above.
+
+## Why
+
+I'm using this in a few places such as http://www.codetriage.com/. Need low level control, without sacrificing usability.
+
+## Install
+
+In your `Gemfile`
+
+```
+gem 'git_hub_bub'
+```
+
+Then run `$ bundle install`
+
+## GET Whatever you Want:
+
+To make requests to a `GET` endpoint use `GitHubBub.get`
+
+```ruby
+response = GitHubBub.get('repos/rails/rails/issues')
+```
+
+Now you can do stuff like grab the json-ified body:
+
+```ruby
+response.json_body # => { foo: "bar" ...}
+```
+
+And get pagination (if there is any):
+
+```ruby
+response.next_url   # => "https://api.github.com/repositories/8514/issues?page=2"
+response.last_url?  # => false
+response.pagination # => {"next_url"=>"https://api.github.com/repositories/8514/issues?page=2", "last_url"=>"https://api.github.com/repositories/8514/issues?page=18"}
+```
+
+## Passing Params
+
+To pass parameters such as page number, or sorting or whatever, input a hash as the second argument.
+
+```ruby
+GitHubBub.get('repositories/8514/issues', page: 1, sort: 'comments', direction:'desc')
+```
+
+## Passing Anything Else
+
+Anything else you pass in the third argument will be given to [Excon](https://github.com/geemus/excon) which powers GitHubBub. So if you want to set headers you can do it like this:
+
+```ruby
+GitHubBub.get('repositories/8514/issues', {page: 1}, {headers: { "Content-Type" => "application/x-www-form-urlencoded" }})
+```
+
+or
+
+```ruby
+GitHubBub.get('repositories/8514/issues', {}, {headers: { "Content-Type" => "application/x-www-form-urlencoded" }})
+```
+
+See [Excon](https://github.com/geemus/excon) for documentation on more available options.
+
+## Default Headers
+
+Default headers are set in `GitHubBub::Request`
+
+```ruby
+BASE_HEADERS   = {'Accept' => "application/#{GITHUB_VERSION}", "User-Agent" => USER_AGENT}
+```
+
+You can change `GitHubBub::Request::GITHUB_VERSION` and `GitHubBub::Request::USER_AGENT`.
+
+If you want any other default headers you can set them in `EXTRA_HEADERS` like so:
+
+```ruby
+GitHubBub::Request::EXTRA_HEADERS = { "Content-Type" => "application/x-www-form-urlencoded" }
+```
+
+Keep in mind this will change them for _every_ request. If you need logic behind your default headers, consider adding a `before_send_callback` to conditionally modify headers
+
+
+## Authenticated Requests
+
+Some GitHub endpoints require a user's authorization you can do that by passing in `token`:
+
+```ruby
+GitHubBub.get('/user', token: 'a38ck38ckgoldfishtoken')
+```
+
+Or you can manually set a header like so:
+
+```ruby
+GitHubBub.get('/user', {} {headers: {"Authorization" => "token a38ck38ckgoldfishtoken"}})
+```
+
+You will need to use one of these every time the GitHub api says "as an authenticated user".
+
+## Callbacks
+
+If you want to mess with the url or options before sending a request you can set a callback globally
+
+```ruby
+GitHubBub::Request.set_callback do |request|
+  request.url     = "http://schneems.com"
+  request.options = {do: "anything you want to _all_ the requests" }
+end
+```
+
+## Endpoints
+
+Check [GitHub Developer Docs](http://developer.github.com/). When you see something like
+
+```
+GET /users/:user/repos
+```
+
+It means you need to use the `GitHubBub.get` method and pass in a string like `'/users/schneems/repos'` the full request might look like this:
+
+
+```ruby
+GitHubBub.get('/users/schneems/repos')
+```
+
+## Other HTTP Methods
+
+Supports everything GitHub currently supports http://developer.github.com/v3/#http-verbs :
+
+```
+HEAD   # => GitHubBub.head
+GET    # => GitHubBub.get
+POST   # => GitHubBub.post
+PATCH  # => GitHubBub.patch
+PUT    # => GitHubBub.put
+DELETE # => GitHubBub.delete
+```
+
+
+## Configuration
+
+You can use callbacks and there are some constants you can set, look in `GitHubBub::Request`. You will definetly want to set `GitHubBub::Request::USER_AGENT` It needs to be unique to your app: (http://developer.github.com/v3/#user-agent-required).
+
+```ruby
+GitHubBub::Request::USER_AGENT = 'a-unique-and-permanent-agent-to-my-app'
+```
+
+## Testing
+
+This gem is tested using the super cool request recording/stubbing framework [VCR](https://github.com/vcr/vcr). This does mean at one point and time all tests ran successfully against GitHub's servers. This also means if you want to write any tests any that are not already recorded will need to hit GitHub servers. So make sure the tests you write don't do anything really bad.
+
+You'll also need a valid `.env` file
+
+```sh
+$ touch .env
+```
+
+Anything you put in this file will be sourced into your environment for tests. Here is an example `.env` file.
+
+```sh
+GITHUB_API_KEY=asdfe92fakeKey43ad638e35asdfd98167847248a26
+OWNER=schneems
+REPO=wicked
+USER_NAME="Richard Schneeman"
+WATCH_OWNER=emberjs
+WATCH_REPO=ember.js
+```
+
+You will need to change most of these values
+
+```
+GITHUB_API_KEY=asdfe92fakeKey43ad638e35asdfd98167847248a26
+```
+
+Your github API key, you can get one from https://github.com/settings/applications.
+
+```
+OWNER=schneems
+```
+
+Your public github username
+
+```
+REPO=wicked
+```
+
+A repo that you have commit access too.
+
+```
+USER_NAME="Richard Schneeman"
+```
+
+Your real name
+
+```
+WATCH_OWNER=emberjs
+```
+
+The `:owner` of a repo you might watch or want to watch, needs to be combined with WATCH_REPO. This should be different from `OWNER`
+
+```
+WATCH_REPO=ember.js
+```
+
+A repo that the `WATCH_OWNER` owns. Should be different from `REPO`
+
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,15 @@
+require 'bundler/gem_tasks'
+require 'git_hub_bub'
+
+task :default => [:test]
+
+require 'rake'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+

data/changelog.md

@@ -0,0 +1,3 @@
+## 0.0.1 (05/21/2012)
+
+- Hello World

data/git_hub_bub.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'git_hub_bub/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "git_hub_bub"
+  gem.version       = GitHubBub::VERSION
+  gem.authors       = ["Richard Schneeman"]
+  gem.email         = ["richard.schneeman+rubygems@gmail.com"]
+  gem.description   = %q{git_hub_bub makes github requests}
+  gem.summary       = %q{git_hub_bub makes github requests}
+  gem.homepage      = "https://github.com/schneems/git_hub_bub"
+  gem.license       = "MIT"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency "rrrretry"
+  gem.add_dependency "excon"
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "vcr",     '~> 2.5.0'
+  gem.add_development_dependency "webmock", '~> 1.11.0'
+  gem.add_development_dependency "dotenv"
+end
+

data/lib/git_hub_bub/request.rb

@@ -0,0 +1,137 @@
+module GitHubBub
+  class RequestError < StandardError; end
+
+  class Request
+    attr_accessor :url, :options, :token
+    BASE_URI       = 'https://api.github.com'
+    USER_AGENT     ||= SecureRandom.hex(16)
+    GITHUB_VERSION = "vnd.github.3.raw+json"
+    EXTRA_HEADERS  ||= {}
+    BASE_HEADERS   = EXTRA_HEADERS.merge({'Accept' => "application/#{GITHUB_VERSION}", "User-Agent" => USER_AGENT})
+    RETRIES        = 1
+
+    def initialize(url, query = {}, options = {})
+      self.url             = url.include?("http") ? url : File.join(BASE_URI, url)
+      self.options         = options || {}
+      self.options[:query] = query   if query && !query.empty?
+      options[:headers]    = BASE_HEADERS.merge(options[:headers]|| {})
+    end
+
+    def self.head(url, query = {}, options = {})
+      self.new(url, query, options).head
+    end
+
+    def head
+      wrap_request do
+        Excon.head(url, options)
+      end
+    end
+
+    def self.get(url, query = {}, options = {})
+      self.new(url, query, options).get
+    end
+
+    def get
+      wrap_request do
+        ex = Excon.get(url, options)
+        ex = Excon.get(@location, options) if @location = ex.headers["Location"]
+        ex
+      end
+    end
+
+    def self.post(url, query = {}, options = {})
+      self.new(url, query, options).post
+    end
+
+    def post
+      wrap_request do
+        Excon.post(url, options)
+      end
+    end
+
+    def self.patch(url, query = {}, options = {})
+      self.new(url, query, options).patch
+    end
+
+    def patch
+      wrap_request do
+        Excon.patch(url, options)
+      end
+    end
+
+    def self.put(url, query = {}, options = {})
+      self.new(url, query, options).put
+    end
+
+    def put
+      wrap_request do
+        Excon.put(url, options)
+      end
+    end
+
+    def self.delete(url, query = {}, options = {})
+      self.new(url, query, options).delete
+    end
+
+    def delete
+      wrap_request do
+        Excon.delete(url, options)
+      end
+    end
+
+    def wrap_request(&block)
+      before_callbacks!
+      set_auth_from_token!
+      query_to_json_body!
+      response = RETRIES.times.retry do
+        GitHubBub::Response.create(yield)
+      end
+      raise RequestError, "message: '#{response.json_body['message']}', url: '#{url}', response: '#{response.inspect}'" unless response.status.to_s =~ /^2.*/
+      return response
+    end
+
+    # do they take query params? do they take :body?
+    # who cares, send them both!
+    def query_to_json_body!
+      options[:body] = options[:query].to_json if options[:query]
+    end
+
+    def set_auth_from_token!
+      return unless token
+      options[:headers]["Authorization"] ||= "token #{token}"
+    end
+
+    def token
+      @token ||= if options[:headers] && token_string = options[:headers]["Authorization"]
+        token_string.split(/\s/).last
+      elsif options[:query] && token = options[:query].delete(:token)
+        token
+      else
+        nil
+      end
+    end
+    alias :token? :token
+
+    def self.set_before_callback(&block)
+      before_callbacks << block
+    end
+
+    def self.before_callbacks
+      @before_callbacks ||=[]
+    end
+
+    def self.clear_callbacks
+      @before_callbacks = []
+    end
+
+    def before_callbacks!
+      self.class.before_callbacks.each do |callback|
+        run_callback &callback
+      end
+    end
+
+    def run_callback(&block)
+      yield self
+    end
+  end
+end

data/lib/git_hub_bub/response.rb

@@ -0,0 +1,66 @@
+module GitHubBub
+  class Response < Excon::Response
+
+     def self.create(response)
+       self.new(response.data)
+     end
+
+     def json_body
+      ::JSON.parse(self.body)
+     end
+
+     def pagination
+       @pagination ||= parse_pagination
+     end
+
+     def parsed_response
+      response.body.inspect
+     end
+
+     def next_url
+       pagination['next_url']
+     end
+
+     def prev_url
+       pagination['prev_url']
+     end
+     alias :previous_url :prev_url
+
+     def last_url
+       pagination['last_url']
+     end
+
+     def first_url
+       pagination['first_url']
+     end
+
+     def last_page?
+       return true if next_url.nil?
+       last_page_number = page_number_from_url(last_url)
+       next_page_number = page_number_from_url(next_url)
+       return next_page_number > last_page_number
+     end
+
+     def first_page?
+       return true if first_url.nil?
+       return false
+     end
+
+     def page_number_from_url(url)
+       query = ::URI.parse(url).query
+       ::CGI.parse(query)["page"].first.to_i
+     end
+
+    def header_links
+       (headers['link'] || headers['Link'] || "").split(',')
+     end
+
+     def parse_pagination
+       header_links.each_with_object({}) do |element, hash|
+         key   = element[/rel=["'](.*)['"]/, 1]
+         value = element[/<(.*)>/, 1]
+         hash["#{key}_url"] = value
+       end
+     end
+   end
+end