github_api 0.1.0.pre

data/lib/github_api/repos/commits.rb

@@ -0,0 +1,115 @@
+# encoding: utf-8
+
+module Github
+  class Repos
+    module Commits
+      
+      REQUIRED_COMMENT_PARAMS = %w[ body commit_id line path position ]
+
+      # Creates a commit comment
+      #
+      # = Examples
+      #  @github = Github.new
+      #  @github.repos.create_comment(...)
+      #
+      def create_comment(user_name=nil, repo_name=nil, params={})
+        raise ArgumentError, "Expected following inputs to the method: #{REQUIRED_COMMENT_PARAMS.join(', ')}" unless _validate_inputs(REQUIRED_COMMENT_PARAMS, inputs)
+
+        post("/repos/#{user}/#{repo}/commits/#{sha}/comments", inputs)
+      end
+      
+      # Deletes a commit comment
+      #
+      # = Examples
+      #  @github = Github.new
+      #  @github.repos.delete_comment(...)
+      #
+      def delete_comment(user, repo, comment_id)
+        delete("/repos/#{user}/#{repo}/comments/#{comment_id}")
+      end
+
+      # List commits on a repository
+      #
+      # = Parameters
+      #  :sha   Optional string. Sha or branch to start listing commits from.
+      #  :path  Optional string. Only commits containing this file path will be returned
+      # = Examples
+      #  @github = Github.new
+      #  @github.repos.commits('user-name', 'repo-name', { :sha => ... })
+      #
+      def commits(user_name=nil, repo_name=nil, params={})
+        _update_user_repo_params(user_name, repo_name)      
+        _validate_user_repo_params(user, repo) unless user? && repo?
+        _normalize_params_keys(params)
+        _filter_params_keys(%w[ sha path], params)
+
+        response = get("/repos/#{user}/#{repo}/commits", params)
+        return response unless block_given?
+        response.each { |el| yield el }
+      end
+
+      # List commit comments for a repository
+      # 
+      # = Examples
+      #  @github = Github.new
+      #  @github.repos.list_repo_comments('user-name', 'repo-name')
+      #
+      def list_repo_comments(user_name=nil, repo_name=nil)
+        _update_user_repo_params(user_name, repo_name)      
+        _validate_user_repo_params(user, repo) unless user? && repo?
+
+        response = get("/repos/#{user}/#{repo}/comments")
+        return response unless block_given?
+        response.each { |el| yield el }
+      end
+      
+      # List comments for a single commit
+      #
+      # = Examples
+      #  @github = Github.new
+      #  @github.repos.list_commit_comments('user-name', 'repo-name', '6dcb09b5b57875f334f61aebed695e2e4193db5e')
+      #
+      def list_commit_comments(user, repo, sha)
+        get("/repos/#{user}/#{repo}/commits/#{sha}/comments")
+      end
+      
+      # Gets a single commit
+      # 
+      # Examples: 
+      #  @github = Github.new
+      #  @github.repos.get_commit('user-name', 'repo-name', '6dcb09b5b57875f334f61aebed6')
+      #
+      def get_commit(user, repo, sha)
+        get("/repos/#{user}/#{repo}/commits/#{sha}")
+      end
+
+      # Gets a single commit comment
+      # 
+      # = Examples
+      #  @github = Github.new
+      #  @github.repos.get_comment 'user-name', 'repo-name', 'comment-id'
+      #
+      def get_comment(user, repo, comment_id)
+        get("/repos/#{user}/#{repo}/comments/#{comment_id}")
+      end
+
+      # Gets a single commit
+      #
+      def get_commit(user, repo, sha)
+        get("/repos/#{user}/#{repo}/commits/#{sha}")
+      end
+      
+      # Update a commit comment
+      #
+      # = Examples
+      #  @github = Github.new
+      #  @github.repos.update_comment(...)
+      #
+      def update_comment(user, repo, comment_id)
+        raise ArgumentError, "expected following inputs to the method: 'body'" unless _validate_inputs(["body"], inputs)
+        patch("/repos/#{user}/#{repo}/comments/#{comment_id}")
+      end
+      
+    end # Commits
+  end # Repos
+end # Github

