fuselage 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 fuselage.gemspec
+gemspec

data/README.markdown

@@ -0,0 +1,65 @@
+#Fuselage
+
+Fuselage is a light weight Ruby wrapper for the Github v3 api. It was inspired by the Github v2 Ruby wrapper octopi.
+
+It was created for Gitpilot. Check us out at: http://www.gitpilot.com
+
+##Credits
+
+* Corey Collins
+* JP Richardson
+
+##Install
+
+Fuselage can easily be installed as a Ruby gem:
+
+    $ [sudo] gem install fuselage
+
+##Usage
+
+To use fuselage just include it in your script:
+
+    require 'fuselage'
+
+    include Fuselage
+
+###Authenicated
+
+If you have genereated a access token through github, then you can use the authenicated api with this method:
+
+    authenicated do
+      repo = Repository.find('private-repo')
+    end
+
+###Anonymous
+
+Otherwise, if you are not authenticated there is no need to wrap your method call in the block. Like:
+
+    repo = Repository.find('public-repo')
+
+
+## API Completed
+
+This is still a work in progress and not all of the api has been mapped yet. So far these have been mapped.
+
+**1. Users**
+
+**2. Repos**
+
+**3. Git Data**
+
+##License
+
+Copyright (c) 2011, Gitpilot LLC
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

data/Rakefile

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'rake'
+require 'bundler'
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.libs << File.dirname(__FILE__)
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = false
+end
+
+task :default => :test

data/examples/authenticated.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.join(File.dirname(__FILE__), %w[.. lib cockpit]))
+
+include Fuselage
+
+access_token = "YOUR ACCESS TOKEN"
+
+#Creating a branch on a private repo
+
+authenticated(access_token) do 
+
+  #Find the repo.
+  repo = Repository.find('private-repo')
+  
+  # Get the most recent commit to point the reference to.
+  recent_commit = repo.most_recent_commit
+  
+  #Create the reference
+  ref = Reference.create(repo.name, 'new-branch', recent_commit.sha)
+  
+  puts ref
+end

data/examples/simple.rb

@@ -0,0 +1,6 @@
+require File.expand_path(File.join(File.dirname(__FILE__), %w[.. lib cockpit]))
+
+include Fuselage
+
+user = User.find 'coreycollins'
+puts user

data/fuselage.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "fuselage/version"
+
+Gem::Specification.new do |s|
+  s.name        = "fuselage"
+  s.version     = Fuselage::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Corey Collins"]
+  s.email       = ["corey@gitpilot.com"]
+  s.homepage    = ""
+  s.summary     = %q{LightWeight Github API v3 Wrapper}
+  s.description = %q{LightWeight Github API v3 Wrapper}
+
+  s.rubyforge_project = "fuselage"
+  
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "fakeweb"
+  s.add_dependency "httparty"
+
+  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"]
+end

data/lib/fuselage/api.rb

@@ -0,0 +1,100 @@
+require 'singleton'
+
+module Fuselage
+  # Dummy class, so AnonymousApi and AuthApi have somewhere to inherit from
+  class Api
+    attr_accessor :token, :read_only
+  end
+  
+  # Used for accessing the Github API anonymously
+  class AnonymousApi < Api
+    include HTTParty
+    include Singleton
+    base_uri "https://api.github.com"
+    
+    def read_only?
+      true
+    end
+    
+    def auth_parameters
+      { }
+    end
+  end
+  
+  class AuthApi < Api
+    include HTTParty
+    include Singleton
+    base_uri "https://api.github.com"
+    
+    def read_only?
+      false
+    end
+    
+    def auth_parameters
+      {:access_token => Api.me.token }
+    end
+  end
+  
+  # This is the real API class.
+  #
+  # API requests are limited to 60 per minute.
+  #
+  # Sets up basic methods for accessing the API.
+  class Api
+    @@api = Fuselage::AnonymousApi.instance
+    @@authenticated = false
+    
+    include Singleton
+    
+    RETRYABLE_STATUS = [403]
+    MAX_RETRIES = 5
+    # Would be nice if cattr_accessor was available, oh well.
+    
+    # We use this to check if we use the auth or anonymous api
+    def self.authenticated
+      @@authenticated
+    end
+    
+    # We set this to true when the user has auth'd.
+    def self.authenticated=(value)
+      @@authenticated = value
+    end
+    
+    # The API we're using 
+    def self.api
+      @@api
+    end
+    
+    class << self
+      alias_method :me, :api
+    end
+    
+    # set the API we're using
+    def self.api=(value)
+      @@api = value
+    end
+  
+    def get(path, params = {}, klass=nil)
+      resp = self.class.get(path, { :query => params.merge(auth_parameters) })
+      raise NotFound, klass || self.class if resp.code.to_i == 404
+      raise APIError, 
+        "GitHub returned status #{resp.code}" unless resp.code.to_i == 200 || resp.code.to_i == 201
+      resp
+    end
+  
+    def post(path, params = {}, klass=nil)
+      resp = self.class.post(path, { :query => auth_parameters, :body => params.to_json } )
+      raise NotFound, klass || self.class if resp.code.to_i == 404
+      raise APIError, 
+        "GitHub returned status #{resp.code}" unless resp.code.to_i == 200 || resp.code.to_i == 201
+      resp
+    end
+
+    private
+    
+    def method_missing(method, *args)
+      api.send(method, *args)
+    end
+    
+  end
+end

