gh 0.0.1

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - jruby-18mode
+  - jruby-19mode
+  - rbx-18mode
+  - rbx-19mode
+  - ruby-head
+  - jruby-head
+  - ree

data/Gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in gh.gemspec
+gemspec
+gem 'rake'
+platform(:jruby) { gem 'jruby-openssl' }

data/README.md

@@ -0,0 +1,25 @@
+**This is work in progress and not yet usable!**
+
+Goal of this library is to ease usage of the Github API as part of large, tightly integrated, distributed projects, such as [Travis CI](http://travis-ci.org). It was born out due to issues we ran into with all existing Github libraries and the Github API itself.
+
+With that in mind, this library follows the following goals:
+
+* Implement features in separate layers, make layers as independend of each other as possible
+* Higher level layers should not worry about when to send requests
+* It should only send requests to Github when necessary
+* It should be able to fetch data from Github asynchronously (i.e. HTTP requests to Travis should not be bound to HTTP requests to Github, if possible)
+* It should be able to deal with events and hooks well (i.e. update cached entities with hook data)
+* It should not have intransparent magic (i.e. implicit, undocumented requirements on fields we get from Github)
+* It should shield against possible changes to the Github API or at least complain about those changes if it can't deal with it.
+
+Most of this is not yet implemented!
+
+The lower level APIs support a Rack-like stacking API:
+
+``` ruby
+api = GH::Stack.build do
+  use GH::Cache, cache: Rails.cache
+  use GH::Normalizer
+  use GH::Remote, username: "admin", password: "admin"
+end
+```

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new :default do |t|
+  t.rspec_opts = %w[-bcfd --fail-fast]
+end

data/gh.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "gh/version"
+
+Gem::Specification.new do |s|
+  s.name        = "gh"
+  s.version     = GH::VERSION
+  s.authors     = ["Konstantin Haase"]
+  s.email       = ["konstantin.mailinglists@googlemail.com"]
+  s.homepage    = ""
+  s.summary     = %q{layered github client}
+  s.description = %q{multi-layer client for the github api v3}
+
+  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 'webmock'
+
+  s.add_runtime_dependency 'faraday',     '~> 0.7'
+  s.add_runtime_dependency 'backports',   '~> 2.3'
+  s.add_runtime_dependency 'multi_json',  '~> 1.0'
+end

data/lib/gh.rb

@@ -0,0 +1,32 @@
+require 'gh/version'
+require 'backports'
+require 'forwardable'
+
+module GH
+  autoload :Cache,      'gh/cache'
+  autoload :Case,       'gh/case'
+  autoload :Normalizer, 'gh/normalizer'
+  autoload :Remote,     'gh/remote'
+  autoload :Response,   'gh/response'
+  autoload :Stack,      'gh/stack'
+  autoload :Wrapper,    'gh/wrapper'
+
+  def self.[](key)
+    backend = Thread.current[:GH] ||= DefaultStack.build
+    backend[key]
+  end
+
+  def self.with(backend)
+    backend = DefaultStack.build(backend) if Hash === backend
+    was, Thread.current[:GH] = Thread.current[:GH], backend
+    yield
+  ensure
+    Thread.current[:GH] = was
+  end
+
+  DefaultStack = Stack.new do
+    use Cache
+    use Normalizer
+    use Remote
+  end
+end

data/lib/gh/cache.rb

@@ -0,0 +1,47 @@
+require 'gh'
+require 'thread'
+
+module GH
+  # Public: This class deals with HTTP requests to Github. It is the base Wrapper you always want to use.
+  # Note that it is usually used implicitely by other wrapper classes if not specified.
+  class Cache < Wrapper
+    # Public: Get/set cache to use. Compatible with Rails/ActiveSupport cache.
+    attr_accessor :cache
+
+    # Internal: Simple in-memory cache basically implementing a copying GC.
+    class SimpleCache
+      # Internal: Initializes a new SimpleCache.
+      #
+      # size - Number of objects to hold in cache.
+      def initialize(size = 2048)
+        @old, @new, @size, @mutex = {}, {}, size/2, Mutex.new
+      end
+
+      # Internal: Tries to fetch a value from the cache and if it doesn't exist, generates it from the
+      # block given.
+      def fetch(key)
+        @mutex.lock { @old, @new = @new, {} if @new.size > @size } if @new.size > @size
+        @new[key] ||= @old[key] || yield
+      end
+    end
+
+    # Internal: Initializes a new Cache instance.
+    def setup(*)
+      self.cache ||= Rails.cache if defined? Rails.cache and defined? RAILS_CACHE
+      self.cache ||= ActiveSupport::Cache.lookup_store if defined? ActiveSupport::Cache.lookup_store
+      self.cache ||= SimpleCache.new
+      super
+    end
+
+    # Public: Retrieves resources from Github and caches response for future access.
+    #
+    # Examples
+    #
+    #   Github::Cache.new['users/rkh'] # => { ... }
+    #
+    # Returns the Response.
+    def [](key)
+      cache.fetch(path_for(key)) { super }
+    end
+  end
+end

data/lib/gh/case.rb

@@ -0,0 +1,8 @@
+require 'gh'
+
+module GH
+  module Case
+    def respond_to(method) proc { |o| o.respond_to? method } end
+    private :respond_to
+  end
+end

data/lib/gh/faraday.rb

@@ -0,0 +1,99 @@
+# Copyright (c) 2009 rick olson, zack hobson
+#
+# 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.
+
+require 'faraday'
+
+if Faraday::VERSION < '0.8.0'
+  $stderr.puts "please update faraday"
+
+  # https://github.com/technoweenie/faraday/blob/master/lib/faraday/request/basic_authentication.rb
+  require 'base64'
+
+  module Faraday
+    class Request::BasicAuthentication < Faraday::Middleware
+      def initialize(app, login, pass)
+        super(app)
+        @header_value = "Basic #{Base64.encode64([login, pass].join(':')).gsub("\n", '')}"
+      end
+
+      def call(env)
+        unless env[:request_headers]['Authorization']
+          env[:request_headers]['Authorization'] = @header_value
+        end
+        @app.call(env)
+      end
+    end
+  end
+
+  # https://github.com/technoweenie/faraday/blob/master/lib/faraday/request/retry.rb
+  module Faraday
+    class Request::Retry < Faraday::Middleware
+      def initialize(app, retries = 2)
+        @retries = retries
+        super(app)
+      end
+
+      def call(env)
+        retries = @retries
+        begin
+          @app.call(env)
+        rescue StandardError, Timeout::Error
+          if retries > 0
+            retries -= 1
+            retry
+          end
+          raise
+        end
+      end
+    end
+  end
+
+  # https://github.com/technoweenie/faraday/blob/master/lib/faraday/request/token_authentication.rb
+  module Faraday
+    class Request::TokenAuthentication < Faraday::Middleware
+      def initialize(app, token, options={})
+        super(app)
+
+        # values = ["token=#{token.to_s.inspect}"]
+        #         options.each do |key, value|
+        #           values << "#{key}=#{value.to_s.inspect}"
+        #         end
+        #         comma = ",\n#{' ' * ('Authorization: Token '.size)}"
+        #         @header_value = "Token #{values * comma}"
+        @header_value = "token #{token}"
+      end
+
+      def call(env)
+        unless env[:request_headers]['Authorization']
+          env[:request_headers]['Authorization'] = @header_value
+        end
+        @app.call(env)
+      end
+    end
+  end
+
+  # https://github.com/technoweenie/faraday/blob/master/lib/faraday/request.rb
+  Faraday::Request.register_lookup_modules \
+      :url_encoded => :UrlEncoded,
+      :multipart   => :Multipart,
+      :retry       => :Retry,
+      :basic_auth  => :BasicAuthentication,
+      :token_auth  => :TokenAuthentication
+end

data/lib/gh/normalizer.rb

@@ -0,0 +1,109 @@
+require 'gh'
+require 'time'
+
+module GH
+  # Public: A Wrapper class that deals with normalizing Github responses.
+  class Normalizer < Wrapper
+    # Public: Fetches and normalizes a github entity.
+    #
+    # Returns normalized Response.
+    def [](key)
+      result = super
+      links(result)['self'] ||= { 'href' => full_url(key).to_s } if result.hash?
+      result
+    end
+
+    private
+
+    def modify(*)
+      normalize super
+    end
+
+    def links(hash)
+      hash = hash.data if hash.respond_to? :data
+      hash["_links"] ||= {}
+    end
+
+    def set_link(hash, type, href)
+      links(hash)[type] = {"href" => href}
+    end
+
+    def normalize_response(response)
+      response      = response.dup
+      response.data = normalize response.data
+      response
+    end
+
+    def normalize_hash(hash)
+      corrected = {}
+      corrected.default_proc = hash.default_proc if hash.default_proc
+
+      hash.each_pair do |key, value|
+        key = normalize_key(key, value)
+        next if normalize_url(corrected, key, value)
+        next if normalize_time(corrected, key, value)
+        corrected[key] = normalize(value)
+      end
+
+      normalize_user(corrected)
+      corrected
+    end
+
+    def normalize_time(hash, key, value)
+      hash['date'] = Time.at(value).xmlschema if key == 'timestamp'
+    end
+
+    def normalize_user(hash)
+      hash['owner']  ||= hash.delete('user') if hash['created_at']   and hash['user']
+      hash['author'] ||= hash.delete('user') if hash['committed_at'] and hash['user']
+
+      hash['committer'] ||= hash['author']    if hash['author']
+      hash['author']    ||= hash['committer'] if hash['committer']
+    end
+
+    def normalize_url(hash, key, value)
+      case key
+      when "blog"
+        set_link(hash, key, value)
+      when "url"
+        type = Addressable::URI.parse(value).host == api_host.host ? "self" : "html"
+        set_link(hash, type, value)
+      when /^(.+)_url$/
+        set_link(hash, $1, value)
+      end
+    end
+
+    def normalize_key(key, value = nil)
+      case key
+      when 'gravatar_url'         then 'avatar_url'
+      when 'org'                  then 'organization'
+      when 'orgs'                 then 'organizations'
+      when 'username'             then 'login'
+      when 'repo'                 then 'repository'
+      when 'repos'                then normalize_key('repositories', value)
+      when /^repos?_(.*)$/        then "repository_#{$1}"
+      when /^(.*)_repo$/          then "#{$1}_repository"
+      when /^(.*)_repos$/         then "#{$1}_repositories"
+      when 'commit', 'commit_id'  then value =~ /^\w{40}$/ ? 'sha' : key
+      when 'comments'             then Numeric === value ? 'comment_count'    : key
+      when 'forks'                then Numeric === value ? 'fork_count'       : key
+      when 'repositories'         then Numeric === value ? 'repository_count' : key
+      when /^(.*)s_count$/        then "#{$1}_count"
+      else key
+      end
+    end
+
+    def normalize_array(array)
+      array.map { |e| normalize(e) }
+    end
+
+    def normalize(object)
+      case object
+      when Hash     then normalize_hash(object)
+      when Array    then normalize_array(object)
+      when Response then normalize_response(object)
+      else object
+      end
+    end
+  end
+end

data/lib/gh/remote.rb

@@ -0,0 +1,71 @@
+require 'gh'
+require 'gh/faraday'
+
+module GH
+  # Public: This class deals with HTTP requests to Github. It is the base Wrapper you always want to use.
+  # Note that it is usually used implicitely by other wrapper classes if not specified.
+  class Remote < Wrapper
+    attr_reader :api_host, :connection, :headers
+
+    # Public: Generates a new Rempte instance.
+    #
+    # api_host - HTTP host to send requests to, has to include schema (https or http)
+    # options  - Hash with configuration options:
+    #            :token    - OAuth token to use (optional).
+    #            :username - Github user used for login (optional).
+    #            :password - Github password used for login (optional).
+    #            :origin   - Value of the origin request header (optional).
+    #            :headers  - HTTP headers to be send on every request (optional).
+    #            :adapter  - HTTP library to use for making requests (optional, default: :net_http)
+    #
+    # It is highly recommended to set origin, but not to set headers.
+    # If you set the username, you should also set the password.
+    def setup(api_host, options)
+      token, username, password = options.values_at :token, :username, :password
+
+      api_host  = api_host.api_host if api_host.respond_to? :api_host
+      @api_host = Addressable::URI.parse(api_host)
+      @headers  = options[:headers].try(:dup)  || {
+        "Origin"          => options[:origin] || "http://example.org",
+        "Accept"          => "application/vnd.github.v3.raw+json," \
+                             "application/vnd.github.beta.raw+json;q=0.5," \
+                             "application/json;q=0.1",
+        "Accept-Charset"  => "utf-8"
+      }
+
+      @connection = Faraday.new(:url => api_host) do |builder|
+        builder.request(:token_auth, token)               if token
+        builder.request(:basic_auth, username, password)  if username and password
+        builder.request(:retry)
+        builder.response(:raise_error)
+        builder.adapter(options[:adapter] || :net_http)
+      end
+    end
+
+    # Public: ...
+    def inspect
+      "#<#{self.class}: #{api_host}>"
+    end
+
+    # Public: Retrieves resources from Github.
+    #
+    # Examples
+    #
+    #   Github::Remote.new['users/rkh'] # => { ... }
+    #
+    # Raises Faraday::Error::ResourceNotFound if the resource returns status 404.
+    # Raises Faraday::Error::ClientError if the resource returns a status between 400 and 599.
+    # Returns the Response.
+    def [](key)
+      response = connection.get(path_for(key), headers)
+      modify(response.body, response.headers)
+    end
+
+    private
+
+    def modify(body, headers = {})
+      return body if body.is_a? Response
+      Response.new(headers, body)
+    end
+  end
+end

data/lib/gh/response.rb

@@ -0,0 +1,89 @@
+require 'gh'
+require 'multi_json'
+
+module GH
+  # Public: Class wrapping low level Github responses.
+  #
+  # Delegates safe methods to the parsed body (expected to be an Array or Hash).
+  class Response
+    include GH::Case
+
+    # Internal: Content-Type header value expected from Github
+    CONTENT_TYPE = "application/json; charset=utf-8"
+
+    include Enumerable
+    attr_accessor :headers, :data, :body
+
+    # subset of safe methods that both Array and Hash implement
+    extend Forwardable
+    def_delegators(:@data, :[], :assoc, :each, :empty?, :flatten, :include?, :index, :inspect, :length,
+      :pretty_print, :pretty_print_cycle, :rassoc, :select, :size, :to_a, :values_at)
+
+    # Internal: Initializes a new instance.
+    #
+    # headers - HTTP headers as a Hash
+    # body    - HTTP body as a String
+    def initialize(headers = {}, body = "{}")
+      @headers = Hash[headers.map { |k,v| [k.downcase, v] }]
+      raise ArgumentError, "unexpected Content-Type #{content_type}" if content_type and content_type != CONTENT_TYPE
+
+      case body
+      when respond_to(:to_str)  then @body = body.to_str
+      when respond_to(:to_hash) then @data = body.to_hash
+      when respond_to(:to_ary)  then @data = body.to_ary
+      else raise ArgumentError, "cannot parse #{body.inspect}"
+      end
+
+      @body ||= MultiJson.encode(@data)
+      @body   = @body.encode("utf-8") if @body.respond_to? :encode
+      @data ||= MultiJson.decode(@body)
+    end
+
+    # Public: Duplicates the instance. Will also duplicate some instance variables to behave as expected.
+    #
+    # Returns new Response instance.
+    def dup
+      super.dup_ivars
+    end
+
+    # Public: Returns the response body as a String.
+    def to_s
+      @body.dup
+    end
+
+    # Public: Returns true or false indicating whether it supports method.
+    def respond_to?(method, *)
+      return super unless method.to_s == "to_hash" or method.to_s == "to_ary"
+      data.respond_to? method
+    end
+
+    # Public: Implements to_hash conventions, please check respond_to?(:to_hash).
+    def to_hash
+      return method_missing(__method__) unless respond_to? __method__
+      @data.dup.to_hash
+    end
+
+    # Public: Implements to_ary conventions, please check respond_to?(:to_hash).
+    def to_ary
+      return method_missing(__method__) unless respond_to? __method__
+      @data.dup.to_ary
+    end
+
+    def hash?
+      respond_to? :to_hash
+    end
+
+    protected
+
+    def dup_ivars
+      @headers, @data, @body = @headers.dup, @data.dup, @body.dup
+      self
+    end
+
+    private
+
+    def content_type
+      headers['content-type']
+    end
+  end
+end

data/lib/gh/stack.rb

@@ -0,0 +1,52 @@
+require 'gh'
+
+module GH
+  # Public: Exposes DSL for stacking wrappers.
+  #
+  # Examples
+  #
+  #   api = GH::Stack.build do
+  #     use GH::Cache, cache: Rails.cache
+  #     use GH::Normalizer
+  #     use GH::Remote, username: "admin", password: "admin"
+  #   end
+  class Stack
+    # Public: Generates a new wrapper stack from the given block.
+    #
+    # options - Hash of options that will be passed to all layers upon initialization.
+    #
+    # Returns top most Wrapper instance.
+    def self.build(options, &block)
+      new(&block).build(options)
+    end
+
+    # Public: Generates a new Stack instance.
+    #
+    # options - Hash of options that will be passed to all layers upon initialization.
+    #
+    # Can be used for easly stacking layers.
+    def initialize(options = {}, &block)
+      @options, @stack = {}, []
+      instance_eval(&block) if block
+    end
+
+    # Public: Adds a new layer to the stack.
+    #
+    # Layer will be wrapped by layers already on the stack.
+    def use(klass, options = {})
+      @stack << [klass, options]
+      self
+    end
+
+    # Public: Generates wrapper instances for stack configuration.
+    #
+    # options - Hash of options that will be passed to all layers upon initialization.
+    #
+    # Returns top most Wrapper instance.
+    def build(options = {})
+      @stack.reverse.inject(nil) do |backend, (klass, opts)|
+        klass.new backend, @options.merge(opts).merge(options)
+      end
+    end
+  end
+end

data/lib/gh/version.rb

@@ -0,0 +1,4 @@
+module GH
+  # Public: Library version.
+  VERSION = "0.0.1"
+end

data/lib/gh/wrapper.rb

@@ -0,0 +1,102 @@
+require 'gh'
+require 'addressable/uri'
+
+module GH
+  # Public: Simple base class for low level layers.
+  # Handy if you want to manipulate resources coming in from Github.
+  #
+  # Examples
+  #
+  #   class IndifferentAccess
+  #     def [](key) super.tap { |r| r.data.with_indifferent_access! } end
+  #   end
+  #
+  #   gh = IndifferentAccess.new
+  #   gh['users/rkh'][:name] # => "Konstantin Haase"
+  #
+  #   # easy to use in the low level stack
+  #   gh = Github.build do
+  #     use GH::Cache
+  #     use IndifferentAccess
+  #     use GH::Normalizer
+  #   end
+  class Wrapper
+    extend Forwardable
+
+    # Public: Get wrapped layer.
+    attr_reader :backend
+
+    # Public: Returns the URI used for sending out web request.
+    def_delegator :backend, :api_host
+
+    # Public: Retrieves resources from Github.
+    #
+    # By default, this method is delegated to the next layer on the stack
+    # and modify is called.
+    def [](key)
+      modify backend[key]
+    end
+
+    # Internal: Get/set default layer to wrap when creating a new instance.
+    def self.wraps(klass = nil)
+      @wraps = klass if klass
+      @wraps || Remote
+    end
+
+    # Public: Initialize a new Wrapper.
+    #
+    # backend - layer to be wrapped
+    # options - config options
+    def initialize(backend = nil, options = {})
+      setup(*normalize_options(backend, options))
+      options.each_pair { |key, value| public_send("#{key}=", value) if respond_to? "#{key}=" }
+    end
+
+    # Public: Set wrapped layer.
+    def backend=(layer)
+      layer.frontend = self
+      @backend = layer
+    end
+
+    # Internal: ...
+    def frontend=(value)
+      @frontend = value
+    end
+
+    # Internal: ...
+    def frontend
+      @frontend ? @frontend.frontend : self
+    end
+
+    def inspect
+      "#<#{self.class}: #{backend.inspect}>"
+    end
+
+    private
+
+    def modify(data)
+      data
+    end
+
+    def setup(backend, options)
+      self.backend = Wrapper === backend ? backend : self.class.wraps.new(backend, options)
+    end
+
+    def normalize_options(backend, options)
+      backend, options = nil, backend if Hash === backend
+      options ||= {}
+      backend ||= options[:backend] || options[:api_url] || 'https://api.github.com'
+      [backend, options]
+    end
+
+    def full_url(key)
+      api_host + path_for(key)
+    end
+
+    def path_for(key)
+      uri = Addressable::URI.parse(key)
+      raise ArgumentError, "URI out of scope: #{key}" if uri.host and uri.host != api_host.host
+      uri.request_uri
+    end
+  end
+end

data/spec/cache_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe GH::Cache do
+  before { subject.backend = GH::MockBackend.new }
+
+  it 'send HTTP requests for uncached resources' do
+    subject['users/rkh']['name'].should be == "Konstantin Haase"
+    requests.count.should be == 1
+  end
+
+  it 'uses the cache for subsequent requests' do
+    subject['users/rkh']['name'].should be == "Konstantin Haase"
+    subject['users/svenfuchs']['name'].should be == "Sven Fuchs"
+    subject['users/rkh']['name'].should be == "Konstantin Haase"
+    requests.count.should be == 2
+  end
+end

data/spec/normalizer_spec.rb

@@ -0,0 +1,260 @@
+require 'spec_helper'
+
+describe GH::Normalizer do
+  before { subject.backend = GH::MockBackend.new }
+
+  def normalize(payload)
+    data['payload'] = payload
+  end
+
+  def with_headers(headers = {})
+    response = GH::Response.new(headers)
+    data['payload'], response.data = response, data['payload']
+  end
+
+  def normalized
+    subject['payload']
+  end
+
+  it 'is set up properly' do
+    backend.frontend.should be_a(GH::Normalizer)
+  end
+
+  it 'leaves unknown fields in place' do
+    normalize 'foo' => 'bar'
+    normalized['foo'].should be == 'bar'
+  end
+
+  it 'works for deeply nested fields'
+  it 'works for lists'
+
+  context 'date fields' do
+    it 'generates date from timestamp'
+  end
+
+  context 'renaming' do
+    def self.renames(a, b)
+      it "renames #{a} to #{b}" do
+        normalize a => "foo"
+        normalized.should_not include(a)
+        normalized.should include(b)
+        normalized[b].should be == "foo"
+      end
+    end
+
+    renames 'org', 'organization'
+    renames 'orgs', 'organizations'
+    renames 'username', 'login'
+    renames 'repo', 'repository'
+    renames 'repos', 'repositories'
+    renames 'repo_foo', 'repository_foo'
+    renames 'repos_foo', 'repository_foo'
+    renames 'foo_repo', 'foo_repository'
+    renames 'foo_repos', 'foo_repositories'
+
+    it 'renames commit to sha if value is a sha' do
+      normalize 'commit' => 'd0f4aa01f100c26c6eae17ea637f46cf150d9c1f'
+      normalized.should_not include('commit')
+      normalized.should include('sha')
+      normalized['sha'].should be == 'd0f4aa01f100c26c6eae17ea637f46cf150d9c1f'
+    end
+
+    it 'does not rename commit to sha if value is not a sha' do
+      normalize 'commit' => 'foo'
+      normalized.should include('commit')
+      normalized.should_not include('sha')
+      normalized['commit'].should be == 'foo'
+    end
+
+    it 'renames commit_id to sha if value is a sha' do
+      normalize 'commit_id' => 'd0f4aa01f100c26c6eae17ea637f46cf150d9c1f'
+      normalized.should_not include('commit_id')
+      normalized.should include('sha')
+      normalized['sha'].should be == 'd0f4aa01f100c26c6eae17ea637f46cf150d9c1f'
+    end
+
+    it 'does not rename commit_id to sha if value is not a sha' do
+      normalize 'commit_id' => 'foo'
+      normalized.should include('commit_id')
+      normalized.should_not include('sha')
+      normalized['commit_id'].should be == 'foo'
+    end
+
+    it 'renames comments to comment_count if content is a number' do
+      normalize 'comments' => 42
+      normalized.should include('comment_count')
+      normalized.should_not include('comments')
+      normalized['comment_count'].should be == 42
+    end
+
+    it 'renames repositories to repository_count if content is a number' do
+      normalize 'repositories' => 42
+      normalized.should include('repository_count')
+      normalized.should_not include('repositories')
+      normalized['repository_count'].should be == 42
+    end
+
+    it 'renames repos to repository_count if content is a number' do
+      normalize 'repos' => 42
+      normalized.should include('repository_count')
+      normalized.should_not include('repos')
+      normalized['repository_count'].should be == 42
+    end
+
+    it 'renames forks to fork_count if content is a number' do
+      normalize 'forks' => 42
+      normalized.should include('fork_count')
+      normalized.should_not include('forks')
+      normalized['fork_count'].should be == 42
+    end
+
+    it 'does not rename comments to comment_count if content is not a number' do
+      normalize 'comments' => 'foo'
+      normalized.should include('comments')
+      normalized.should_not include('comment_count')
+      normalized['comments'].should be == 'foo'
+    end
+
+    it 'does not rename repositories to repository_count if content is not a number' do
+      normalize 'repositories' => 'foo'
+      normalized.should include('repositories')
+      normalized.should_not include('repository_count')
+      normalized['repositories'].should be == 'foo'
+    end
+
+    it 'does not rename repos to repository_count if content is not a number' do
+      normalize 'repos' => 'foo'
+      normalized.should include('repositories')
+      normalized.should_not include('repository_count')
+      normalized['repositories'].should be == 'foo'
+    end
+
+    it 'does not rename forks to fork_count if content is not a number' do
+      normalize 'forks' => 'foo'
+      normalized.should include('forks')
+      normalized.should_not include('fork_count')
+      normalized['forks'].should be == 'foo'
+    end
+
+    it 'renames user to owner if appropriate' do
+      normalize 'user' => 'me', 'created_at' => Time.now.xmlschema
+      normalized.should_not include('user')
+      normalized.should include('owner')
+      normalized['owner'].should be == 'me'
+    end
+
+    it 'renames user to author if appropriate' do
+      normalize 'user' => 'me', 'committed_at' => Time.now.xmlschema
+      normalized.should_not include('user')
+      normalized.should include('author')
+      normalized['author'].should be == 'me'
+    end
+
+    it 'leaves user in place if owner exists' do
+      normalize 'user' => 'me', 'created_at' => Time.now.xmlschema, 'owner' => 'you'
+      normalized.should include('user')
+      normalized.should include('owner')
+      normalized['user'].should be == 'me'
+      normalized['owner'].should be == 'you'
+    end
+
+    it 'leaves user in place if author exists' do
+      normalize 'user' => 'me', 'committed_at' => Time.now.xmlschema, 'author' => 'you'
+      normalized.should include('user')
+      normalized.should include('author')
+      normalized['user'].should be == 'me'
+      normalized['author'].should be == 'you'
+    end
+
+    it 'leaves user in place if no indication what kind of user' do
+      normalize 'user' => 'me'
+      normalized.should_not include('owner')
+      normalized.should_not include('author')
+      normalized.should include('user')
+      normalized['user'].should be == 'me'
+    end
+
+    it 'copies author to committer' do
+      normalize 'author' => 'me'
+      normalized.should include('author')
+      normalized.should include('committer')
+      normalized['author'].should be == 'me'
+      normalized['author'].should be_equal(normalized['committer'])
+    end
+
+    it 'copies committer to author' do
+      normalize 'committer' => 'me'
+      normalized.should include('author')
+      normalized.should include('committer')
+      normalized['author'].should be == 'me'
+      normalized['author'].should be_equal(normalized['committer'])
+    end
+
+    it 'does not override committer or author if both exist' do
+      normalize 'committer' => 'me', 'author' => 'you'
+      normalized.should include('author')
+      normalized.should include('committer')
+      normalized['author'].should be == 'you'
+      normalized['committer'].should be == 'me'
+    end
+  end
+
+  context 'links' do
+    it 'generates link entries from link headers' do
+      pending
+      normalize '_links' => {'href' => 'foo'}
+      with_headers
+
+      normalized.headers.should include("Link")
+      normalized.headers["Link"].should be == "something something"
+    end
+
+    it 'generates link headers from link entries'
+    it 'does not discard existing link entires'
+    it 'does not discard existing link headers'
+
+    it 'identifies _url suffix as link' do
+      normalize 'foo_url' => 'http://lmgtfy.com/?q=foo'
+      normalized.should_not include('foo_url')
+      normalized.should include("_links")
+      normalized["_links"].should include("foo")
+      normalized["_links"]["foo"].should be_a(Hash)
+      normalized["_links"]["foo"]["href"].should be == 'http://lmgtfy.com/?q=foo'
+    end
+
+    it 'identifies blog as link' do
+      normalize 'blog' => 'http://rkh.im'
+      normalized.should_not include('blog')
+      normalized.should include("_links")
+      normalized["_links"].should include("blog")
+      normalized["_links"]["blog"].should be_a(Hash)
+      normalized["_links"]["blog"]["href"].should be == 'http://rkh.im'
+    end
+
+    it 'detects avatar links from gravatar_url' do
+      normalize 'gravatar_url' => 'http://gravatar.com/avatar/93c02710978db9979064630900741691?size=50'
+      normalized.should_not include('gravatar_url')
+      normalized.should include("_links")
+      normalized["_links"].should include("avatar")
+      normalized["_links"]["avatar"].should be_a(Hash)
+      normalized["_links"]["avatar"]["href"].should be == 'http://gravatar.com/avatar/93c02710978db9979064630900741691?size=50'
+    end
+
+    it 'detects html urls in url field' do
+      normalize 'url' => 'http://github.com/foo'
+      normalized.should_not include('url')
+      normalized.should include('_links')
+      normalized['_links'].should include('html')
+      normalized['_links']['html']['href'].should be == 'http://github.com/foo'
+    end
+
+    it 'detects self urls in url field'  do
+      normalize 'url' => 'http://api.github.com/foo'
+      normalized.should_not include('url')
+      normalized.should include('_links')
+      normalized['_links'].should include('self')
+      normalized['_links'].should_not include('html')
+      normalized['_links']['self']['href'].should be == 'http://api.github.com/foo'
+    end
+  end
+end

data/spec/payloads/users/rkh.yml

@@ -0,0 +1,22 @@
+---
+- !binary "c2VydmVy": !binary |-
+    bmdpbngvMS4wLjEy
+  !binary "ZGF0ZQ==": !binary |-
+    VHVlLCAwNiBNYXIgMjAxMiAxNjo1MTozNyBHTVQ=
+  !binary "Y29udGVudC10eXBl": !binary |-
+    YXBwbGljYXRpb24vanNvbjsgY2hhcnNldD11dGYtOA==
+  !binary "dHJhbnNmZXItZW5jb2Rpbmc=": !binary |-
+    Y2h1bmtlZA==
+  !binary "Y29ubmVjdGlvbg==": !binary |-
+    a2VlcC1hbGl2ZQ==
+  !binary "c3RhdHVz": !binary |-
+    MjAwIE9L
+  !binary "eC1yYXRlbGltaXQtbGltaXQ=": !binary |-
+    NTAwMA==
+  !binary "ZXRhZw==": !binary |-
+    IjMzYjg0NTM3MTBjZjQ2OWQ1MGE5ZjJhNWM3MWM1YmU1Ig==
+  !binary "eC1yYXRlbGltaXQtcmVtYWluaW5n": !binary |-
+    NDk5NQ==
+- ! '{"type":"User","following":485,"login":"rkh","public_repos":117,"public_gists":219,"html_url":"https://github.com/rkh","blog":"http://rkh.im","hireable":false,"bio":"","location":"Potsdam,
+  Berlin, Portland","company":"Travis CI","followers":401,"url":"https://api.github.com/users/rkh","created_at":"2008-10-22T18:56:03Z","name":"Konstantin
+  Haase","email":"k.haase@finn.de","gravatar_id":"5c2b452f6eea4a6d84c105ebd971d2a4","id":30442,"avatar_url":"https://secure.gravatar.com/avatar/5c2b452f6eea4a6d84c105ebd971d2a4?d=https://a248.e.akamai.net/assets.github.com%2Fimages%2Fgravatars%2Fgravatar-140.png"}'

data/spec/payloads/users/svenfuchs.yml

@@ -0,0 +1,21 @@
+---
+- !binary "c2VydmVy": !binary |-
+    bmdpbngvMS4wLjEy
+  !binary "ZGF0ZQ==": !binary |-
+    V2VkLCAwNyBNYXIgMjAxMiAxNDo0NDowOCBHTVQ=
+  !binary "Y29udGVudC10eXBl": !binary |-
+    YXBwbGljYXRpb24vanNvbjsgY2hhcnNldD11dGYtOA==
+  !binary "dHJhbnNmZXItZW5jb2Rpbmc=": !binary |-
+    Y2h1bmtlZA==
+  !binary "Y29ubmVjdGlvbg==": !binary |-
+    a2VlcC1hbGl2ZQ==
+  !binary "c3RhdHVz": !binary |-
+    MjAwIE9L
+  !binary "eC1yYXRlbGltaXQtbGltaXQ=": !binary |-
+    NTAwMA==
+  !binary "ZXRhZw==": !binary |-
+    IjgwZjgyNzk4N2UwNGNmZjcxYWZkMjM4YjhjY2ExNjcwIg==
+  !binary "eC1yYXRlbGltaXQtcmVtYWluaW5n": !binary |-
+    NDk5OQ==
+- ! '{"html_url":"https://github.com/svenfuchs","type":"User","hireable":false,"following":90,"login":"svenfuchs","bio":"","avatar_url":"https://secure.gravatar.com/avatar/402602a60e500e85f2f5dc1ff3648ecb?d=https://a248.e.akamai.net/assets.github.com%2Fimages%2Fgravatars%2Fgravatar-140.png","public_repos":86,"blog":"http://svenfuchs.com","location":"Germany/Berlin","company":null,"followers":272,"url":"https://api.github.com/users/svenfuchs","created_at":"2008-03-04T20:38:09Z","name":"Sven
+  Fuchs","email":"me@svenfuchs.com","gravatar_id":"402602a60e500e85f2f5dc1ff3648ecb","id":2208,"public_gists":77}'

data/spec/remote_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe GH::Remote do
+  it 'loads resources from github' do
+    stub_request(:get, "https://api.github.com/foo").to_return(:body => '["foo"]')
+    subject['foo'].to_s.should be == '["foo"]'
+  end
+
+  it 'sets headers correctly' do
+    stub_request(:get, "https://api.github.com/foo").to_return(:headers => {'X-Foo' => 'bar'}, :body => '[]')
+    subject['foo'].headers['x-foo'].should be == 'bar'
+  end
+
+  it 'raises an exception for missing resources' do
+    stub_request(:get, "https://api.github.com/foo").to_return(:status => 404)
+    expect { subject['foo'] }.to raise_error(Faraday::Error::ResourceNotFound)
+  end
+
+  it 'parses the body' do
+    stub_request(:get, "https://api.github.com/foo").to_return(:body => '{"foo":"bar"}')
+    subject['foo']['foo'].should be == 'bar'
+  end
+end

data/spec/response_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe GH::Response do
+  it 'is specified'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,62 @@
+require 'gh'
+require 'webmock/rspec'
+require 'yaml'
+require 'fileutils'
+
+module GH
+  module TestHelpers
+    def backend
+      subject.backend
+    end
+
+    def requests
+      backend.requests
+    end
+
+    def data
+      backend.data
+    end
+  end
+
+  class MockBackend < Wrapper
+    attr_accessor :data, :requests
+
+    def setup(*)
+      @data, @requests = {}, []
+      super
+    end
+
+    def [](key)
+      key  = path_for(key)
+      file = File.expand_path("../payloads/#{key}.yml", __FILE__)
+      @requests << key
+
+      result = @data[key] ||= begin
+        unless File.exist? file
+          res = allow_http { super }
+          FileUtils.mkdir_p File.dirname(file)
+          File.write file, [res.headers, res.body].to_yaml
+        end
+
+        Response.new(*YAML.load_file(file))
+      end
+
+      result = Response.new({}, result) unless result.is_a? Response
+      result
+    end
+
+    private
+
+    def allow_http
+      raise Faraday::Error::ResourceNotFound if ENV['CI']
+      WebMock.allow_net_connect!
+      yield
+    ensure
+      WebMock.disable_net_connect!
+    end
+  end
+end
+
+RSpec.configure do |c|
+  c.include GH::TestHelpers
+end

data/spec/stack_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe GH::Stack do
+  it 'is specified'
+end

data/spec/wrapper_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe GH::Wrapper do
+  it 'is specified'
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: gh
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Konstantin Haase
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70328844248000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70328844248000
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: &70328844247440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70328844247440
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: &70328844262860 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70328844262860
+- !ruby/object:Gem::Dependency
+  name: backports
+  requirement: &70328844262340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70328844262340
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: &70328844261880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70328844261880
+description: multi-layer client for the github api v3
+email:
+- konstantin.mailinglists@googlemail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- README.md
+- Rakefile
+- gh.gemspec
+- lib/gh.rb
+- lib/gh/cache.rb
+- lib/gh/case.rb
+- lib/gh/faraday.rb
+- lib/gh/normalizer.rb
+- lib/gh/remote.rb
+- lib/gh/response.rb
+- lib/gh/stack.rb
+- lib/gh/version.rb
+- lib/gh/wrapper.rb
+- spec/cache_spec.rb
+- spec/normalizer_spec.rb
+- spec/payloads/users/rkh.yml
+- spec/payloads/users/svenfuchs.yml
+- spec/remote_spec.rb
+- spec/response_spec.rb
+- spec/spec_helper.rb
+- spec/stack_spec.rb
+- spec/wrapper_spec.rb
+homepage: ''
+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: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: layered github client
+test_files:
+- spec/cache_spec.rb
+- spec/normalizer_spec.rb
+- spec/payloads/users/rkh.yml
+- spec/payloads/users/svenfuchs.yml
+- spec/remote_spec.rb
+- spec/response_spec.rb
+- spec/spec_helper.rb
+- spec/stack_spec.rb
+- spec/wrapper_spec.rb