data/lib/github_api/repos/downloads.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+
+module Github
+  class Repos
+    module Downloads
+      
+      REQUIRED_PARAMS = %w[ name size ]
+      VALID_PARAMS = %w[ name size description content_type ]
+
+      REQUIRED_S3_PARAMS = %w[ key acl success_action_status Filename AWSAccessKeyId Policy Signature Content-Type file ]
+
+      # List downloads for a repository
+      #
+      # GET /repos/:user/:repo/downloads
+      #
+      def downloads(user, repo)
+        get("/repos/#{user}/#{repo}/downloads")
+      end
+
+      # Get a single download
+      #
+      # GET /repos/:user/:repo/downloads/:id
+      #
+      def get_download(user, repo, download_id)
+        get("/repos/#{user}/#{repo}/downloads/#{download_id}")
+      end
+
+      # Delete download from a repository
+      #
+      # DELETE /repos/:user/:repo/downloads/:id
+      #
+      def delete_download(user, repo, download_id)
+        delete("/repos/#{user}/#{repo}/downloads/#{download_id}")
+      end
+
+      # Creating a new download is a two step process. 
+      # You must first create a new download resource using this method.
+      # Response from this method is to be used in #upload method.
+      #
+      # POST /repos/:user/:repo/downloads
+      #
+      def create_download(user, repo, params={})
+        _normalize_params_keys(params)
+        raise ArgumentError, "expected following inputs to the method: #{REQUIRED_INPUTS.join(', ')}" unless _valid_inputs(REQUIRED_PARAMS, params)
+        _filter_params_keys(VALID_PARAMS, params)
+
+        post("/repos/#{user}/#{repo}/downloads", params)
+      end
+        
+      # Upload a file to Amazon, using the reponse instance from 
+      # Github::Repos::Downloads#create. This can be done by passing 
+      # the response object as an argument to upload method.
+      #
+      def upload(result, file)
+        REQUIRED_S3_PARAMS.each do |key|
+          raise ArgumentError, "expected following keys: #{REQUIRED_S3_PARAMS.join(', ')}" unless result.respond_to?(key) 
+        end
+        
+        # TODO use ordered hash if Ruby < 1.9
+        mapped_params = {
+          "key"                   => result.path,
+          "acl"                   => result.acl,
+          "success_action_status" => 201,
+          "Filename"              => result.name,
+          "AWSAccessKeyId" => result.accesskeyid,
+          "Policy" => result.policy,
+          "Signature" => result.signature,
+          "Content-Type" => result.mime_type,
+          "file" => file 
+        }
+        
+        post(result.s3_url, mapped_params)
+      end
+
+    end # Downloads
+  end # Repos
+end # Github

data/lib/github_api/repos/forks.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+module Github
+  class Repos
+    module Forks
+      
+      # List forks 
+      #
+      # GET /repos/:user/:repo/forks
+      #
+      # Examples
+      #
+      def forks(user, repo)
+        get("/repos/#{user}/#{repo}/forks")
+      end
+      
+      # Create a fork for the authenticated user
+      # 
+      # POST /repos/:user/:repo/forks
+      #
+      def create_fork(user, repo, params={})
+        _normalize_params_keys(params)
+        _filter_params_keys(%w[ org ], params)
+
+        post("/repos/#{user}/#{repo}/forks", params)
+      end
+    end
+  end
+end # Github

data/lib/github_api/repos/hooks.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+
+module Github
+  class Repos
+    module Hooks
+
+      REQUIRED_PARAMS = %w[ name config ]
+
+      # List repository hooks
+      # 
+      # GET /repos/:user/:repo/hooks
+      #
+      def hooks(user, repo)
+        get("/repos/#{user}/#{repo}/hooks")
+      end
+
+      # Get a single hook 
+      #
+      # GET /repos/:user/:repo/hooks/:id
+      #
+      def get_hook(user, repo, hook_id)
+        get("/repos/#{user}/#{repo}/hooks/#{hook_id}")
+      end
+
+      # Create a hook
+      #
+      # POST /repos/:user/:repo/hooks
+      #
+      def create_hook(user, repo, params)
+        _normalize_params_keys(params)
+        _filter_params_keys(%w[ name config active ], params)
+        raise ArgumentError, "Required parameters are: #{REQUIRED_PARAMS.join(', ')}" unless _validate_inputs(REQUIRED_PARAMS, params)
+
+        post("/repos/#{user}/#{repo}/hooks", params)
+      end
+
+      # Edit a hook
+      #
+      # PATCH /repos/:user/:repo/hooks/:id
+      # 
+      def edit_hook(user, repo, hook_id, params)
+        _normalize_params_keys(params)
+        _filter_params_keys(%w[ name config active ], params)
+        raise ArgumentError, "Required parameters are: #{REQUIRED_PARAMS.join(', ')}" unless _validate_inputs(REQUIRED_PARAMS, params)
+
+        patch("/repos/#{user}/#{repo}/hooks/#{hook_id}")
+      end
+
+      # Test a hook
+      #
+      # POST /repos/:user/:repo/hooks/:id/test
+      #
+      def test_hook(user, repo, hook_id)
+        post("/repos/#{user}/#{repo}/hooks/#{hook_id}/test")
+      end
+
+      # Delete a hook
+      #
+      # DELETE /repos/:user/:repo/hooks/:id
+      #
+      def delete_hook(user, repo, hook_id)
+        delete("/repos/#{user}/#{repo}/hooks/#{hook_id}")
+      end
+
+    end # Hooks
+  end # Repos
+end # Github

