ghee 0.7.0

data/lib/ghee/api/users.rb

@@ -0,0 +1,72 @@
+class Ghee
+
+  # API module encapsulates all of API endpoints
+  # implemented thus far
+  #
+  module API
+
+    # The Users module handles all of the Github User
+    # API endpoints
+    #
+    module Users
+
+      # Users::Proxy inherits from Ghee::Proxy and
+      # enables defining methods on the proxy object
+      #
+      class Proxy < ::Ghee::ResourceProxy
+        include Ghee::CUD
+
+        # Gists for a user
+        #
+        # Returns json
+        #
+        def gists(params={})
+          Ghee::API::Gists::Proxy.new(connection,"#{path_prefix}/gists",params)
+        end
+
+        # Repos for a user
+        #
+        # Returns json
+        #
+        def repos(name=nil, params={})
+          params = name if name.is_a?Hash
+          prefix = name.is_a?(String) ? "/repos/#{self["login"]}/#{name}" : "#{path_prefix}/repos" 
+          Ghee::API::Repos::Proxy.new(connection,prefix, params)
+        end
+
+        # Returns list of the provided users organizations or 
+        # an organization by name
+        #
+        # org - String name of the organization (optional)
+        #
+        # Returns json
+        #
+        def orgs(org=nil, params={})
+          params = org if org.is_a?Hash
+          prefix = org.is_a?(String) ? "/orgs/#{org}" : "#{path_prefix}/orgs"
+          Ghee::API::Orgs::Proxy.new(connection, prefix, params)
+        end
+
+       
+      end
+
+      # Get authenticated user
+      #
+      # Returns json
+      #
+      def user
+        Proxy.new(connection, '/user')
+      end
+
+      # Get a single user
+      #
+      # user - String of user login
+      #
+      # Returns json
+      #
+      def users(user)
+        Proxy.new(connection, "/users/#{user}")
+      end
+    end
+  end
+end

data/lib/ghee/connection.rb

@@ -0,0 +1,33 @@
+require 'faraday'
+require 'faraday_middleware'
+require 'multi_json'
+
+class Ghee
+  class Connection < Faraday::Connection
+    attr_reader :hash
+
+    # Instantiates connection, accepts an options hash
+    # for authenticated access
+    #
+    # OAuth2 expects
+    #   :access_token => "OAuth Token" 
+    #
+    # Basic auth expects
+    #   :basic_auth => {:user_name => "octocat", :password => "secret"}
+    def initialize(hash={})
+      @hash = hash
+      access_token = hash[:access_token] if hash.has_key?:access_token
+      basic_auth = hash[:basic_auth] if hash.has_key?:basic_auth
+
+      super('https://api.github.com') do |builder|
+        builder.use     Faraday::Request::JSON
+        builder.use     Faraday::Response::ParseJson
+        builder.adapter Faraday.default_adapter
+      end
+
+      self.headers["Authorization"] = "token #{access_token}" if access_token
+      self.basic_auth(basic_auth[:user_name], basic_auth[:password]) if basic_auth
+      self.headers["Accept"] = 'application/json'
+    end
+  end
+end

data/lib/ghee/resource_proxy.rb

@@ -0,0 +1,111 @@
+class Ghee
+
+  # ResourceProxy lets us create a virtual
+  # proxy for any API resource, utilizing
+  # method_missing to handle passing
+  # messages to the real object
+  #
+  class ResourceProxy
+
+    # Undefine methods that might get in the way
+    instance_methods.each { |m| undef_method m unless m =~ /^__|instance_eval|instance_variable_get|object_id/ }
+
+    # Make connection and path_prefix readable
+    attr_reader :connection, :path_prefix, :params
+
+    # Expose pagination data
+    attr_reader :current_page, :total, :pagination
+
+    # Instantiates proxy with the connection
+    # and path_prefix
+    #
+    # connection - Ghee::Connection object
+    # path_prefix - String
+    #
+    def initialize(connection, path_prefix, params = {})
+      @connection, @path_prefix, @params = connection, path_prefix, params
+    end
+
+    # Method_missing takes any message passed
+    # to the ResourceProxy and sends it to the
+    # real object
+    #
+    # message - Message object
+    # args* - Arguements passed
+    #
+    def method_missing(message, *args, &block)
+      subject.send(message, *args, &block)
+    end
+
+    # Subject is the response body parsed
+    # as json
+    #
+    # Returns json
+    #
+    def subject
+      @subject ||= connection.get(path_prefix){|req| req.params.merge!params }.body
+    end
+
+    # Paginate is a helper method to handle
+    # request pagination to the github api
+    #
+    # options - Hash containing pagination params
+    # eg; 
+    #     :per_page => 100, :page => 1
+    #
+    # Returns self
+    #
+    def paginate(options)
+      @current_page = options.fetch(:page) {raise ArgumentError, ":page parameter required"}
+      per_page = options.delete(:per_page) || 30
+      response = connection.get do |req|
+        req.url path_prefix, :per_page => per_page, :page => current_page
+        req.params.merge! params
+      end
+
+      if @subject.nil?
+        @subject = response.body
+      else
+        @subject = @subject.concat response.body
+      end
+
+      parse_link_header response.headers.delete("link")
+
+      return self      
+    end
+
+    def all
+      return self if pagination && next_page.nil?
+
+      self.paginate :per_page => 100, :page => next_page || 1
+
+      self.all
+    end
+
+    # Generate first_page, last_page, next_page, prev_page convienence methods
+    %w{ next prev first last }.each do |term|
+      define_method "#{term}_page" do
+        pagination ? pagination[term.to_sym] ? pagination[term.to_sym][:page] : nil : nil
+      end
+    end
+
+    private 
+
+    def parse_link_header(header)
+      return @total = subject.size, @pagination = {} if header.nil?
+      require 'cgi'
+      pattern = /<(?<link>.*)>;\s+rel="(?<rel>.*)"/
+        matches = {}
+      header.split(',').each do |m|
+        match = pattern.match m
+        uri = URI.parse(match[:link])
+        uri_params = CGI.parse(uri.query)
+        page = uri_params["page"].first.to_i
+        per_page = uri_params["per_page"] ? uri_params["per_page"].first.to_i : 30
+        matches[match[:rel].to_sym] = {:link => match[:link], :page => page, :per_page => per_page}
+      end
+      @pagination = matches
+    end
+
+  end
+end