data/lib/fuselage/base.rb

@@ -0,0 +1,27 @@
+module Fuselage
+  class Base
+
+    attr_accessor :api
+    
+    def initialize(attributes={})
+      # Useful for finding out what attr_accessor needs for classes
+      # puts caller.first.inspect
+      # puts "#{self.class.inspect} #{attributes.keys.map { |s| s.to_sym }.inspect}"
+      attributes.each do |key, value|
+        method = "#{key}="
+        self.send(method, value) if respond_to? method
+      end
+    end
+
+    def self.get(path, params={})
+      response = Api.api.get(path, params, self)
+      response.parsed_response
+    end
+
+    def self.post(path, params={})
+      response = Api.api.post(path, params, self)
+      response.parsed_response
+    end
+    
+  end
+end

data/lib/fuselage/blob.rb

@@ -0,0 +1,31 @@
+module Fuselage
+  class Blob < Base
+
+    attr_accessor :sha, :content, :encoding
+
+    # Find a blob
+    #
+    #   examples:
+    #     Blob.find('cockpit', '45f6d8e74e145b910be4e15f67ef3892fe7abb26')
+    def self.find(repo, sha, user=nil)
+      raise AuthenticationRequired unless Api.authenticated
+      user ||= User.current.login
+      Blob.new(get("/repos/#{user}/#{repo}/git/blobs/#{sha}").merge(:sha => sha))
+    end
+    
+    # Create a blob
+    #
+    # Content must be in utf-8 encoding.
+    # TODO: Add suport for base-64.
+    #
+    #   examples:
+    #     Blob.create('cockpit', 'Some really cool data.')
+    def self.create(repo, content)
+      raise AuthenticationRequired unless Api.authenticated
+      params = {:content => content, :encoding => 'utf-8'}
+      user = User.current.login
+      Blob.new(post("/repos/#{user}/#{repo}/git/blobs", params))
+    end
+
+  end
+end

data/lib/fuselage/commit.rb

@@ -0,0 +1,49 @@
+module Fuselage
+  class Commit < Base
+
+    attr_accessor :sha, :message, :parents, :author, :url, :tree, :committer
+
+    # Find a commit
+    #
+    #   examples:
+    #     Blob.find('cockpit', '45f6d8e74e145b910be4e15f67ef3892fe7abb26')
+    def self.find(repo, sha, user=nil)
+      raise AuthenticationRequired unless Api.authenticated
+      user ||= User.current.login
+      Commit.new(get("/repos/#{user}/#{repo}/commits/#{sha}"))
+    end
+
+    # Create a commit
+    #
+    # Options:
+    #  :author
+    #     :name
+    #     :date
+    #     :email
+    #  :committer
+    #     :name
+    #     :date
+    #     :email
+    #
+    #   examples:
+    #     Commit.create('cockpit', 'This is a new commit', '45f6d8e74e145b910be4e15f67ef3892fe7abb26', ['45f6d8e74e145b910be4e15f67ef3892fe7abb26'])
+    #     
+    #     Commit.create('cockpit', 'Comit with author', '45f6d8e74e145b910be4e15f67ef3892fe7abb26', ['45f6d8e74e145b910be4e15f67ef3892fe7abb26'], {
+    #       :author => {:name => 'Corey', :email => 'corey@gitpilot.com'}
+    #     })
+    def self.create(repo, message, tree, parents=[], options={})
+      raise AuthenticationRequired unless Api.authenticated
+      params = {:message => message, :tree => tree, :parents => parents}.merge(options)
+      user = User.current.login
+      Commit.new(post("/repos/#{user}/#{repo}/git/commits", params))
+    end
+  
+    def merge_attributes(attributes)
+      attributes.each do |key, value|
+        method = "#{key}="
+        self.send(method, value) if respond_to? method
+      end
+    end
+
+  end
+end