data/lib/github_api/repos/keys.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+module Github
+  class Repos
+    module Keys
+      
+      # List keys
+      #
+      # GET /repos/:user/:repo/keys
+      #
+      def keys(user, repo)
+        get("/repos/#{user}/#{repo}/keys")
+      end
+
+      # Get a key
+      #
+      # GET /repos/:user/:repo/keys/:id
+      #
+      def get_key(user, repo, key_id)
+        get("/repos/#{user}/#{repo}/keys/#{key_id}")
+      end
+
+      # Create a key
+      #
+      # POST /repos/:user/:repo/keys
+      def create_key(user, repo, params={})
+        _normalize_params_keys(params)
+        _filter_params_keys(%w[ title key ], params)
+
+        post("/repos/#{user}/#{repo}/keys", params)
+      end
+
+      # Edit key
+      #
+      # PATCH /repos/:user/:repo/keys/:id
+      #
+      def edit_key(user, repo, key_id)
+        _normalize_params_keys(params)
+        _filter_params_keys(%w[ title key ], params)
+
+        patch("/repos/#{user}/#{repo}/keys/#{key_id}")
+      end
+      
+      # Delete key
+      #
+      # DELETE /repos/:user/:repo/keys/:id
+      def delete_key(user, repo, key_id)
+        delete("/repos/#{user}/#{repo}/keys/#{key_id}")
+      end
+
+    end # Keys
+  end # Repos
+end # Github

data/lib/github_api/repos/watching.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+module Github
+  class Repos
+    module Watching
+      
+      # List repo watchers
+      #
+      # GET /repos/:user/:repo/watchers
+      #
+      def watchers
+        get("/repos/#{user}/#{repo}/watchers")
+      end
+      
+      # List repos being watched
+      def watched(user=nil)
+        if user
+          get("/users/#{user}/watched")
+        else
+          get("/user/watched")
+        end
+      end
+
+      # Check if you are watching a repo
+      #
+      # GET /user/watched/:user/:repo
+      #
+      def watching?(user, repo)
+        get("/user/watched/#{user}/#{repo}")
+      end
+
+      # Watch a repo 
+      #
+      # PUT /user/watched/:user/:repo
+      #
+      def start_watching(user, repo)
+        put("/user/watched/#{user}/#{repo}")
+      end
+      
+      # Stop watching a repo
+      #
+      # DELETE /user/watched/:user/:repo
+      #
+      def stop_watching(user, repo)
+        delete("/user/watched/#{user}/#{repo}")
+      end
+
+    end
+  end
+end

data/lib/github_api/request.rb

@@ -0,0 +1,75 @@
+# encoding: utf-8
+
+require 'base64'
+require 'addressable/uri'
+require 'set'
+
+module Github
+  # Defines HTTP verbs
+  module Request
+    
+    METHODS = [:get, :post, :put, :delete, :patch]
+    METHODS_WITH_BODIES = [ :post, :put, :patch ]
+
+    TOKEN_REQUIRED_REGEXP = [
+      /repos\/.*\/.*\/comments/,
+    ]
+
+    def get(path, params={}, options={})
+      request(:get, path, params, options)
+    end
+
+    def patch(path, params={}, options={})
+      request(:patch, path, params, options)
+    end
+
+    def post(path, params={}, options={})
+      request(:post, path, params, options)
+    end
+
+    def put(path, params={}, options={})
+      request(:put, path, params, options)
+    end
+
+    def delete(path, params={}, options={})
+      request(:delete, path, params, options)
+    end
+
+    def request(method, path, params, options)
+      if !METHODS.include?(method)
+        raise ArgumentError, "unkown http method: #{method}"
+      end
+
+      puts "EXECUTED: #{method} - #{path} with #{params} and #{options}"
+
+      response = connection(options).send(method) do |request|
+        case method.to_sym
+        when *(METHODS - METHODS_WITH_BODIES)
+          request.url(path, params)
+        when *METHODS_WITH_BODIES
+          request.path = path
+          request.body = _process_params(params) unless params.empty?
+        end
+      end
+      response.body
+    end
+
+    def _process_params(params)
+      return params['data'] if params.has_key?('data')
+      return params
+    end
+    # no need for this smizzle
+    def formatted_path(path, options={})
+      [ path, options.fetch(:format, format) ].compact.join('.')
+    end
+
+    def basic_auth(login, password)
+      auth = Base64.encode("#{login}:#{password}")
+      auth.gsub!("\n", "")
+    end
+
+    def token_auth
+    end
+
+  end # Request
+end # Github