data/lib/ghee/state_methods.rb

@@ -0,0 +1,29 @@
+class Ghee
+  module CUD
+
+    # Creates 
+    #
+    # return json
+    #
+    def create(attributes)
+      connection.post(path_prefix,attributes).body
+    end
+
+    # Patchs 
+    #
+    # return json
+    #
+    def patch(attributes)
+      connection.patch(path_prefix, attributes).body
+    end
+
+    # Destroys 
+    #
+    # return boolean
+    #
+    def destroy
+      connection.delete(path_prefix).status == 204
+    end
+  end
+
+end

data/lib/ghee/version.rb

@@ -0,0 +1,4 @@
+# encoding: UTF-8
+class Ghee
+  VERSION = "0.7.0"
+end

data/spec/ghee/api/authorizations_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Ghee::API::Authorizations do
+  subject { Ghee.new(GH_AUTH) }
+
+  describe "#authorizations" do
+
+    context "with a test authorization" do 
+      before :all do 
+        VCR.use_cassette "authorizations.create.test" do
+          @test_auth = subject.authorizations.create :scopes => ["public_repo"]
+          @test_auth.should_not be_nil
+        end
+      end
+
+      let(:test_auth) {@test_auth}
+
+      it "should return an auth" do 
+        VCR.use_cassette "authorizations(id)" do 
+          auth = subject.authorizations(test_auth["id"])
+          auth["scopes"].should include("public_repo")
+        end
+      end
+
+      it "should return a list of auths" do 
+        VCR.use_cassette "authorizations" do 
+          auth = subject.authorizations
+          auth.size().should > 0
+        end
+      end
+
+      it "should patch an auth" do 
+        VCR.use_cassette "authorization(id).patch" do 
+          auth = subject.authorizations(test_auth["id"]).patch :add_scopes => ["repo"]
+          auth["scopes"].should include("repo")
+        end
+      end
+
+      after :all do 
+        VCR.use_cassette "authorizations(id).destroy" do 
+          subject.authorizations(test_auth["id"]).destroy.should be_true
+        end
+      end
+    end
+  end
+end

data/spec/ghee/api/events_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Ghee::API::Events do
+  subject { Ghee.new(GH_AUTH) }
+
+  EventTypes = ["CommitComment","CreateEvent","DeleteEvent","DownloadEvent","FollowEvent",
+  "ForkEvent","ForkApplyEvent","GistEvent","GollumEvent","IssueCommentEvent",
+  "IssuesEvent","MemberEvent","PublicEvent","PullRequestEvent","PushEvent",
+  "TeamAddEvent","WatchEvent"]
+
+  def should_be_an_event(event)
+    EventTypes.should include(event['type'])
+    event['repo'].should be_instance_of(Hash)
+    event['actor'].should be_instance_of(Hash)
+    event['org'].should be_instance_of(Hash)
+    event['created_at'].should_not be_nil
+  end
+
+  describe "#events" do
+    it "should return public events" do
+      VCR.use_cassette('events') do
+        events = subject.events
+        events.size.should > 0
+        should_be_an_event(events.first)
+      end
+    end
+    describe "#paginate" do 
+      it "should return page 1" do
+        VCR.use_cassette "events.page1" do
+          events = subject.events.paginate :page => 1
+          events.size.should > 0
+          events.next_page.should == 2
+          should_be_an_event(events.first)
+        end
+      end
+      it "should return page 2" do
+        VCR.use_cassette "events.page2" do
+          events = subject.events.paginate :page => 2
+          events.size.should > 0
+          events.next_page.should == 3
+          events.prev_page.should == 1
+          should_be_an_event(events.first)
+        end
+      end
+    end
+  end
+end