data/lib/fuselage/error.rb

@@ -0,0 +1,28 @@
+module Fuselage
+  
+  class RegisterError < StandardError; end
+  
+  class FormatError < StandardError
+   def initialize(f)
+     super("Got unexpected format (got #{f.first} for #{f.last})")
+   end
+  end
+  
+  class AuthenticationRequired < StandardError
+  end
+
+  class APIError < StandardError
+  end
+  
+  class InvalidLogin < StandardError
+  end
+
+  class ArgumentMustBeHash < Exception; end
+  
+  class NotFound < Exception
+    def initialize(klass)
+      super "The #{klass.to_s.split("::").last} could not be found or created. It could be private."
+    end
+  end
+  
+end

data/lib/fuselage/reference.rb

@@ -0,0 +1,50 @@
+module Fuselage
+  class Reference < Base
+
+    attr_accessor :ref, :url, :object
+
+    # Find a reference
+    #   
+    #   ref must have 'heads/' in front of branch name
+    #
+    #   examples:
+    #     Reference.find('cockpit', 'hads/master')
+    def self.find(repo, ref, user=nil)
+      raise AuthenticationRequired unless Api.authenticated
+      user ||= User.current.login
+      Reference.new(get("/repos/#{user}/#{repo}/git/refs/#{ref}"))
+    end
+
+    # Finds all the refs for a given repo.
+    def self.find_all(repo, user=nil)
+      raise AuthenticationRequired unless Api.authenticated
+      user ||= User.current.login
+      refs = []
+      get("/repos/#{user}/#{repo}/git/refs").each { |r| refs << Reference.new(r) }
+      refs
+    end
+
+    def self.create(repo, ref, sha)
+      raise AuthenticationRequired unless Api.authenticated
+      params = {:ref => ref, :sha => sha}
+      user = User.current.login
+      Reference.new(post("/repos/#{user}/#{repo}/git/refs", params))
+    end
+
+    def self.update(repo, ref, sha, force=true, user=nil)
+      raise AuthenticationRequired unless Api.authenticated
+      params = {:force => force, :sha => sha}
+      user ||= User.current.login
+      Reference.new(post("/repos/#{user}/#{repo}/git/refs/#{ref}", params))
+    end
+    
+    def sha
+      object['sha'] if object
+    end
+
+    def to_s
+      ref
+    end
+
+  end
+end

data/lib/fuselage/repository.rb

@@ -0,0 +1,111 @@
+module Fuselage
+  class Repository < Base
+
+    attr_accessor :description, :url, :forks, :name, :homepage, :watchers, 
+                  :owner, :private, :fork, :open_issues, :pledgie, :size
+
+
+    # Finds a repo with current authenticated user
+    #
+    def self.find(repo, options={})
+      options = {:type => 'all'}.merge(options)
+      if options[:user]
+        Repository.new(get("/repos/#{options[:user]}/#{repo}", {:type => options[:type]}))
+      else
+        raise AuthenticationRequired unless Api.authenticated
+        Repository.new(get("/repos/#{User.current.login}/#{repo}", {:type => options[:type]}))
+      end
+    end
+
+    # Finds all public repos identified by the given username
+    #
+    def self.find_all(options={})
+      options = {:type => 'all'}.merge(options)
+      repos = []
+      if options[:user]
+        get("/users/#{options[:user]}/repos", {:type => options[:type]}).each { |r| repos << Repository.new(r) }
+      else
+        raise AuthenticationRequired unless Api.authenticated
+        get("/user/repos", {:type => options[:type]}).each { |r| repos << Repository.new(r) }
+      end
+      repos
+    end
+
+    # Finds all public repos identified by the given organization
+    #
+    def self.find_by_organization(organization, options={})
+      options = {:type => 'all'}.merge(options)
+      repos = []
+      get("/orgs/#{organization}/repos", {:type => options[:type]}).each { |r| repos << Repository.new(r) }
+      repos
+    end
+
+    def self.create(name, options={})
+      raise AuthenticationRequired unless Api.authenticated
+      Repository.new(post('/user/repos', {:name => name}.merge(options)))
+    end
+
+    def tags
+      raise AuthenticationRequired unless Api.authenticated
+      tags = []
+      Repository.get("/repos/#{User.current.login}/#{self.name}/tags").each do |t| 
+        tag = Tag.new
+        tag.tag = t['name']
+        if t['commit']
+          tag.object = t['commit']
+          tag.object['type'] = 'commit'
+        end
+        tags << tag
+      end
+      tags
+    end
+
+    def branches
+      raise AuthenticationRequired unless Api.authenticated
+      branches = []
+      Repository.get("/repos/#{User.current.login}/#{self.name}/branches").each do |b| 
+        branch = Reference.new
+        branch.ref = 'ref/heads/' + b['name']
+        branch.url = b['url']
+        if b['commit']
+          branch.object = b['commit']
+          branch.object['type'] = 'commit'
+        end
+        branches << branch
+      end
+      branches
+    end
+
+    def commits(options={})
+      raise AuthenticationRequired unless Api.authenticated
+      commits = []
+      Repository.get("/repos/#{User.current.login}/#{self.name}/commits", options).each do |c| 
+        commit = Commit.new(c)
+        if c['commit']
+          commit.merge_attributes(c['commit'])
+        end
+        commits << commit
+      end
+      commits
+    end
+
+    def most_recent_commit(ref_sha)
+      commits = self.commits(:sha => ref_sha)
+      commits.first
+    end
+    
+    def create_branch(name, parent_sha)
+      Reference.create(self.name, "refs/heads/#{name}", parent_sha)
+    end
+
+    def to_s
+      name
+    end
+    
+    def pp
+      
+    end
+
+  end
+end
+                  

data/lib/fuselage/tag.rb

@@ -0,0 +1,44 @@
+module Fuselage
+  class Tag < Base
+    attr_accessor :tag, :sha, :message, :tagger, :object, :url
+
+    # Find a tag
+    #
+    #   examples:
+    #     Tag.find('cockpit', '45f6d8e74e145b910be4e15f67ef3892fe7abb26')
+    def self.find(repo, sha, user=nil)
+      raise AuthenticationRequired unless Api.authenticated
+      user ||= User.current.login
+      Tag.new(get("/repos/#{user}/#{repo}/git/tags/#{sha}"))
+    end
+
+    # Create a tag
+    #
+    #
+    # Options:
+    #  :type,    values: 'commit', 'tree', and 'blob'. default is commit
+    #  :tagger
+    #     :name
+    #     :date
+    #     :email
+    #
+    #   examples:
+    #     Tag.create('cockpit', v1.0', 'New tag', '45f6d8e74e145b910be4e15f67ef3892fe7abb26')
+    #     
+    #     Commit.create('cockpit', v1.0', 'New tag', '45f6d8e74e145b910be4e15f67ef3892fe7abb26', {
+    #       :tagger => {:name => 'Corey', :email => 'corey@gitpilot.com'}
+    #     })
+    def self.create(repo, tag, message, object, options={})
+      raise AuthenticationRequired unless Api.authenticated
+      options = {:type => 'commit'}.merge(options)
+      params = {:tag => tag, :message => message, :object => object}.merge(options)
+      user = User.current.login
+      Tag.new(post("/repos/#{user}/#{repo}/git/blobs", params))
+    end
+
+    def to_s
+      tag
+    end
+
+  end
+end

data/lib/fuselage/tree.rb

@@ -0,0 +1,41 @@
+module Fuselage
+  class Tree < Base
+
+    attr_accessor :sha, :url, :tree, :path, :mode
+    
+    # Find a tree
+    #
+    #   examples:
+    #     Tree.find('cockpit', '45f6d8e74e145b910be4e15f67ef3892fe7abb26')
+    def self.find(repo, sha, user=nil)
+      raise AuthenticationRequired unless Api.authenticated
+      user ||= User.current.login
+      Commit.new(get("/repos/#{user}/#{repo}/trees/#{sha}"))
+    end
+
+    # Create a tree
+    #
+    # Tree Hash:
+    #   :path => 'file',
+    #   :mode => '100644',    refer to http://developer.github.com/v3/git/trees/ for modes.
+    #   :type => 'commit',    values: 'commit', 'tree', and 'blob'. 
+    #   :sha => '45f6d8e74e145b910be4e15f67ef3892fe7abb26'
+    #     or 
+    #   :content => 'Some UTF-8 Encoded Content'
+    #
+    # Options:
+    #  :type,    values: 'commit', 'tree', and 'blob'. default is commit
+    #  :tagger
+    #     :name
+    #     :date
+    #     :email
+    #
+    def self.create(repo, tree_hashes=[], options={})
+      raise AuthenticationRequired unless Api.authenticated
+      params = {:tree => tree_hashes }.merge(options)
+      user = User.current.login
+      Tree.new(post("/repos/#{user}/#{repo}/git/trees", params))
+    end
+    
+  end
+end