data/spec/ghee/api/gists_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+
+describe Ghee::API::Gists do
+  subject { Ghee.new(GH_AUTH) }
+
+  def should_be_a_gist(gist)
+    gist['url'].should include('https://api.github.com/gists/')
+    gist['user']['url'].should include('https://api.github.com/users/')
+    gist['created_at'].should_not be_nil
+    gist['files'].should be_instance_of(Hash)
+    gist['files'].size.should > 0
+  end
+
+  describe "#users" do
+    describe "#gists" do
+      it "should return users gists" do
+        VCR.use_cassette('users(login).gists') do
+          gists = subject.users('jonmagic').gists
+          gists.size.should > 0
+          should_be_a_gist(gists.first)
+        end
+      end
+    end
+  end
+
+  describe "#gists" do
+    it "should return gists for authenticated user" do
+      VCR.use_cassette('gists') do
+        gists = subject.gists
+        gists.size.should > 0
+        should_be_a_gist(gists.first)
+      end
+    end
+
+    describe "#public" do
+      it "should return public gists" do
+        VCR.use_cassette('gists.public') do
+          gists = subject.gists.public
+          gists.size.should > 0
+          should_be_a_gist(gists.first)
+        end
+      end
+    end
+
+    describe "#starred" do
+      it "should return starred gists" do
+        VCR.use_cassette('gists.starred') do
+          gists = subject.gists.starred
+          gists.size.should > 0
+          should_be_a_gist(gists.first)
+        end
+      end
+    end
+
+    describe "#create" do
+      it "should create a gist" do
+        VCR.use_cassette('gists.create') do
+          gist = subject.gists.create({
+            :description => "Testing the ghee api",
+            :public => true,
+            :files => {
+              'ghee_test.txt' => {
+                :content => "Booya!"
+              }
+            }
+          })
+          should_be_a_gist(gist)
+          subject.gists(gist['id']).destroy
+        end
+      end
+    end
+
+    context "with gist id" do
+      before(:all) do
+        VCR.use_cassette('gists.test') do
+          @test_gist = subject.gists.create({:public => false, :files => {'file.txt' => {:content => 'ready to destroy'}}})
+        end
+      end
+      let(:test_gist) { @test_gist }
+
+      it "should return single gist" do
+        VCR.use_cassette('gists(id)') do
+          gist = subject.gists(test_gist['id'])
+          gist['id'].should == test_gist['id']
+          should_be_a_gist(gist)
+        end
+      end
+
+      describe "#patch" do
+        it "should patch the gist" do
+          VCR.use_cassette('gists(id).patch') do
+            gist = subject.gists(test_gist['id']).patch({
+              :files => {
+                'test.md' => {
+                  :content => 'clarified butter'
+                }
+              }
+            })
+            should_be_a_gist(gist)
+            gist['files']['test.md']['content'].should == 'clarified butter'
+          end
+        end
+      end
+
+      describe "#star" do
+        it "should star the gist" do
+          VCR.use_cassette('gists(id).star') do
+            subject.gists(test_gist['id']).star.should be_true
+          end
+        end
+      end
+
+      describe "#unstar" do
+        it "should star the gist" do
+          VCR.use_cassette('gists(id).unstar') do
+            subject.gists(test_gist['id']).unstar.should be_true
+          end
+        end
+      end
+
+      describe "#starred?" do
+        it "should return true if gist is starred" do
+          VCR.use_cassette('gists(id).starred? is true') do
+            subject.gists(test_gist['id']).star
+            subject.gists(test_gist['id']).starred?.should be_true
+          end
+        end
+
+        it "should return false if gist is unstarred" do
+          VCR.use_cassette('gists(id).starred? is false') do
+            subject.gists(test_gist['id']).unstar
+            subject.gists(test_gist['id']).starred?.should be_false
+          end
+        end
+      end
+
+      describe "#destroy" do
+        it "should delete the gist and return true" do
+          VCR.use_cassette('gists(id).destroy true') do
+            gist = subject.gists.create({:public => false, :files => {'file.txt' => {:content => 'ready to destroy'}}})
+            subject.gists(gist['id']).destroy.should be_true
+          end
+        end
+
+        it "should return false if gist doesn't exist" do
+          VCR.use_cassette('gists(id).destroy false') do
+            subject.gists("12345678901234567890").destroy.should be_false
+          end
+        end
+      end
+    end
+  end
+end